【持续更新】leetcode算法-数组篇

会在近期陆续地完成数组篇的整理，希望对找工作的小伙伴有所帮助。

 

1、Two Sum：两数相加为一固定值，求其下标。一次遍历数组，用一个hash表存储已经访问过的数及其下标，对于新访问的数value，查hash表中是否有target-value的值，如果有，程序输出，如果没有，继续访问下一个数直到访问完。

 

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> hash = new HashMap<>();
    for (int i=0; i<nums.length; i++){
        if(hash.containsKey(target-nums[i])){
            return new int[]{hash.get(target-nums[i]),i};
        }else{
            hash.put(nums[i],i);
        }
    }
    return new int[]{0,0};
}

 

2、Median of Two Sorted Arrays：求两个有序数组的中位数。其实就是求第k大的数。首先比较两数组k/2处的数的大小，若a[k/2]<b[k/2]，则a[0,...k/2]可以省去，则求剩余数组k-k/2大的数，依次下去，知道k=1，求第1大的数，即比较两数组的第一个元素，取小的那个。

 

3、Container With Most Water：给一个数组，每一个元素表示一个高度，找两个元素和x轴围城的容器装下水的最大量。直接的做法是暴力求解，O（n2）复杂度。优化做法是，从两头向中间靠，比较两头元素的大小，大的不动，小的往中间移动。

 

public int maxArea(int[] height) {
    int max = 0;
    int left = 0;
    int right = height.length - 1;
    int curArea = 0;
    while (left < right) {
        curArea = (right - left) * (height[right] < height[left] ? height[right--] : height[left++]);
        if (curArea > max)
            max = curArea;
    }
    return max;
}

 

4、3Sum：在数组中求三个数相加等于0。先排序，然后遍历数组，两重循环。3个指针，外层循环遍历数组，内层循环遍历外层循环后面的数，如果和大于0，则指针往左移动，如果小于0，则往右移动。

 

public List<List<Integer>> threeSum(int[] nums) {
    List<List<Integer>> list = new ArrayList<List<Integer>>();
    Set<List<Integer>> set = new HashSet<>();
    sort(nums);
    int j = 0;
    int k = 0;
    for (int i = 0; i < nums.length - 2; i++) {
        j = i + 1;
        k = nums.length - 1;
        while (j < k) {
            int x = nums[i] + nums[j] + nums[k];
            if (x == 0) {
                List<Integer> innerList = new ArrayList<>();
                innerList.add(nums[i]);
                innerList.add(nums[j]);
                innerList.add(nums[k]);
                if (!set.contains(innerList)) {
                    set.add(innerList);
                    list.add(innerList);   
                }
                j = j + 1;
                k = k - 1;
            } else if (x > 0) {
                k = k - 1;
            } else {
                j = j + 1;
            }
        }
    }
    return list;
}

 

5、3Sum Closest：类似3Sum

 

6、4Sum：类似3Sum

 

7、Remove Duplicates from Sorted Array：有序数组去重，返回剩余数的个数

 

public int removeDuplicates(int[] nums) {
    if (nums.length == 0)    return 0;
    int index = 0;
    for (int i = 1; i < nums.length; i++) {
        if (nums[index] != nums[i]) {
            nums[++index] = nums[i];
        }
    }
    return index + 1;
}

 

8、Remove Element：数组中移除给定的数，返回剩余数的个数

 

public int removeElement(int[] nums, int val) {
    int index=0;
    for(int i =0; i<nums.length; i++){
        if(nums[i] != val) nums[index++]=nums[i];
    }
    return index;
}

 

9、Next Permutation：数组表示一个整数，返回下一个排列数，如果没有比原数组大的排列数，则返回最小的排列数

 

public void nextPermutation(int[] nums) {
    if(nums==null || nums.length<2) return;
    int len = nums.length;
    // 从右向左遍历，找到第一个前一个数小于后一个的数（升序对），记value=nums[i-1]
    int i = len - 1;
    while (i>0 && nums[i-1]>=nums[i]){
        i--;
    }
    if(i==0){
        reverse(nums, 0, len-1);     // 反转数组
    }else{
        // 从右向左遍历，找到第一个大于value的数
        int j = i-1;
        int k = len -1;
        while(nums[j]>=nums[k]){
            k--;
        }
        int temp = nums[j];
        nums[j] = nums[k];
        nums[k] = temp;
        reverse(nums, i, len-1);
    }
}

 

10、Search in Rotated Sorted Array：在循环有序的数组（数没有重复）中查询一个数，返回这个数的下标，没有则返回-1

 

public int search(int[] nums, int target) {
    if(nums==null || nums.length==0) return -1;
    // 找到最小值，即旋转中心
    int n=nums.length;
    int lo=0, hi=n-1;
    while(lo<hi){
        int mid=(hi-lo)/2+lo;
        if(nums[mid]>nums[hi]) lo=mid+1;
        else hi=mid;
    }
    int pivot=lo;
    lo=0;
    hi=n-1;
    while(lo<=hi){
        int mid=(hi-lo)/2+lo;
        int realmid=(mid+pivot)%n;
        if(nums[realmid]==target) return realmid;
        else if(nums[realmid]>target) hi=mid-1;
        else lo=mid+1;
    }
    return -1;
}

 

11、Search for a Range：找到给定的数在有序数组中的下标区间，两次二分搜索，一次找左边界，一次找右边界

 

public int[] searchRange(int[] nums, int target) {
    int[] ret = {-1,-1};
    if(nums==null || nums.length==0) return nums;
    int n=nums.length;
    int lo=0, hi=n-1;
    while(lo<hi){
        int mid=(hi-lo)/2+lo;
        if(nums[mid]<target) lo=mid+1;
        else hi=mid;
    }
    if(nums[lo]!=target) return ret;
    ret[0]=lo;
 
    lo=0;
    hi=n-1;
    while(lo<hi){
        int mid=(hi-lo)/2+lo+1;     // 保证偏向右边
        if(nums[mid]>target) hi=mid-1;
        else lo=mid;
    }
    ret[1]=lo;
    return ret;
}

 

12、Search Insert Position：二分查找

 

13、Combination Sum：求数组中元素等于给定的数的集合，允许重复，回溯法

 

public List<List<Integer>> combinationSum(int[] candidates, int target) {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    if(candidates == null || candidates.length == 0)
        return res;
    List<Integer> list = new ArrayList<>();
    helper(candidates, target, 0, list, res);
    return res;
}
public void helper(int[] candidates, int target, int start, List<Integer> temp, List<List<Integer>> res) {
    if(target == 0){
        res.add(new ArrayList<>(temp));
        return;
    }
    if(target < 0) return;
    for (int i = start; i < candidates.length; i++){
        temp.add(candidates[i]);
        helper(candidates, target-candidates[i], i, temp, res);
        temp.remove(temp.size() - 1);
    }
}

 

14、Combination Sum II：求数组中元素等于给定的数的集合，数组中的元素只能用一次，回溯法

 

public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    if(candidates.length == 0 || candidates == null)
        return res;
    List<Integer> list = new ArrayList<>();
    Arrays.sort(candidates);
    helper(candidates, target, 0, list, res);
    return res;
}
public void helper(int[] candidates, int target, int start, List<Integer> temp, List<List<Integer>> res) {
    if(target == 0){
        res.add(new ArrayList<>(temp));
        return;
    }
    else if(target < 0)
        return;
    else {
        for (int i = start; i < candidates.length; i++){
            // 跳过重复元素
            if(i>start && candidates[i]==candidates[i-1])
                continue;
            temp.add(candidates[i]);
            helper(candidates, target-candidates[i], i+1, temp, res);
            temp.remove(temp.size() - 1);
        }
    }
}

 

15、First Missing Positive：无序数组，找到第一个缺失的正数，主要思想是将正确的数放到正确的位置上

 

public int firstMissingPositive(int[] nums) {
    if(nums == null || nums.length == 0) return 1;
    int n = nums.length;
    for (int i=0; i<n; i++){
        while(nums[i]>0 && nums[i]<=n && nums[i]!=nums[nums[i]-1]) swap(nums, i, nums[i]-1);
    }
    for(int i=0; i<n; i++){
        if(nums[i]!=i+1) return i+1;
    }
    return n+1;
}

 

16、Trapping Rain Water：求最大的积水量。解法：先找到最大高度的下标，然后分别从两边往最大高度靠，同时维护一个当前最大值变量，积水量就是当前最大值减去当前高度。

 

public int trap(int[] height) {
    if (height==null || height.length <= 2) return 0;
    // 找最大高度
    int maxIndex=0;
    int max=0;
    for(int i=0; i<height.length; i++){
        if(height[i]>max){
            max=height[i];
            maxIndex=i;
        }
    }
    int result=0;
    int curMax=0;
    for(int i=0; i<maxIndex; i++){
        if(height[i]<curMax){
            result += curMax-height[i];
        }else{curMax=height[i];}
    }
    curMax=0;
    for(int i=height.length-1; i>maxIndex; i--){
        if(height[i]<curMax) result += curMax-height[i];
        else curMax=height[i];
    }
    return result;
}

17、Jump Game II：给定一个数组，求数组头到数组尾的最少的步数。贪心法。

 

public int jump(int[] nums) {
    if(nums==null || nums.length==0) return 0;
    int dis=0;
    int edge=0;
    int steps=0;
    for(int i=0; i<nums.length-1 && i<=dis; i++){
        dis=Math.max(dis, i+nums[i]);
        if(dis>=nums.length-1) return steps+1;
        // 判断是否在一次跳转之内，只有等于最大边界时才会步数加1
        if(edge == i){
            edge = dis;
            steps++;
        }
    }
    return 0;
}

18、Rotate Image：顺时针旋转n*n矩阵。先转置，再左右翻转。

 

public void rotate(int[][] matrix) {
    if(matrix==null || matrix.length==0) return;
    int n = matrix.length;
    int tmp;
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < n; ++j) {
            tmp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = tmp;
        }
    }
    for(int i=0; i<n; i++){
        reverse(matrix[i]);
    }
}

19、Maximum Subarray：求数组的最大子串和。

 

public int maxSubArray(int[] nums) {
    if(nums==null || nums.length==0) return 0;
    int max=nums[0];
    int curSum=0;
    for(int i=0; i<nums.length; i++){
        curSum=Math.max(nums[i], curSum+nums[i]);
        max=Math.max(max, curSum);
    }
    return max;
}

20、Spiral Matrix：螺旋输出矩阵的元素

 

public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> res = new ArrayList<>();
    int m = matrix.length;
    if (m < 1) return res;
    int n = matrix[0].length;
    int left = 0;
    int right = n-1;
    int up = 0;
    int down = m-1;
    while (left <= right && up <= down) {
        // traverse right
        for (int i = left; i <= right; i++) {
            res.add(matrix[up][i]);
        }
        up++;
        // traverse down
        for (int i = up; i <= down; i++) {
            res.add(matrix[i][right]);
        }
        right--;
        // traverse left
        if (up <= down) {
            for (int i = right; i >= left; i--) {
                res.add(matrix[down][i]);
            }
        }
        down--;
        // traverse up
        if (left <= right) {
            for (int i = down; i >= up; i--) {
                res.add(matrix[i][left]);
            }
        }
        left++;
    }

    return res;
}

21、Jump Game：给定一个数组，判断能否从数组头到达数组尾。贪心法。维护一个变量，记录当前位置能到达的最远的距离，当最远距离超出数组长度，即可判断能到达数组尾。

 

public boolean canJump(int[] nums) {
    if(nums==null || nums.length==0) return false;
    int dis=0;
    for(int i=0; i<nums.length && i<=dis; i++){
        dis = Math.max(dis, i+nums[i]);
        if(dis >= nums.length-1) return true;
    }
    return false;
}

22、Merge Intervals：合并区间。先按照区间的前端进行排序操作，再查看是否出现覆盖的情况。

 

public List<Interval> merge(List<Interval> intervals) {
    List<Interval> res = new ArrayList<>();
    int n = intervals.size();
    if (n < 1) return res;
    // Sort by ascending starting point using an anonymous Comparator
    Collections.sort(intervals, new Comparator<Interval>() {
        @Override
        public int compare(Interval i1, Interval i2) {
            return Integer.compare(i1.start, i2.start);
        }
    });
    int start = intervals.get(0).start;
    int end = intervals.get(0).end;
    for(int i=1; i<n; i++){
        Interval curInteval = intervals.get(i);
        if(curInteval.start <= end){
            end = Math.max(end, curInteval.end);
        }
        else{
            res.add(new Interval(start, end));
            start = curInteval.start;
            end = curInteval.end;
        }
    }
}

23、Insert Interval：给定一个按前端排好序的区间数组，现有另外一个区间，求插入并合并后的区间。

 

public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
    int i=0;
    while(i < intervals.size() && intervals.get(i).end < newInterval.start) i++;          // 是否可以用二分找到这个i？
    while(i<intervals.size() && intervals.get(i).start <= newInterval.end){
        newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));
        intervals.remove(i);
    }
    intervals.add(i,newInterval);
    return intervals;
}

24、Spiral Matrix II：生成螺旋的矩阵

 

public int[][] generateMatrix(int n) {
    int[][] matrix = new int[n][n];
    if (n < 1)
        return matrix;
    int count = 1;
    int left = 0;
    int right = n-1;
    int up = 0;
    int down = n-1;
    while (left <= right && up <= down) {
        for (int i = left; i <= right; i++) {
            matrix[up][i] = count;
            count++;
        }
        up++;
        for (int i = up; i <= down; i++) {
            matrix[i][right] = count;
            count++;
        }
        right--;
        if (up <= down) {
            for (int i = right; i >= left; i--) {
                matrix[down][i] = count;
                count++;
            }
            down--;
        }
        if (left <= right) {
            for (int i = down; i >= up; i--) {
                matrix[i][left] = count;
                count++;
            }
            left++;
        }
    }
    return matrix;
}

25、Unique Paths：求从左上到右下的路径数。

 

public int uniquePaths(int m, int n) {
    int[] paths = new int[n+1];
    Arrays.fill(paths, 1);
    paths[0] = 0;
    for(int i=0; i<m-1; i++){
        for(int j=0; j<n; j++){
            paths[j+1] = paths[j+1] + paths[j];
        }
    }
    return paths[n];
}

26、Unique Paths II：存在障碍的情况下，求从左上到右下的路径数。

 

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    int n = obstacleGrid.length;
    int m = obstacleGrid[0].length;
    int[][] p = new int[n][m];
    // 初始化第一行
    for (int i = 0; i < m; i++){
        p[0][i] = 1 - obstacleGrid[0][i];
        if (p[0][i] == 0)   break;
    }
    // 初始化第一列
    for (int j = 0; j < n; j++){
        p[j][0] = 1 - obstacleGrid[j][0];
        if (p[j][0] == 0) break;
    }
    for ( int i = 1; i < n; i++){
        for (int j = 1; j < m; j++) {
            if(obstacleGrid[i][j] == 1)
                p[i][j] = 0;
            else p[i][j] = p[i-1][j] + p[i][j-1];
        }
    }
    return p[n-1][m-1];
}

27、Minimum Path Sum：求从左上到右下的最小的路径的长度，只能向右或向下走。

 

public int minPathSum(int[][] grid) {
    if(grid==null || grid.length==0) return 0;
    int m = grid.length;
    int n = grid[0].length;
    int[][] p = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0)
                p[i][j] = grid[i][j];
            else if (i == 0 && j > 0)
                p[i][j] = p[i][j-1] + grid[i][j];
            else if (i > 0 && j == 0)
                p[i][j] = p[i-1][j] + grid[i][j];
            else
                p[i][j] = Math.min(p[i-1][j], p[i][j-1]) + grid[i][j];
        }
    }
    return p[m-1][n-1];
}

28、Plus One：数组加1

 

public int[] plusOne(int[] digits) {
    int carry = 1;
    for(int i=digits.length-1; i>=0; i--){
        carry += digits[i];
        digits[i] = carry % 10;
        carry /= 10;
    }
    if(carry==0) return digits;
    else{
        int[] newdigits = new int[digits.length+1];
        newdigits[0]=1;
        for(int i=1; i<newdigits.length; i++){
            newdigits[i]=digits[i-1];
        }
        return newdigits;
    }
}

29、Set Matrix Zeroes：当(i,j)=0是，把第i行和第j列置为0

 

public void setZeroes(int[][] matrix) {
    boolean col0 = false;
    for (int i = 0; i < matrix.length; i++) {
        if(matrix[i][0]==0) col0=true;
        for (int j = 1; j < matrix[0].length; j++) {
            if (matrix[i][j] == 0) {
                matrix[0][j] = 0;
                matrix[i][0] = 0;
            }
        }
    }
    for (int i = matrix.length-1; i>=0; i--) {
        for (int j = matrix[0].length-1; j>=1; j--) {
            if (matrix[0][j] == 0 || matrix[i][0] == 0) {
                matrix[i][j] = 0;
            }
        }
        if(col0) matrix[i][0]=0;
    }
}

30、Search a 2D Matrix：在矩阵里查找数。二分查找

 

public boolean searchMatrix(int[][] matrix, int target) {
    if(matrix==null || matrix[0].length==0) return false;
    int m=matrix.length;
    int n=matrix[0].length;
    int lo=0;
    int hi=m*n-1;
    int mid;
    while(lo<=hi){
        mid=(hi-lo)/2+lo;
        int row=mid/n;
        int col=mid%n;
        if(matrix[row][col]==target) return true;
        else if(matrix[row][col] > target) hi = mid-1;
        else lo = mid + 1;
    }
    return false;
}

31、Sort Colors：给定一个数组，元素只有0,1,2，给它排序。可以用计数排序，也可以用交换。

 

public void sortColors(int[] nums) {
    if(nums==null || nums.length==0) return;
    int lo=0;
    int hi=nums.length-1;
    int i=0;
    while(i<=hi){
        if(nums[i]==0) swap(nums, i++, lo++);
        else if(nums[i]==2) swap(nums, i, hi--);
        else{i++;}
    }
}

32、Subsets：求一个集合的所有子集

 

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    res.add(list);
    for(int i=0; i<nums.length; i++){
        int size = res.size();
        for(int k=0; k<size; k++){
            List<Integer> newList = new ArrayList<>(res.get(k));
            newList.add(nums[i]);
            res.add(newList);
        }
    }
    return res;
}

public List<List<Integer>> subsets(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> res = new ArrayList<>();
    int totalNumber = 1 << nums.length;
    for(int i=0; i<totalNumber; i++){
        List<Integer> set = new ArrayList<>();
        for(int j=0; j<nums.length; j++){
            if(((i>>>j) & 0x1) == 1) set.add(nums[j]);
        }
        res.add(set);
    }
    return res;
}

33、Word Search： 在二维字符数组中，查找单词，回溯法

 

public boolean exist(char[][] board, String word) {
    for(int i = 0; i < board.length; i++)
        for(int j = 0; j < board[0].length; j++){
            if(exist(board, i, j, word, 0)) return true;
        }
    return false;
}
private boolean exist(char[][] board, int i, int j, String word, int ind){
    if(ind == word.length()) return true;
    if(i > board.length-1 || i <0 || j<0 || j >board[0].length-1 || board[i][j]!=word.charAt(ind)) return false;
    char ch=board[i][j];
    board[i][j]='*';
    boolean result =    exist(board, i-1, j, word, ind+1) ||
                        exist(board, i, j-1, word, ind+1) ||
                        exist(board, i, j+1, word, ind+1) ||
                        exist(board, i+1, j, word, ind+1);
    board[i][j] = ch;
    return result;
}

34、Remove Duplicates from Sorted Array II： 数组已排序，去除数组中重复的元素，允许出现两次

 

public int removeDuplicates(int[] nums) {
    if(nums.length <= 2) return nums.length;
    int index=0;
    int p=1;
    int counter=1;
    while(p<nums.length){
        if(nums[p] == nums[index]){
            if(counter == 2){
                p++;
            }
            else{
                nums[++index] = nums[p];
                p++;
                counter = 2;
            }
        }
        else {
            nums[++index] = nums[p];
            p++;
            counter = 1;
        }
    }
    return index+1;
}

35、Search in Rotated Sorted Array II： 在循环有序数组中查找，数组中有重复的数

public class Solution {
    public boolean search(int[] nums, int target) {
        if (nums.length < 1)
            return false;
        int start = 0;
        int end = nums.length - 1;
        while (start < end) {
            int mid = start + (end-start)/2;
            if (nums[mid] == target) return true;

            if (nums[start] < nums[mid]) {
                if (target < nums[mid] && target >= nums[start])
                    end = mid - 1;
                else start = mid + 1;
            }
            else if (nums[start] > nums[mid]){
                if (target > nums[mid] && target <= nums[end])
                    start = mid + 1;
                else end = mid - 1;
            }
            else {
                start++;
            }
        }
        return target == nums[start];
    }
}

 

36、Largest Rectangle in Histogram： 求最大的长方形面积

 

public int largestRectangleArea(int[] heights) {
    int maxArea = 0;
    Stack<Integer> stack = new Stack<>();
    int i=0;
    int height = 0;
    int area = 0;
    while(i <= heights.length){
        if(i < heights.length) height = heights[i];
        else height = 0;
        if(stack.isEmpty() || height >= heights[stack.peek()]){
            stack.push(i++);
        }
        else{
            int index = stack.pop();
            if(stack.isEmpty()) area = i * heights[index];
            else {
                area = (i-stack.peek()-1) * heights[index];
            }
            maxArea = Math.max(area, maxArea);
        }
    }
    return maxArea;
}

37、Maximal Rectangle： 利用36题结论

 

public int maximalRectangle(char[][] matrix) {
    int m = matrix.length;
    if (m < 1){
        return 0;
    }
    int n = matrix[0].length;
    int[][] heights = new int[m][n+1];
    for(int i = 0; i < m; i++){
        for(int j = 0; j < n; j++) {
            if(matrix[i][j] == '0'){
                heights[i][j] = 0;
            }else {
                heights[i][j] = i == 0 ? 1 : heights[i - 1][j] + 1;
            }
        }
    }
    int maxArea=0;
    for(int i = 0; i < m; i++){
        int area = maxAreaInHist(heights[i]);
        if(area > maxArea){
            maxArea=area;
        }
    }
    return maxArea;
}

38、Merge Sorted Array： 类似于插入排序

 

39、Subsets II： 数组子集，数组中有重复的元素

 

public List<List<Integer>> subsetsWithDup(int[] nums) {
    int length = nums.length;
    Arrays.sort(nums);

    List<List<Integer>> res = new ArrayList<>();
    List<Integer> emptyList = new ArrayList<>();
    res.add(emptyList);

    for (int i = 0; i < length; i++) {
        int count = 1;
        while (i+1< length && nums[i] == nums[i+1]) {
            count++;
            i++;
        }
        int size = res.size();
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < count; k++) {
                List<Integer> newList = new ArrayList<>(res.get(j));
                for (int p = 0; p <= k; p++)
                    newList.add(nums[i]);
                res.add(newList);
            }
        }
    }
    return res;
}

40、Construct Binary Tree from Preorder and Inorder Traversal： 根据先序和中序遍历构建树

 

构建过程，在中序遍历中找根节点的下标可以用hashmap加速

41、Construct Binary Tree from Inorder and Postorder Traversal： 根据中序和后序遍历构建树

 

构建过程，在中序遍历中找根节点的下标可以用hashmap加速

42、Pascal's Triangle： 生成杨辉三角

 

public List<List<Integer>> generate(int numRows) {
    List<List<Integer>> res = new ArrayList<>();

    if (numRows < 1) return res;
    List<Integer> first = new ArrayList<>();
    first.add(1);
    res.add(first);
    for (int i = 2; i <= numRows; i++)
    {
        List<Integer> list = new ArrayList<>();
        List<Integer> preList = res.get(i-2);
        for (int j = 0; j < i; j++)
        {
            if (j == 0)
                list.add(1);
            else if (j == i-1)
                list.add(1);
            else
            {
                list.add(preList.get(j-1)+preList.get(j));
            }
        }
        res.add(list);
    }
    return res;
}

43、Pascal's Triangle II： 生成第k个杨辉三角

public List<Integer> getRow(int rowIndex) {
    List<Integer> res = new ArrayList<>();
    if (rowIndex < 0)
        return res;

    for (int i = 0; i <= rowIndex; i++)
    {
        res.add(0, 1);
        for (int j = 1; j < res.size()-1; j++)
        {
            res.set(j, res.get(j)+res.get(j+1));
        }
    }
    return res;
}

 

44、Triangle： 求最短路径

 

public int minimumTotal(List<List<Integer>> triangle) {
    if (triangle == null || triangle.size() == 0)
        return 0;

    int [] sum = new int[triangle.size()];
    for (int i = 0; i < triangle.size(); i++)
        sum[i] = triangle.get(triangle.size()-1).get(i);

    for (int i = triangle.size()-2; i >= 0; i--)
    {
        for (int j = 0; j <= i; j++)
            sum[j] = Math.min(sum[j], sum[j+1]) + triangle.get(i).get(j);
    }
    return sum[0];

}

45、Best Time to Buy and Sell Stock：

 

46、Best Time to Buy and Sell Stock II：

 

47、Best Time to Buy and Sell Stock III：

 

48、Word Ladder II：

 

49、Longest Consecutive Sequence：

 

50、Maximum Product Subarray：

 

51、Find Minimum in Rotated Sorted Array：

 

52、Find Minimum in Rotated Sorted Array II：

 

53、Find Peak Element：

 

54、Missing Ranges：

 

55、Two Sum II - Input array is sorted：

 

56、Majority Element：

 

57、Rotate Array：

 

58、Minimum Size Subarray Sum：

 

59、Combination Sum III：给定数k和n，求所有的k个数之和等于n的集合，其中k个数中不允许重复的数，并且数字大小为1到9。回溯法

 

public List<List<Integer>> combinationSum3(int k, int n)
{
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> temp = new ArrayList<>();
    boolean[] visited = new boolean[10];
    helper(k, n, 1, 0, visited, temp, result);
    return result;
}
public void helper(int k, int n, int start, int sum, boolean[] visited, List<Integer> temp, List<List<Integer>> res)
{
    if (sum == n && temp.size() == k){
        res.add(new ArrayList<>(temp));
        return;
    }
    if (sum > n || temp.size() > k) return;
    for (int i = start; i < 10; i++){
        if (visited[i])
            continue;
        if (temp.size() > 0 && temp.get(temp.size()-1) > i)
            continue;
        temp.add(i);
        visited[i] = true;
        helper(k, n, start+1, sum+i, visited, temp, res);
        temp.remove(temp.size()-1);
        visited[i] = false;
    }
}

 

60、Contains Duplicate：

 

61、Contains Duplicate II：

 

62、Summary Ranges：

 

63、Majority Element II：

 

64、Product of Array Except Self：

 

65、Shortest Word Distance：

 

66、Shortest Word Distance III：

 

67、3Sum Smaller：

 

68、Missing Number：

 

69、Find the Celebrity：

 

70、Wiggle Sort：

 

71、Move Zeroes：

 

72、Find the Duplicate Number：

 

73、Game of Life：

 

74、Range Addition：

 

75、Patching Array：给出一个从小到大排好序的整数数组nums和一个整数n，在数组中添加若干个补丁（元素）使得[1,n]的区间内的所有数都可以表示成nums中若干个数的和。返回最少需要添加的补丁个数。

public class Solution {
    /**
    定义一个当前数字i之前的数组合能到达的最小上界minUpper，如表示的数范围是1-m，则定义上界为minUpper=m+1
    循环如下：
    上界minUpper <= N：
        如果当前数字i <= minUpper：
            更新上界：minUpper = minUpper + i
        如果当前数字i > minUpper：说明需要添加补丁数字minUpper，并且更新此时的上界minUpper=minUpper+minUpper;
    */
    public int minPatches(int[] nums, int n) {
        int minUpper = 1;
        int index = 0;
        int missingCounter = 0;
        while (minUpper <= n) {
            if(index < nums.length && nums[index] <= minUpper) {
                minUpper += nums[index];
                index++;
            }
            else {
                //System.out.println(minUpper);
                minUpper += minUpper;
                missingCounter ++;
            }
        }
        return missingCounter;
    }
}