详解顺序结构双指针处理算法

🎀个人主页： https://zhangxiaoshu.blog.csdn.net
📢欢迎大家：关注🔍+点赞👍+评论📝+收藏⭐️，如有错误敬请指正!
💕未来很长，值得我们全力奔赴更美好的生活！

前言

在数据结构和算法方面的面试中，数组和字符串的相关问题往往是一个重要的考察点。面试官通常会测试面试者在处理这些基础数据结构时的熟练程度，因为这直接关系到解决实际问题的能力。在数组和字符串的考察中，双指针和滑动窗口以及排序算法、字符串的处理API成为关键技巧，本文主要对双指针进行简单介绍

文章目录

前言
1. 序
2. 双指针原理
3. 应用场景
- （1）数组元素的逆置问题
- （2）元素有序的数组有关问题
- （3）判断数组元素的对称性
- （4）环的判断
总结

1. 序

双指针和滑动窗口是在处理数组和字符串问题时常用的技巧。双指针通常用于解决数组中的一些查找或判断问题，通过设置两个指针在数组上移动，实现对数组的遍历和比较。滑动窗口则常用于解决字符串中的子串或子数组问题，通过维护一个可变大小的窗口在字符串上滑动，从而实现对子串或子数组的探测。

排序算法在面试中同样是一个重要的考察点，因为它与数组相关，对数据的整理和查找提供了基础。熟练掌握常见的排序算法，如快速排序、归并排序等，有助于在解决各种问题时更高效地处理数组。此外，对于字符串的处理API也是面试中需要掌握的知识。熟悉字符串的各种操作，如查找子串、替换字符、反转字符串等，能够帮助面试者更灵活地处理字符串相关的问题。

本文主要是对双指针这种常用技巧进行简要介绍，帮助读者在面对数组和字符串相关问题时能够更加从容应对。深入理解这些技巧，并在实际问题中灵活运用，将有助于提高面试者在数据结构和算法面试中的表现。

2. 双指针原理

双指针是一种在数组或链表等数据结构中常用的技巧，它通常涉及使用两个指针，分别指向不同的元素，通过协同工作对元素进行遍历或解决问题。以下是关于双指针两种常用形式：
在这里插入图片描述

左右指针：两个指针分别位于数组或链表的两端，逐渐向中间移动，通常用于查找或判断问题。
快慢指针：两个指针以不同的速度移动，用于解决涉及环的问题或查找中点等。

3. 应用场景

（1）数组元素的逆置问题

在数组元素的逆置问题中，使用双指针法是一种高效且直观的方法。这是因为在逆置数组的过程中，两个指针可以从数组的两端向中间移动，通过交换对应位置的元素，实现数组元素的逆置。

简洁性：双指针法简化了逆置过程，通过两个指针的交替移动，可以直接将数组的两端元素进行交换，而无需额外的数据结构或操作。
原地逆置：双指针法允许在原地逆置数组，而不需要额外的空间。这对于内存效率是非常重要的，尤其是在处理大规模数据时。
线性时间复杂度：双指针法的移动操作是线性的，每次移动一个指针，逆置整个数组的时间复杂度为O(n)，其中n是数组的长度。
适用于多种数据结构：双指针法不仅适用于数组，还可以用于逆置链表等其他数据结构，因为逆置的核心思想是两个指针相向移动。

以下是一个Java示例，演示如何使用双指针法逆置数组：

public static void reverseArray(int[] nums) {
        int left = 0;
        int right = nums.length - 1;

        while (left < right) {
            // 交换左右指针对应位置的元素
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;

            // 移动指针
            left++;
            right--;
        }
}

（2）元素有序的数组有关问题

双指针法在基于有序数组的问题中的应用场景通常涉及查找满足某条件的两个元素或判断数组中是否存在某个目标元素。

有序性质：有序数组的性质为元素按照升序或降序排列，这为双指针法提供了有力的基础。由于数组有序，我们可以利用这一性质通过双指针的协同工作来快速定位目标。
减少搜索空间：在有序数组中，通过适当调整指针的位置，可以有效地缩小搜索的范围，从而减少搜索空间。这样的减少搜索空间的策略能够加速算法的执行。
双指针协同移动：在有序数组中，双指针可以协同移动，其中一个指针向前移动，而另一个指针向后移动。这种协同移动的方式使得算法的复杂度保持在线性或次线性水平。
找到匹配元素：双指针法在有序数组中通常用于找到满足某条件的两个元素，例如找到两个元素之和等于目标值，或者找到某个元素的配对。通过左右指针协同移动，可以有效地找到这些匹配的元素。

以下是一个在有序数组中查找两个元素之和等于目标值的Java示例：

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

        while (left < right) {
            int sum = nums[left] + nums[right];

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

        // 没有找到满足条件的元素
        return new int[0];
}

（3）判断数组元素的对称性

使用双指针法判断数组元素的对称性具有一些优势，这使得它在这类问题中成为一个有效而简洁的解决方案：

减少比较次数：双指针法通过同时从数组的两端向中间移动，可以有效减少需要进行的比较次数。在对称性问题中，相邻的元素只需要进行一次比较，而不是两次。这可以降低算法的时间复杂度。
协同移动：双指针法允许两个指针同时移动，协同工作。通过这种方式，我们可以同时比较数组的对应位置，加快了检测对称性的速度。这种协同移动的方式更加直观且容易理解。
空间复杂度低：双指针法通常是原地操作的，不需要额外的空间。这对于空间复杂度的优化是很重要的，尤其是在处理大规模数据时。
简洁性：双指针法的实现相对简洁，代码量较少。它不需要额外的数据结构或复杂的逻辑，适用于对称性问题这类相对基础的场景。

以下是一个简单的Java示例，演示了使用双指针法判断数组元素的对称性：

public static boolean isSymmetricArray(int[] nums) {
        int left = 0;
        int right = nums.length - 1;

        while (left < right) {
            if (nums[left] != nums[right]) {
                return false;
            }
            // 移动指针
            left++;
            right--;
        }

        // 没有发现不对称的元素
        return true;
}

（4）环的判断

使用双指针法判断环的存在具有一些优势，使得它成为解决环相关问题的有效方法：

空间复杂度低：双指针法通常是原地操作的，不需要额外的空间来存储信息。这对于空间复杂度的优化是很重要的，尤其是在处理大规模数据时。
线性时间复杂度：双指针法在检测环的过程中，快慢指针协同移动，每次迭代中，慢指针移动一步，快指针移动两步。因此，如果存在环，快指针最终会追上慢指针。由于每个指针都最多遍历整个链表一次，算法的时间复杂度是线性的，即O(n)，其中n是链表的长度。
判断环的起点：双指针法不仅可以判断链表中是否存在环，而且可以用于确定环的起点。当快慢指针相遇后，将一个指针移到链表头部，然后两个指针以相同的速度向前移动，再次相遇的地方就是环的起点。

以下是一个示例，演示了使用双指针法判断链表中是否存在环：

 public static boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }

        ListNode slow = head;
        ListNode fast = head.next;

        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }

        return true;
    }