lettCode 数组

1. Merge Sorted Array 154
   描述：合并两排好序数组
   记忆：三标记，从后扫描，小剩继续

public void mergeSortedArray(int[] a, int m, int[] b, int n) {
        // write your code here
        if (a == null || b == null) {
            return;
        }
        int idx1 = m - 1;
        int idx2 = n - 1;
        int len = m + n - 1;
        while (idx1 >= 0 && idx2 >= 0) {
            if (a[idx1] > b[idx2]) {
                a[len--] = a[idx1--];
            } else {
                a[len--] = b[idx2--];
            }
        }
        while (idx2 >= 0) {
            a[len--] = b[idx2--];
        }
    }

2 First Missing Positive
描述：找无序数字丢失的最小正整数
记忆：

  public int firstMissingPositive(int[] A) {  
    if(A==null || A.length==0)  
    {  
        return 1;  
    }  
    for(int i=0;i<A.length;i++)  
    {  
        if(A[i]<=A.length && A[i]>0 && A[A[i]-1]!=A[i])  
        {  
            int temp = A[A[i]-1];  
            A[A[i]-1] = A[i];  
            A[i] = temp;  
            i--;  
        }  
    }  
    for(int i=0;i<A.length;i++)  
    {  
        if(A[i]!=i+1)  
            return i+1;  
    }  
    return A.length+1;  
}

3 Rotate Image
描述：旋转图像
记忆：定临时，四边转，看好不变量

   public void rotate(int[][] matrix) {
        // write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return;
        }

        int layerNum = matrix.length / 2;

        for (int layer = 0; layer < layerNum; layer++) {
            for (int i = layer; i < matrix.length - layer - 1; i++) {
                int temp = matrix[layer][i];
                matrix[layer][i] = matrix[matrix.length - i - 1][layer];
                matrix[matrix.length-i-1][layer] = matrix[matrix.length-layer-1][matrix.length-i-1];
                matrix[matrix.length-layer-1][matrix.length-i-1] = matrix[i][matrix.length-layer-1];
                matrix[i][matrix.length-layer-1] = temp;
            }
        }
    }  

4 Spiral Matrix lintCode-374
描述： 记录螺旋矩阵
记忆：按顺序记录，有剩再记

 public List<Integer> spiralOrder(int[][] matrix) {
        // Write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return res;
        }
        int min = Math.min(matrix.length, matrix[0].length);
        int levelNum = min / 2;
        for (int level = 0; level < levelNum; level++) {
            for (int i = level; i < matrix[0].length - level - 1; i++) {
                res.add(matrix[level][i]);
            }
            for (int i = level; i < matrix.length - level - 1; i++) {
                res.add(matrix[i][matrix[0].length - level - 1]);
            }
            for (int i = matrix[0].length - level - 1; i > level; i--) {
                res.add(matrix[matrix.length - level - 1][i]);
            }
            for (int i = matrix.length - level - 1; i > level; i--) {
                res.add(matrix[i][level]);
            }
        }
        if(min % 2 == 1) {
            if (matrix.length < matrix[0].length) {
            for (int i = levelNum; i < matrix[0].length - levelNum; i++) {
                res.add(matrix[levelNum][i]);
              }
             } else {
                for (int i = levelNum; i < matrix.length - levelNum; i++) {
                 res.add(matrix[i][levelNum]);
            }
          }
        }

        return res;
    }

5 Spiral Matrix II lintCode-381
描述：生成螺旋矩阵

public int[][] generateMatrix(int n) {
        // Write your code here
        if (n < 0) {
            return null;
        }
        int[][] res = new int[n][n];
        int levelNum = n / 2;
        int num = 1;
        for (int level = 0; level < levelNum; level++) {
            for (int i = level; i < n - level - 1; i++) {
                res[level][i] = num++;
            }
            for (int i = level; i < n - level - 1; i++) {
                res[i][n - level - 1] = num++;
            }
            for (int i = n - level - 1; i > level; i--) {
                res[n - level - 1][i] = num++;
            }
            for (int i = n - level - 1; i > level; i--) {
                res[i][level] = num++;
            }
        }
        if (n % 2 == 1) {
            res[levelNum][levelNum] = num;
        }
        return res;
    }

遍历
6 Two Sum lintCode-56
描述：给数组和和，反下标
记忆；HashMap 记录值和下标

1 public int[] twoSum(int[] numbers, int target) {
        // write your code here
        int[] res = new int[2];
        if (numbers == null && numbers.length < 2) {
            return null;
        }
        HashMap<Integer, Integer> hm = new HashMap<>();
        for (int i = 0; i < numbers.length; i++) {
            if (hm.containsKey(target - numbers[i])) {
                res[0] = hm.get(target - numbers[i]) + 1;
                res[1] = i + 1;
                return res;
            }
            hm.put(numbers[i], i);
        }
        return null;
    }

7 3Sum lintCode-57
描述：返回三和为0
记忆：用两数和为相反数，重复过

 public ArrayList<ArrayList<Integer>> threeSum(int[] numbers) {
        // write your code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (numbers == null || numbers.length <= 2) {
            return res;
        }
        Arrays.sort(numbers);
        for (int i = numbers.length - 1; i >= 2; i--) {
            if (i < numbers.length - 1 && numbers[i] == numbers[i + 1]) {
                continue;
            }
            ArrayList<ArrayList<Integer>> cur = twoSum(numbers, i - 1, -numbers[i]);
            for (int j = 0; j < cur.size(); j++) {
                cur.get(j).add(numbers[i]);
            }
            res.addAll(cur);
        }
        return res;
    }
    public ArrayList<ArrayList<Integer>> twoSum(int[] num, int end, int target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (num == null || num.length <= 1) {
            return res;
        }
        int l = 0;
        int r = end;
        while (l < r) {
            if (num[l] + num[r] == target) {
                ArrayList<Integer> item = new ArrayList<Integer>();
                item.add(num[l]);
                item.add(num[r]);
                res.add(item);
                l++;
                r--;
                while (l < r && num[l] == num[l - 1]) {
                    l++;
                }
                 while (l < r && num[r] == num[r + 1]) {
                    r--;
                }
            } else if (num[l] + num[r] > target) {
                r--;
            } else {
                l++;
            }
        }
        return res;
    }

8 3Sum Closest lintCode-57
描述：反与目标相差较小

    public int threeSumClosest(int[] num, int target) {  
        if(num == null || num.length<=2)  
            return Integer.MIN_VALUE;  
        Arrays.sort(num);  
        int closest = num[0]+num[1]+num[2]-target;      
        for(int i=0;i<num.length-2;i++)  
        {  
            int cur = twoSum(num,target-num[i],i+1);  
            if(Math.abs(cur)<Math.abs(closest))  
                closest = cur;   
        }  
        return target+closest;  
    }  
    private int twoSum(int[] num, int target, int start)  
    {  
        int closest = num[start]+num[start+1]-target;  
        int l = start;  
        int r = num.length-1;  
        while(l<r)  
        {  
            if(num[l]+num[r]==target)  
                return 0;  
            int diff = num[l]+num[r]-target;  
            if(Math.abs(diff)<Math.abs(closest))  
                closest = diff;      
            if(num[l]+num[r]>target)  
            {  
                r--;  
            }  
            else  
            {  
                l++;  
            }  
        }  
        return closest;  
    }  

遍历
1 Container With Most Water lintCode - 383
描述：找最大水桶
记忆：标最大，夹逼

public int maxArea(int[] heights) {
        // write your code here
        if (heights == null && heights.length == 0) {
            return 0;
        }
        int l = 0;
        int r = heights.length - 1;
        int maxArea = 0;
        while (l < r) {
            maxArea = Math.max(maxArea, Math.min(heights[l], heights[r])*(r - l));
            if (heights[l] < heights[r]) {
                l++;
            } else {
                r--;
            }
        }
        return maxArea;
    }

2 Set Matrix Zeroes lintCode - 162

public void setZeroes(int[][] matrix) {
        // write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return;
        }
        boolean rowFlag = false;
        boolean colFlag = false;
        for (int i = 0;  i < matrix[0].length; i++) {
            if (matrix[0][i] == 0) {
                rowFlag = true;
                break;
            }
        }
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[i][0] == 0) {
                colFlag = true;
                break;
            }
        }
        for (int i = 1; i < matrix.length; i++) {
            for (int j = 1; j < matrix[0].length; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < matrix.length; i++) {
            for (int j = 1; j < matrix[0].length; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        if (colFlag) {
            for (int i = 0; i < matrix.length; i++) {
                matrix[i][0] = 0;
            }
        }
        if (rowFlag) {
            for (int i = 0; i < matrix[0].length; i++) {
                matrix[0][i] = 0;
            }
        }
    }

用好标记
1 Valid Sudoku lintCode-389
描述：判断数独
记忆：有是判有错

public boolean isValidSudoku(char[][] board) {
        if (board == null || board.length != 9 || board[0].length != 9) {
            return false;
        }
        for (int i = 0; i < 9; i++) {
            boolean[] map = new boolean[9];
            for (int j = 0; j < 9; j++) {
                if (board[i][j] != '.') {
                   if (map[(int)(board[i][j] - '1')]) {
                       return false;
                   }
                   map[(int)(board[i][j] - '1')] = true;
                }
            }
        }
        for (int i = 0; i < 9; i++) {
            boolean[] map = new boolean[9];
            for (int j = 0; j < 9; j++) {
                if (board[j][i] != '.') {
                    if (map[(int)(board[j][i] - '1')]) {
                        return false;
                    }
                    map[(int)(board[j][i] - '1')] = true;
                }
            }
        }
        for (int block = 0; block < 9; block++) {
            boolean[] map = new boolean[9];
            for (int i = block / 3 * 3; i < block / 3 * 3 + 3; i++) {
                for (int j = block % 3 * 3; j < block % 3 * 3 + 3; j++) {
                    if (board[i][j] != '.') {
                    if (map[(int)(board[i][j] - '1')]) {
                        return false;
                    }
                    map[(int)(board[i][j] - '1')] = true;
                }
                }
            }
        }
        return true;
    }

2 Next Permutation lintCode-190
描述：下一个排列

    public void nextPermutation(int[] num) {  
        if(num==null || num.length==0)  
            return;  
        int i = num.length-2;  
        while(i>=0 && num[i]>=num[i+1])  
        {  
            i--;  
        }  
        if(i>=0)  
        {  
            int j=i+1;  
            while(j<num.length && num[j]>num[i])  
            {  
                j++;  
            }  
            j--;  
            int temp = num[i];  
            num[i] = num[j];  
            num[j] = temp;  
        }  
        reverse(num, i+1);  
    }  
    private void reverse(int[] num, int index)  
    {  
        int l = index;  
        int r = num.length-1;  
        while(l<r)  
        {  
            int temp = num[l];  
            num[l] = num[r];  
            num[r] = temp;  
            l++;  
            r--;  
        }  
    }  

3 Word Search lintCode-123

public void sortColors(int[] nums) {
        // write your code here
        if (nums == null || nums.length == 0) {
            return;
        }
        int idx0 = 0;
        int idx1 = 0;
        for (int i = 0; i< nums.length; i++) {
            if (nums[i] == 0) {
                nums[i] = 2;
                nums[idx1++] = 1;
                nums[idx0++] = 0;
            } else if (nums[i] == 1) {
                nums[i] = 2;
                nums[idx1++] = 1;
            }
        }