【双指针】做一些简单的双指针

这些题都是些简单难度的题，旨在利用 双指针的思想 解题。

977. 有序数组的平方

去做题

• 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

1. 一个新数组用来存储平方后的数组
2. 设 i = 0，j = n-1 -->【nums[i]*nums[i] > nums[j]*nums[j]】比较后存入新数组中。

public int[] sortedSquares(int[] nums) {
	int n = nums.length;
	int[] ans = new int[n];
	int i = 0, j = n-1;
	for(int p=n-1; i<=j; p--){
		if(nums[i]*nums[i] > nums[j]*nums[j]){
			ans[p] = nums[i]*nums[i];
			i++;
		}else{
			ans[p] = nums[j]*nums[j];
			j--;
		}
	}
	return ans;
}

283. 移动零

去做题

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

1. 左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部
2. 初始都指向nums[0]，右指针往前遍历，不为零时则与左指针交换
3. 执行一次交换，左指针右移一位
   示例：[0, 5, 0, 2, 3, 0]

	public void moveZeroes(int[] nums) {
        int n = nums.length, left = 0, right = 0;
        while(right < n){
            //每循环一次，右指针都要往右移一位
            if(nums[right] != 0){
            	//执行交换，左指针右移一位
                swap(nums, left, right);
                left++;
            }
            right++;
        }
    }
    //交换
    public void swap(int[] nums, int left, int right){
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }

167. 两数之和 II - 输入有序数组

去做题

• 给定一个已按照 非递减顺序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
  函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
  你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

1. 两个指针分别指向numbers[0] 和 numbers[n-1]
2. 每次计算两个指针指向的两个元素之和，并和目标值比较。

    public int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length-1;

        while(left < right){
            int sum = numbers[left] + numbers[right];
            if(sum == target){
                return new int[]{left + 1, right + 1};
            }else if(sum < target)
                left++;
            else
                right--;
        }

        return new int[]{-1, -1};
    }

344. 反转字符串

去做题

• 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
  不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

1. 两个指针分别指向 s[0] 和 s[n-1]
2. 交换两个指针所指向的元素

	public void reverseString(char[] s) {
        int n = s.length;
        int left = 0;
        int right = n-1;
        while(left < right){
            char temp = s[left];
            s[left++] = s[right];
            s[right--] = temp;
        }
    }

876. 链表的中间结点

去做题

• 给定一个头结点为 head 的非空单链表，返回链表的中间结点。
  如果有两个中间结点，则返回第二个中间结点。

1. 快指针走两步，慢指针走一步。
2. 快指针遍历结束，慢指针应该指向中间结点

public ListNode middleNode(ListNode head) {
    ListNode slow = head, fast = head;
    while(fast != null && fast.next != null){
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
}

19. 删除链表的倒数第 N 个结点

去做题

• 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
  进阶： 你能尝试使用一趟扫描实现吗？

1. 快指针比慢指针多走N步，当快指针走完时，慢指针指向的就是要删除的倒数第n个结点。
2. 实现：先使快指针往前遍历n次，然后两个指针一起往前遍历，直到快指针为空。
3. 为了在遍历结束时使慢指针指向要删除结点的前驱节点，考虑初始将慢指针指向哑节点。

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0, head);
    ListNode slow = dummy, fast = head;
    for(int i = 0; i < n; i++){
        fast = fast.next;
    }
    while(fast != null){
        slow = slow.next;
        fast = fast.next;
    }
    slow.next = slow.next.next;
    ListNode ans = dummy.next;
    return ans;
}

---

🐑🐑🐑