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的也是可以的。