Leetcode百炼成钢——1.玩转双指针

---

算法解释

1.双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多个数组的多个指针。
2.若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口（两个指针包围的区域即为当前的窗口），经常用于区间搜索。
3.若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的

---

一、TwoSum

1.1 有排序数组

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

输入：nums = [2,3,4], target = 6
输出：[1,2]

输入：nums = [3,3], target = 6
输出：[0,1]

问题重述：
在一个升序数组中找两个数之和等于target的数，返回它们的下标。（假设一个输入只有一个输出）
思路：
通过左右两个指针向中间移动，遍历数组。
如果两个指针指向元素的和等于给定值，那么它们就是我们要的结果。如果两个指针指向元素的和小于给定值，我们把左边的指针右移一位，使得当前的和增加一点。如果两个指针指向元素的和大于给定值，我们把右边的指针左移一位，使得当前的和减少一点
Java代码

public static int[] twoSum2(int[] nums, int target) {
        Arrays.sort(nums);
        int[] arr = {0,0};
        int left = 0;
        int right = nums.length-1;
        while (left<right){
            if((nums[right]+nums[left])==target){
                arr[0] = left;
                arr[1] = right;
                break;
            }
            if ((nums[right]+nums[left])>target){
                right--;
            }
            if ((nums[right]+nums[left])<target){
                left++;
            }
        }
        return arr;
 }

1.2 无序数组

思路：
1、双层for循环暴力求解 时间复杂度O(N2)
2、注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)O(N) 降低到 O(1)O(1)。

这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

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

二、合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

思路：
第一种方法：
这个题目我首先想到的是用优先序列去把两个数组都储存起来，然后输出出来就可以了。这种算法的话不用考虑数组是否是非递减顺序。

public void merge(int[] nums1, int m, int[] nums2, int n) {
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    for (int i = 0; i < m; i++) {
        pq.add(nums1[i]);
    }
    for (int i = 0; i < n; i++) {
        pq.add(nums2[i]);
    }
    int[]help = new int[m+n];
    for (int i = 0; i < help.length; i++) {
        nums1[i]=pq.poll();
    }
}

由于优先级队列内部排序成小根堆的时间复杂度是o(logn)所以总的时间复杂度是O（NlogN）

第二种方法：
有点类似归并排序，归并排序是把两个有序的数组，通过比较它们每个数大小，谁小谁就放到一个辅助数组中去，用的方法就是双指针。这道题的话，这个辅助数组就是nums1，借用这个题目把归并排序复习一下。

public static void merge(int[] nums1, int m, int[] nums2, int n) {
        int left = 0;
        int right = 0;
        int index = 0;
        int[] help = new int[m + n];
        while (left < m && right < n) {
            if (nums1[left] < nums2[right]) {
                help[index++] = nums1[left++];
            } else {
                help[index++] = nums2[right++];
            }
        }
        while (left < m) {
            help[index++] = nums1[left++];
        }
        while (right < n) {
            help[index++] = nums2[right++];
        }
        for (int i = 0; i < help.length; i++) {
            nums1[i] = help[i];
        }

    }

这种双指针的方法时间复杂度为O（N）

三、剑指 Offer II 022. 链表中环的入口节点

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

进阶：是否可以使用 O(1) 空间解决此题？

思路：
方法一：一开始看到这个题目，有点懵逼，没太懂题目说的是什么意思。看了官方的说明恍然大悟，原来是说：给你一个链表，这个链表尾部指向pos节点，让我们输出这个节点。
那这样的话，最直观的思路就是，我用哈希表存储每一个节点，如果说再次遇到这个节点的话，就返回这个节点。

public ListNode detectCycle(ListNode head) {
        ListNode pos = head;
        HashSet<ListNode>hashSet = new HashSet<>();
        while (pos!=null){
            if (hashSet.contains(pos)){
                return pos;
            }
            else {
                hashSet.add(pos);
            }
            pos = pos.next;
        }
        return null;
    }

复杂度分析：

时间复杂度：O(N)，其中 N 为链表中节点的数目。我们恰好需要访问链表中的每一个节点。

空间复杂度：O(N)，其中 N 为链表中节点的数目。我们需要将链表中的每个节点都保存在哈希表当中。

方法二：使用快慢指针，定义一个fast指针和一个slow指针，fast指针每次移动两个节点，slow指针每次移动一个节点。如果存在一个环的话，那么它们必然会在环中相遇。
我们需要推导一个结论：第一次相遇后，fast指针从头位置出发，和slow指针同样速度移动，相遇点就是入环点。

public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        ListNode ptr = head;
        while (true) {
            if (fast == null || fast.next == null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if (fast==slow)
                break;
        }

        while (ptr != slow) {
            ptr = ptr.next;
            slow = slow.next;
        }
        return ptr;
    }

时间复杂度 O(N) 空间复杂度O(1)

---