杨辉三角

杨辉三角1

输入: 5

输出:

[

     [1],

    [1,1],

   [1,2,1],

  [1,3,3,1],

 [1,4,6,4,1]

]

 

 

import java.util.*;
public class Solution {
    /**
     *
     * @param numRows int整型
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> generate (int numRows) {
       ArrayList<ArrayList<Integer>> trangle=new ArrayList<>();//定义三角矩阵
         if(numRows==0) return trangle;
         //trangle定义类型及第一个元素为1
         trangle.add(new ArrayList<>());
         trangle.get(0).add(1);
         //
        for(int i=1;i<numRows;i++){
            ArrayList<Integer> row=new ArrayList<>();//定义当前行
            ArrayList<Integer> prerow=trangle.get(i-1);//定义前一行
            //第i(i>1)行第一个元素
            row.add(1);
            //其他的元素就是上+左上
            for(int j=1;j<i;j++){// j一定小于i
                row.add(prerow.get(j-1)+prerow.get(j));
            }
            //每行最后一个元素为1
            row.add(1);
            trangle.add(row);
        }
        return trangle;
        }
    }

杨辉三角2

给出一个索引k，返回杨辉三角的第k行

例如，k=3，

返回[1,3,3,1].

备注：

你能将你的算法优化到只使用O(k)的额外空间吗?

法一：暴力算法

解题思路：

1.定义cur(当前值),pre（保存上一层的值）

2.遍历第一列和对角线即为1

3.递归剩下的值为上+左,cur.add()

4.更新pre记录，记录以前的值

import java.util.*;
public class Solution {
    /**
     *
     * @param rowIndex int整型
     * @return int整型ArrayList
     */
    public ArrayList<Integer> getRow (int rowIndex) {
        ArrayList<Integer>cur=new ArrayList<>();
        ArrayList<Integer> pre=new ArrayList<>();
        for(int i=0;i<=rowIndex;i++){
            cur=new ArrayList<>();
            for(int j=0;j<=i;j++){
                if(j==0||j==i){
                    cur.add(1);
                } 
                else{
                    cur.add(pre.get(j-1)+pre.get(j));
                }
            }
            pre=cur;
        }
        return cur;
    }
}

法二：

 

解题思路：（pre 的 List 省去，cur每次不去新建 List，而是把cur当作pre。）

1.定义cur(当前值),pre=1

2.每次循环以前，第一列为1

3.temp临时保存当前值,更新当前j的时候，就把之前j的信息覆盖掉了。而更新 j + 1 的时候又需要之前j的信息，所以在更新前，我们需要一个变量把之前j的信息保存起来

4.递归cur.set(),改变j下标的值即为上+左

5.更新pre记录，记录以前的值

6.每次循环以后，最后一列为1

import java.util.*;
public class Solution {
    /**
     *
     * @param rowIndex int整型
     * @return int整型ArrayList
     */
    public ArrayList<Integer> getRow (int rowIndex) {
        ArrayList<Integer>cur=new ArrayList<>();
        //ArrayList<Integer> pre=new ArrayList<>();
        int pre=1;
        //第一列为1
        cur.add(1);
        for(int i=1;i<=rowIndex;i++){
            for(int j=1;j<i;j++){
                 int temp=cur.get(j);//temp临时保存
                 cur.set(j,pre+cur.get(j));//相当于cur.get(j-1)+cur.get(j)
                 pre=temp;
                }
            //最后一列
            cur.add(1);
            }
        return cur;
    }

法三：

优化：倒着进行，这样就不会存在覆盖的情况了

解题思路：

1.定义cur(当前值),pre=1

2.每次循环以前，第一列为1

3.从后向前进行递归，更新完j的信息后，虽然把j之前的信息覆盖掉了。但是下一次我们更新的是j - 1，需要的是j - 1和j - 2 的信息，j信息覆盖就不会造成影响了。

4.递归cur.set(),改变j下标的值即为上+左

5.每次循环以后，最后一列为1

import java.util.*;
public class Solution {
    /**
     *
     * @param rowIndex int整型
     * @return int整型ArrayList
     */
    public ArrayList<Integer> getRow (int rowIndex){
        ArrayList<Integer>cur=new ArrayList<>();
        //ArrayList<Integer> pre=new ArrayList<>();
        int pre=1;
        //第一列为1
        cur.add(1);
        for(int i=1;i<=rowIndex;i++){
            for(int j=i-1;j>0;j--){
                 cur.set(j,cur.get(j-1)+cur.get(j));
                }
            //最后一列
            cur.add(1);
            }
        return cur;
    }
    }