LeetCode初级算法训练-数组

简介

下一篇:LeetCode算法训练-字符串

本来想重初中级和企业面试算法开始的，但是最后还是选择从基础的开始，因为我们并不是为了刷题而刷题，而是在刷题过程中锻炼一种算法思维，在大量的训练之后形成一种对算法的独特见解，培养那种对算法的的敏感度，看到题目，大脑中可以浮现一个解题蓝图，而且从初级开始慢慢建立信心，而且这也是在为后边复杂算法的解题思路打基础。

LeetCode初级算法简介

如果你也想训练自己的算法思维，也可以加入我，从初级算法开始，开启你的算法之旅：初级算法。

自己的一些思考：不要在看完题目后直接就看答案，然后去背题，这样行成的算法记忆是不牢固的，一定要有自己的思考；而且不要一开始就在IDEA上边去写，一定试着自己在leetCode提供的白板上边写一遍最后在放到IDEA上边去执行看有什么问题，以便巩固你的基础API的使用和熟练度；还有一点就是大胆些，不是面试我们试错成本低，尽可能把我们的想法融入到代码中

因篇幅问题，博客中只列出示例和自己的解题答案，详细可以直接点击题目查看。

删除排序数组中的重复项

题目 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。

我的答案

class Solution {
     public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        if (nums.length == 1) return 1;

        int elem = nums[0];
        int markIndex = 1;
        //给定 nums = [0,0,1,1,1,2,2,3,3,4]
        for (int i = 1; i < nums.length; i++) {
            if (elem != nums[i]) {
                nums[markIndex] = nums[i];
                markIndex++;
                elem = nums[i];
            }
        }

        return markIndex;
    }
}

执行用时：1 ms
内存消耗：41.5 MB

买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

public static int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) return 0;
     
        int maxProfit = 0;
        int buyPrice = -1;
        int sellPrice = -1;
        //[7,1,5,3,6,4]
        for (int i = 1; i < prices.length; i++) {
            //涨
            if (prices[i] >= prices[i - 1]) {
                if (buyPrice == -1) {
                    buyPrice = prices[i - 1];

                   // System.out.println("buyPrice: " + buyPrice);
                }
            } else {
                if (sellPrice == -1 && buyPrice != -1) {
                    sellPrice = prices[i - 1];
                   // System.out.println("sellPrice: " + sellPrice);
                }
            }

            if (i == prices.length - 1 && sellPrice == -1 && buyPrice != -1) {
                sellPrice = prices[prices.length - 1];
                //System.out.println("sellPrice: " + sellPrice);
            }

            if (buyPrice != -1 && sellPrice != -1) {
                maxProfit += (sellPrice - buyPrice);
                buyPrice = -1;
                sellPrice = -1;
            }
        }
        return maxProfit;
    }

执行用时：23 ms
内存消耗：39.7 MB

运行完之后，和统计的执行时间相比较发现我的可能逻辑想复杂了，我是把刚要上涨的时候记下买入价格，刚要跌的时候记下卖出价格，计算一次，然后一次类推，然后如果是一直上涨那么就把最后一个价格作为卖出价格，最后把每次的最大收益叠加。
然后这个时候我点开别人1ms执行时间的代码，写的非常简单。我就思考哪里会有问题，然后尝试着吧System.output.println()去掉后就变成了1ms。很开心。
修改后：
执行用时：1 ms
内存消耗：39.1 MB

旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
第一次自己写没有好的方法只能暴力。但是提交执行时间过长，无法通过。
尽管做了左旋还是右旋的的判断，但是k和数组特别大的时候就会非常耗时。

class Solution {
  public static void rotate(int[] nums, int k) {
        if (nums == null || nums.length == 0) return;
        
        int realK = k % nums.length;
        boolean right = true;

        if (realK > (nums.length / 2)) {
            right = false;
            realK = nums.length - realK;
        }

        for (int i = 0; i < realK; i++) {
            if (right) {
                for (int j = 0; j < nums.length; j++) {
                    int t = nums[(j + 1) % nums.length];
                    nums[(j + 1) % nums.length] = nums[0];
                    nums[0] = t;
                }
            } else {
                for (int j = nums.length - 1; j >= 1; j--) {
                    int t = nums[(j - 1) % nums.length];
                    nums[(j - 1) % nums.length] = nums[nums.length - 1];
                    nums[nums.length - 1] = t;
                }
            }
        }

    }
}

第二次查看看到官方解题思路时，发现旋转法是最好理解的，然后自己写了一遍，先全部翻转一次，然后把数组分为0 - k, k - length两部分别翻转，记得k要做取余否则会超出数组大小，之后才通过。

class Solution {
    public void rotate(int[] nums, int k) {
        if (nums == null || nums.length == 0) return;
        reverse(nums, 0, nums.length);
        reverse(nums, 0, k % nums.length);
        reverse(nums, k % nums.length, nums.length);
    }

    public void reverse(int[] nums, int start, int end) {
        int needReverse = (end - start) / 2;
        for (int i = 0; i < needReverse; i++) {
            int temp = nums[start + i];
            nums[start + i] = nums[end - i - 1];
            nums[end - i - 1] = temp;
        }
    }
}

执行用时：0 ms
内存消耗：40.5 MB

还有一个环状替换法，还有一种是牺牲空间的使用额外数组的方式，大家可以去看下。
这里介绍一下环状替换拓宽下视野：
环状替换
为防止数组越界先把k做取余处理。
从零开始轮询数组，然后把第一个数缓存在prev，用临时变量temp缓存要替换位置current + k的数；
用prev替换到要替换位置current + k的数，然后把temp赋值给prev更新prev的值，更新当前位置为current + k,count数加1。
因为我们要把对应的数字调整到对应的位置只需要length次就OK了，也就是每个数调整一次位置。
当current等于start的时候说明交换到最后又回到了start的位置上，相当于这一条交换路线我们已经走过一次了，我们需要停止当前交换从下个位置开始继续交换，否则就会一直跑无限循环。

一般这种情况可以用下边的方法预计他们的重新开始交换的次数:
当 length 和 k 的最大公约数 等于 1 的时候：1 次遍历就可以完成交换；
比如 n = 5, k = 3
当 length 和 k 的最大公约数 不等于 1 的时候：1 次遍历是无法完成的所有元素归位，需要 m (最大公约数) 次

public static void rotate2(int[] nums, int k) {
        k = k % nums.length;
        int count = 0;
        for (int i : nums) {
            System.out.print(i + ",");
        }

        System.out.print("\n");
        System.out.println("length: " + nums.length);
        System.out.println("k: " + k);
        for (int start = 0; count < nums.length; start++) {
            System.out.println("-------------------");

            int current = start;
            int prev = nums[start];
            System.out.println("缓存下来的数据 prev: " + prev);
            do {
                int next = (current + k) % nums.length;
                System.out.print("当前位置: " + current + " 替换 ");
                System.out.println(next + " 位置内容");

                System.out.print("nums[" + next + "]:" + nums[next] + "-->");

                int temp = nums[next];
                nums[next] = prev;
                prev = temp;
                current = next;
                count++;

                System.out.println("nums[" + next + "]:" + nums[next]);

                System.out.println("移动次数: " + count);

                for (int i : nums) {
                    System.out.print(i + ",");
                }
                System.out.print("\n");
                System.out.println("-------------------");
                System.out.println("缓存下来的数据 prev: " + prev);
            } while (start != current);
            System.out.println("countend: " + count);
            System.out.println("start: " + start);
        }
    }

存在重复元素

给定一个整数数组，判断是否存在重复元素。
如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
我的思路是先排序一下然后在找出是否有相同的数。
这个还有其他的方式，比如利用HashSet。

public boolean containsDuplicate(int[] nums) {
        if(nums == null || nums.length == 0 || nums.length == 1) return false;
        Arrays.sort(nums);
        int k = nums[0];
        for(int i = 1 ; i< nums.length ; i++) {
            if(k != nums[i]) {
                k = nums[i];
            } else{
                return true;
            }
        }
        return false;
    }

执行用时：4 ms
内存消耗：43.5 MB

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
受上一个题的启发仍然是先排序，排序后肯定都是成对成对的数，然后循环一次，因为是成对出现，从第一个书开始，如果第一个和第二个不一致记录标记repeat为false,则直接的出结果为nums[i];若果是中间的则是第一个第二个相同则跳到下一对 i= i+1 后边再 i++，如果这个时候后边一对不相同则返回nums[i];如果前边的重复这个时候正好是数组的最后一对判断，i经过i+1之后，i为倒数第二个位置，则把最后一个数返回。

public int singleNumber(int[] nums) {
       if (nums.length == 1) return nums[0];
        Arrays.sort(nums);
        boolean repeat = false;
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                repeat = true;
                i = i + 1;
            }
            if (repeat && i == nums.length - 2) {
                return nums[i + 1];
            }
            if (!repeat) {
                return nums[i];
            }
            if (repeat) {
                repeat = false;
            }
        }
        throw new IllegalArgumentException("Not found single elem");
    }

执行用时：4 ms
内存消耗：41 MB
这个地方感觉有些巧合正好凑了这个出来，看了官方解答之后发现他们有更巧妙地解法，就是用异或。

• 任何数和 0 做异或运算，结果仍然是原来的数，即 a ⊕ 0=a。
• 任何数和其自身做异或运算，结果是 0，即a⊕a=0。
• 异或运算满足交换律和结合律，即 a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b。

class Solution {
	public int singleNumber(int[] nums) {
		if(nums.length == 1) return nums[0];
		int sum = 0;
		for(int i : nums) {
			sum ^=i;
		}
		return sum;
	}
}

执行用时：1 ms
内存消耗：40.4 MB
执行时间大幅减少。

两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。

public static int[] intersect2(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i = 0;
        int j = 0;
        int k = 0;
        while(i < nums1.length && j < nums2.length){
            if(nums1[i] == nums2[j]) {
                nums1[k++] = nums1[i];
                i++;
                j++;
            } else if(nums1[i] < nums2[j]) {
                i++;
            } else if(nums1[i] > nums2[j]) {
                j++;
            }
        }
        return Arrays.copyOfRange(nums1,0,k);
    }

执行用时：2 ms
内存消耗：39.7 MB

在答案上边还有一个是用HashMap的也是可以的。

加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

class Solution {
    public int[] plusOne(int[] digits) {
        if (digits == null || digits.length == 0) return null;
        
        for(int i = digits.length - 1; i >= 0 ;i-- ) {
            digits[i] ++;
            digits[i] = digits[i] % 10;
            if(digits[i] != 0) {
                return digits;
            }
        }
        
        digits = new int[digits.length + 1];
        digits[0] =1;
        return digits;
    }
}

刚开始想复杂了，而且自己没有仔细的列出题目的几种条件，没有好好理解题目，没有解出来，后来看了答案恍然大悟。

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:

必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

class Solution {
    public void moveZeroes(int[] nums) {
        int index = 0;
        for(int i = 0;i < nums.length;i++){
            if(nums[i] != 0) {
               if(i != index) {
                   nums[index] = nums[i];
                   nums[i] = 0;
               } 
               index ++; 
            }
        }
    }
}

执行用时：0 ms
内存消耗：40.1 MB
这个比较简单思路类似前边做的删除排序数组中的重复项。不需要管有多少0只管往前插入不是0的数。

两数之和

这个也没什么好说的。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map map = new HashMap<>();

        for(int i = 0; i < nums.length;i++) {
            int result = target - nums[i];
            if(map.containsKey(result)) {
                return new int[]{map.get(result),i};
            }
            map.put(nums[i],i);

        }
        return null;
    }
}

执行用时：2 ms
内存消耗：39.9 MB

有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
示例 1:
输入:
[
[“5”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: true

示例 2:
输入:
[
[“8”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
说明:

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 ‘.’ 。
给定数独永远是 9x9 形式的。

class Solution {
    public boolean isValidSudoku(char[][] board) {
    //三个二维数组改为boolean[][]
       byte[][] rowValues = new byte[9][9];
        byte[][] colValues = new byte[9][9];
        byte[][] boxIndexValues = new byte[9][9];

        for (int row = 0; row < 9; row++) {
            for (int col = 0; col < 9; col++) {
                if (board[row][col] != '.') {
                    int boxIndex = row / 3 * 3 + col / 3;
                    int value = board[row][col] - '1';//'1'是49，减去'1'正好和 0 - 8 对应
					//这里我们把 == 1去掉
                    if (rowValues[row][value] == 1 || colValues[col][value] == 1 || boxIndexValues[boxIndex][value] == 1) {
                        return false;
                    }
					//这里改为置为true
                    rowValues[row][value] = 1;
                    colValues[col][value] = 1;
                    boxIndexValues[boxIndex][value] = 1;
                }
            }
        }

        return true;
    }
}

执行用时：2 ms
内存消耗：40.2 MB
刚开始没想出来，看了下别人的思路然后自己写了一遍，其实就是将横行竖行和小数独内部拍成一行，做三个二维数组，以行列和第几个数独作为二维数组的行，以数字作为列，如果添加之后就把位置的数置为1，每次添加判断三种情况的相应位置是否为1，若果有一种是1则不是有效数独，否则继续判断下个位置。
其实题解中的话，他们用的是boolean的二维数组，boolean只占一位，相当于1/8个字节，而用byte的话它占用的是八位一个字节，所以我们在注解里注释一下。

旋转图像

给定一个 n × n 的二维矩阵表示一个图像。
将图像顺时针旋转 90 度。
说明：
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。
示例 1:
给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]

示例 2:
给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋转输入矩阵，使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]

public static void rotate(int[][] matrix) {
        int count;
        for (int k = 0; k < matrix[0].length / 2; k++) {
            System.out.println(k);
            System.out.println("*****************");
            count = 0;
            for (int row = k; count < (matrix.length - 2 * k - 1) * 4; row++) {
                System.out.println("-------------------");
                System.out.println("row: " + row);
                int curRow = row, curCol = k;
                int rowww = curRow, colll = curCol;
                int prev = matrix[curRow][curCol];
                do {
                    int nextRow = curCol;
                    int nextCol = matrix.length - 1 - curRow;

                    System.out.println(curRow + "," + curCol + "-->" + nextRow + "," + nextCol);

                    int temp = matrix[nextRow][nextCol];
                    System.out.println("currentValue: " + prev + "-->" + "nextValue: " + temp);
                    matrix[nextRow][nextCol] = prev;
                    prev = temp;
                    curRow = nextRow;
                    curCol = nextCol;

                    System.out.println(curRow + "," + curCol);
                    System.out.println(rowww + "," + colll);
                    for (int i = 0; i < matrix.length; i++) {
                        for (int j = 0; j < matrix[0].length; j++) {
                            System.out.print(matrix[i][j] + ",");
                            if ((j + 1) % matrix.length == 0) {
                                System.out.println();
                            }
                        }
                    }
                    count++;
                } while (!(curRow == rowww && curCol == colll));
                System.out.println(count);
            }
        }
    }

执行用时：0 ms（时间图表一直没出来，可能不准）
内存消耗：39.7 MB

改了好几次，最后要像剥洋葱一样一圈一圈的处理，找到每一轮交换需要四次，每一轮都会回到最开始的那个位置并替换掉。主要还是借助前边的旋转数组的思路。最后硬憋出来的。
其实做的过程中由于列和行弄反了偶然发现也可以参考旋转数组的那种一次全部翻转，然后分左右两侧单次旋转。

TODO: 添加一个总体i j交换然后每一行进行翻转的算法

class Solution {
    public void rotate(int[][] matrix){
        for (int i = 0;i < matrix.length ; i++) {
            for (int j = i;j < matrix.length ; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }

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

执行用时：0 ms
内存消耗：39.7 MB