数据结构与算法---移动零、两数之和、三数之和

移动零

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

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

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

---

思路

将所有的0移动到后面，并且保证原来的顺序不变

首先，不能直接将0与最后一个元素进行交互，因为0与12一交互，原来的顺序就被打破

新建一个变量insertIndex，记录数据将要插入的位置
遍历数组
如果是0，则跳过，啥也不做
如果是非0，则将遍历到的值赋值给insertIndex位置，并且inserIndex++;
最后，遍历完毕后，再将InserIndex到nums.length - 1中间的数值赋值为0即可

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

        int insertIndex = 0;
        for(int i = 0; i<nums.length; i++){
            if(nums[i] != 0){
                nums[insertIndex] = nums[i];
                insertIndex++;
            }
        }

        for(int i = insertIndex; i<nums.length; i++){
            nums[i] = 0;
        }
    }
}

---

两数之和

1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

---

LeetCode的第一道题，第一道题，当然要学会了

思路1：暴力法

两个for循环解决问题

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if(nums == null) return null;

        for(int i = 0; i<nums.length; i++){
            for(int j = i + 1; j < nums.length; j++){
                if(nums[i] + nums[j] == target){
                    return new int[] {i, j};
                }
            }
        }
        return null;
    }
}

时间复杂度为O(n^2)
空间复杂度为O(1)

思路2：借助哈希表

当扫描到某一个元素的时候，拿target减去当前值，求得需要凑得的值，如果在之前扫描的元素中可以找到所需要凑的值，则查找结束。如果没找到，那么继续遍历下一个。
问题是，如何从前面已经遍历的元素中查找元素，再重新遍历一遍？那不还是成了两次遍历。
我们可以借助哈希表，将每次遍历到的元素，以值为key，以数组下标为value，进行存储。当需要查看是否存在某个值的时候，直接通过哈希表在O(1)时间里找出。从而达到遍历数组一遍，找出所需target的值

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if(nums == null) return null;

        //key是nums的值，value是nums的index
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i<nums.length; i++){
            Integer indext = map.get(target - nums[i]);
            if(indext != null){
                return new int[] {indext, i};
            }
            map.put(nums[i], i);
        }
        return null;
    }
}

注意Map的创建以及操作

---

三数之和

15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：

[
  [-1, 0, 1],
  [-1, -1, 2]
]

---

思路

暴力法
三个for循环
时间复杂度为O(n^3)
暴力法需要注意的地方是，注意取出重复的元素
时间复杂度太大，不考虑

利用多指针
首先，对数组进行从小到大的排序
然后遍历数组，i从0到nums.length - 3

定义一个left和right；left的初始值为i的下一个元素，right的初始值为nums.length - 1

在left < right下：

判断nums[i] + nums[left] + nums[right] == 0;
如果nums[left] == nums[left + 1];left++;
如果nums[right] == nums[right - 1];righ --;
如果等于零，则找到了要求的结果，然后left++;right–;继续比较。
如果不等于零：
假如左边的值小于0，则将left++;
假如左边的值大于0，则right --;

当left >= right的时候，i++;

注意点是重复元素的问题
处理办法就是：
当左边有相等的值，直接跳过前面的，找到最后面一个相等的值，做比较
当右边有相等的值，直接跳过后面的，找到最前面一个相等的值，做比较

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        if(nums == null) return null;
        //二维数组，用来接收结果
        List<List<Integer>> resultArray = new ArrayList<>();
        if(nums.length < 3) return resultArray;

        //排序
        Arrays.sort(nums);

        //注意i的取值范围
        for(int i = 0; i<=nums.length - 3; i++){
            //如果i重复
            if(i > 0 && nums[i] == nums[i - 1]) continue;

            int left = i + 1;
            int right = nums.length - 1;
            while(left < right){
                if(nums[i] + nums[left] + nums[right] == 0){
                    List subArray = new ArrayList();
                    subArray.add(nums[i]);
                    subArray.add(nums[left]);
                    subArray.add(nums[right]);
                    resultArray.add(subArray);

                    //如果left重复
                    while(left < right && nums[left] == nums[left + 1]) left++;
                    //如果right重复
                    while(left < right && nums[right - 1] == nums[right]) right--;

                    left++;
                    right--;
                }else if(nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else{
                    right--;
                }
            }
        }
        return resultArray;
    }
}

时间复杂度为O(n^2)
空间复杂度为O(1)