数据结构算法刷题--双指针法

最新推荐文章于 2024-11-01 18:51:26 发布
最新推荐文章于 2024-11-01 18:51:26 发布
阅读量81 收藏
点赞数
分类专栏： 数据结构-算法刷题 文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45430847/article/details/130510952
版权

1、移除元素

  • 题目：https://leetcode.cn/problems/remove-element/
  • 思路：双指针，快慢双指针：快指针找到要移除的元素时快指针跳过，正常元素由快指针拷贝到慢指针位置
  • 代码实现：
class Solution {
    // 双指针--快慢指针
    public int removeElement(int[] nums, int val) {
        // 慢指针slow用于维护去掉val值后，数组存放的顺序索引遍历
        // 快指针fast用于遍历nums中原来的值,fast遇到val跳过就行，不是val的放到slow的位置
        int slow = 0;
        for(int fast = 0; fast < nums.length; ++fast){
            while(nums[fast] == val){
                // 命中--fast直接跳过读取下一个应该保留的数
                fast++;
                if(fast == nums.length){
                    return slow;
                }
            }
            // System.out.println("slow-->" + slow + ", fast-->" + fast);
            nums[slow++] = nums[fast];
        }

        return slow;
    }
}

2、反转字符串

  • 题目：https://leetcode.cn/problems/reverse-string/
  • 思路：双指针–首尾双指针，交换左右指针的元素；交换的实现既可以通过传统的设置临时变量，对于数值类型的交换还可以通过三次异或运算实现。
  • 代码实现
class Solution {
    // 双指针法--相向双指针
    public void reverseString(char[] s) {
        // 1、初始化双指针
        int slow = 0;
        int fast = s.length - 1;
        while(slow < fast){
            // 2、通过异或进行交换操作
            s[slow] ^= s[fast];
            s[fast] ^= s[slow];
            s[slow] ^= s[fast];
            // 3、指针移动
            ++slow;
            --fast;
        }
    }
}

3、替换空格

  • 题目：https://leetcode.cn/problems/ti-huan-kong-ge-lcof/
  • 思路：双指针–快慢双指针：先统计空格个数，每有一个空格扩充两个字符位置；然后左右指针分别指向原字符串和扩容后的字符串的最后面，从后往前遍历（可以有效避免数组插入元素的移动）。
  • 代码实现：
class Solution {
    // 双指针法，为了数组的移动方便，无比从后往前
    public String replaceSpace(String s) {
        // 1、先统计空格的个数，对每个空格追加两个位置
        StringBuilder sb = new StringBuilder(s);
        for(int i = 0; i < s.length(); ++i){
            if(s.charAt(i) == ' '){
                sb.append("  ");
            }
        }

        // 2、双指针启动
        // 2.1、指针初始化
        int left = s.length() - 1;
        int fast = sb.length() - 1;

        while(left >= 0){
            // 2.2、核心逻辑--遇到空格补一个 "%20"；正常字符的话就正常替换过来
            if(s.charAt(left) == ' '){
                sb.setCharAt(fast--, '0');
                sb.setCharAt(fast--, '2');
                sb.setCharAt(fast--, '%');
                // 2.3、指针移动
                --left;
            }else{
                // 不是空格，正常移动
                sb.setCharAt(fast--, s.charAt(left--));
            }
        }

        return new String(sb);

    }
}

4、翻转字符串里的单词

  • 题目：https://leetcode.cn/problems/reverse-words-in-a-string/
  • 思路：先整体反转（相向双指针），每个单词局部反转（双指针）+移位
  • 代码实现：
class Solution {
    // 整体反转 + （每个单词局部反转 + 移位）

    public String reverseWords(String s) {
        // 1.单词整体反转
        char[] ch = s.toCharArray();
        reverseCharArray(ch, 0, s.length() - 1);

        // 2.局部反转-每个单词
        // i控制获得一个单词的起始结束索引
        // j控制读取一个单词的字符但不读取空格
        // k控制将每个单词放过来同时适当添加单词之间的一个空格
        int j = 0, k = 0;
        for(int i = 0; i < ch.length; ++i){
            // 2.1 得到一个单词
            if(ch[i] == ' '){
                // 跳过空格
                continue;
            }
            // 空格后的第一个字符,获得单词的起始索引
            int wordStartIndex = i;
            // 让i走完一个单词
            while(i < ch.length && ch[i] != ' '){
                ++i;
            }
            int wordEndIndex = i - 1;

            // 2.2 局部反转单词,然后用j来读取单词,然后通过k来放置单词
            reverseCharArray(ch, wordStartIndex, wordEndIndex);
            for(j = wordStartIndex; j <= wordEndIndex; ++j){
                ch[k++] = ch[j];
            }

            // 2.3 每个单词结束追加空格,但注意避免越界(原字符串没有要删除的字符的情况)
            if(k < ch.length){
                ch[k++] = ' ';
            }
        }

        // 3. 返回结果,k体现了当前结束位置,最后末尾可能有多出来的空格可能没有
        // 没有的情况很好判断:k在原字符串末尾并且这个字符不为空格
        return new String(ch, 0, (k == s.length()) && (ch[k - 1] != ' ') ? k : k - 1);
    }

    // 自定义字符串反转方法——左右双指针
    public void reverseCharArray(char[] ch, int left, int right){
        while(left < right){
            // 反转操作
            ch[left] ^= ch[right];
            ch[right] ^= ch[left];
            ch[left] ^= ch[right];

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

5、翻转链表

  • 题目：https://leetcode.cn/problems/reverse-linked-list/
  • 思路：三指针–分别记录正序条件下的前一个元素、当前元素、下一个元素；然后通过让当前元素的 next 为前一个元素实现一次翻转；指针移动到下一个元素准备下一次翻转操作–当前元素指针到下一个元素、前一个元素指针到当前元素
  • 代码实现：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 双指针:一前一后
    public ListNode reverseList(ListNode head) {
        // 1、指针初始化
        ListNode prev = null;
        ListNode cur = head;

        while(cur != null){
            // 2、核心逻辑--反转：从头开始倒着指
            // 2.1、记录下cur的下一个，免得一会一倒就找不到了
            ListNode temp = cur.next;
            // 2.2、反转，让当前指向前一个
            cur.next = prev;

            // 3、指针移动
            prev = cur;
            cur = temp;
        }
        
        return prev;
    }
}

6、删除链表的倒数第N个节点

  • 题目：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
  • 思路：双指针–快慢指针法，先让快指针走n步，然后快慢指针同步走，这样当快指针走到最后一个元素时，慢指针就走到了要删除的前一个节点。注意：链表中的删除操作要走到要删除节点的前一个，第一个节点也存在被删除的可能–添加虚拟节点。
  • 代码实现：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 双指针，快指针先走n+1步，然后和慢指针一起走，当快指针走到末尾，慢指针就到了要删除节点的前一个
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 头结点可能被删除--设置虚拟头结点
        // 1、指针初始化
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode slow = dummyHead, fast = dummyHead;
        for(int i = 0; i < n; ++i){
            fast = fast.next;
        }

        // 2、指针移动
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }

        // 3、删除节点
        slow.next = slow.next.next;

        return dummyHead.next;
    }

}

7、链表相交

  • 题目：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/
  • 思路：双指针–相交点及其以后的节点一定是全部都对齐的，所以可以先让两个链表的尾部对齐–统计两个链表的长度，计算长度差，然后让长的链表指针先从头节点走长度差，这个时候长链表指针和位于短链表头部的指针对齐，逐个向后判断两个节点是否相等就可以了。
  • 代码实现：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // 双指针法
    // 先求取两者长度，然后算得长度差，将长的那一个指针走长度差从而对齐两个链表的末端，逐个判断是否相交
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 1、计算两个链表的长度
        int lenA = 0, lenB = 0;
        ListNode nodeA = headA, nodeB = headB;
        while(nodeA != null){
            ++lenA;
            nodeA = nodeA.next;
        }
        while(nodeB != null){
            ++lenB;
            nodeB = nodeB.next;
        }

        // 2、整理，将A设为长的链表，方便操作
        if(lenA < lenB){
            // 长度交换
            int lenTemp = lenA;
            lenA = lenB;
            lenB = lenTemp;
            // 链表交换
            nodeA = headA;
            headA = headB;
            headB = nodeA;
        }

        // 3、移动长的指针使二者末尾对齐
        int diff = lenA - lenB;
        nodeA = headA;
        nodeB = headB;
        for(int i = 0; i < diff; ++i){
            nodeA = nodeA.next;
        }

        // 4、逐个判断
        while(nodeA != null){
            if(nodeA == nodeB){
                return nodeA;
            }
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }

        return null;
        
    }
}

8、环形链表Ⅱ

  • 题目：https://leetcode.cn/problems/linked-list-cycle-ii/
  • 思路：快慢双指针–快指针每次走两步，慢指针每次走一步，如果是环，必定相遇
    • 1、记起点到环入口为x，环入口到相遇点长度为y，相遇点再到入口长度为z；
    • 2、于是有 2(x + y) = x + (y + z) + y
    • 3、得到 x = z
    • 4、重点–所以在相遇后找到入口，只需要再从头开始一个指针，让原来的慢指针和新的指针同步一步一步走到相遇的地方就是入口！
  • 代码实现：
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // 快慢双指针：快指针每次走两步，慢指针每次走一步，如果是环，必定相遇
    // 1、记起点到环入口为x，环入口到相遇点长度为y，相遇点再到入口长度为z
    // 2、于是有 2(x + y) = x + (y + z) + y
    // 3、得到 x = z
    // 4、所以在相遇后找到入口，只需要再从头开始一个慢指针，让原来慢指针和新的慢指针相遇就是入口！

    public ListNode detectCycle(ListNode head) {
        // 特殊情况判断
        if(head == null){
            return null;
        }

        // 1、快慢指针初始化
        ListNode slow = head;
        ListNode fast = head;

        // 2、移动，直到两者相遇
        while(fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            // System.out.println("fast-->" + fast + ", slow-->" + slow);
            
            // 相遇
            if(fast == slow){
                // 3、再从头开始一个，和慢指针同步走到相遇--入口
                // 直接使用fast作为新的从头开始的慢指针
                fast = head;
                while(fast != slow){
                    fast = fast.next;
                    slow = slow.next;
                }
                return fast;
            }
        }

        return null;

    }
}

9、三数之和

  • 题目：https://leetcode.cn/problems/3sum/
  • 思路：第一个数通过遍历固定，然后后两个数的遍历通过相向双指针将时间复杂度由O（n^2）压缩到O（n）；第一个数注意剪枝、去重，后两个数也注意去重。
  • 代码实现：
class Solution {
    // 双指针：固定第一个数，第二三个数用相向双指针--注意先排序，判断过程中注意去重

    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();

        // 1、排序
        Arrays.sort(nums);

        // 2、遍历固定第一个数
        for(int i = 0; i < nums.length; ++i){
            // 2.1、第一个数剪枝
            if(nums[i] > 0){
                break;
            }
            // 2.2、第一个数去重
            if(i > 0 && nums[i - 1] == nums[i]){
                continue;
            }

            // 3、双指针获得后两个数
            int left = i + 1, right = nums.length - 1, sum = 0;
            while(left < right){
                sum = nums[i] + nums[left] + nums[right];
                if(sum > 0){
                    // 右指针的数大了
                    --right;
                }else if(sum < 0){
                    // 左指针的数小了
                    ++left;
                }else{
                    // 这组结果是对的
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    ret.add(list);

                    // 后两个数的去重
                    while(left < right && nums[right - 1] == nums[right]){
                        --right;
                    }
                    while(left < right && nums[left + 1] == nums[left]){
                        ++left;
                    }
                    
                    // 左右指针同时移动
                    ++left;
                    --right;
                }
            }
        }

        return ret;

    }
}

10、四数之和

  • 题目：https://leetcode.cn/problems/4sum/
  • 思路：三数之和进阶，遍历固定第一个数后，再遍历固定第二个数，最后剩下的两个数通过双指针压缩时间复杂度到O（n），前两个数注意剪枝、去重；最后两个数注意去重。
  • 代码实现：
class Solution {
    // 三数之和进阶：固定住前两个数，双指针获得后两个数，使后两个数的时间复杂度为O（n），降一阶

    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ret = new ArrayList<>();

        // 1、数组排序
        Arrays.sort(nums);

        // 2、遍历固定第一个数
        for(int i = 0; i < nums.length - 3; ++i){
            // System.out.println("-------------");
            // System.out.println("i-->" + i);
            // 2.1 第一个数剪枝，注意target可能是负数
            if(nums[i] > target && target > 0){
                break;
            }
            // 2.2 第一个数去重
            if(i > 0 && nums[i - 1] == nums[i]){
                continue;
            }

            // 3、遍历固定第二个数
            for(int j = i + 1; j < nums.length - 2; ++j){
                // System.out.println("j-->" + j);
                // 3.1、第二个数剪枝
                if(nums[j] > target - nums[i] && nums[i] > 0){
                    break;
                }
                // 3.2、第二个数去重
                if(j > i + 1 && nums[j - 1] == nums[j]){
                    continue;
                }

                // 4、双指针获得后两个数
                int left = j + 1, right = nums.length - 1, sum = 0;
                // System.out.println("left-->" + left);
                // System.out.println("right-->" + right);

                // 5、结果判断
                while(left < right){
                    sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if(sum > target){
                        // 右指针的数大了
                        --right;
                    }else if(sum < target){
                        // 左指针的数小了
                        ++left;
                    }else{
                        // 结果对了
                        List<Integer> list = new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[left]);
                        list.add(nums[right]);
                        ret.add(list);

                        // 后两个数的去重
                        while(left < right && nums[right - 1] == nums[right]){
                            --right;
                        }
                        while(left < right && nums[left + 1] == nums[left]){
                            ++left;
                        }

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

        }
        return ret;
    }
}

11、双指针总结

Introspection_ZHANG
关注
专栏目录
双指针+前缀和算法刷题路线
08-30
### 双指针+前缀和算法刷题路线 #### 双指针技巧解析 双指针技巧是一种简单而有效的编程方法，它主要用于处理数组或序列中的问题，尤其是在需要找到某些符合条件的子序列时尤为有用。双指针的核心思想在于通过两个...
算法刷题LeetCode中文版.pdf
02-21
这些题目旨在锻炼和提升读者的算法思维、数据结构理解和问题解决能力，对于想要提升算法水平或准备技术面试的开发者来说，是一份宝贵的参考资料。同时，通过阅读和实践这些题目的解决方案，可以帮助读者更好地掌握...
leetcode新手刷题指南-myLeetcode:开始编程！
06-30
leetcode新手刷题指南 Leetcode 刷题指南 参考中的刷题顺序链接到 leetcode 官网中，方便直接跳转到刷题页面。...高级数据结构经典题目 并查集 最小生成树 线段树 树状数组 字典树 海量数据处理 算法模板
小象学院2020 刷题班 3.2-4.171
08-08
【小象学院刷题班3.2-4.171】是一系列涵盖字符串、链表、二叉树等数据结构和算法的编程题目集。接下来，我们将详细讲解这些题目涉及的知识点，并给出相应的解题策略。 1. **验证回文串**（Valid Palindrome） - ...
LeetCode刷题记录（简单-数组）
07-29
- 使用双指针法：一个快指针用于遍历数组，一个慢指针用于跟踪不重复元素的最新位置。 - 当遇到不重复的元素时，将其移动到慢指针的位置，并将慢指针向前移动一位。 - 最终慢指针所在位置即为新数组的有效长度。 **...
21_双端 diff 算法
qq_53109172的博客
11-01 519
简单 diff 算法的问题在于，它的移动操作并不是最优的，我们还是使用上一节的例子来看，如图：在这个例子中，我们使用简单 diff 算法来更新需要进行两次 DOM 移动，将 p-1 移动到 p-3 后面，将 p-2移动到 p-1 后面。但是其实只需要一次移动 DOM 即可，就是将 p-3 移动到 p-1 的前面即可。这一点想要实现，是简单 diff 算法无法做到的，而使用双端 diff 算法就可以。顾名思义，双端 diff 算法是一种同事对新旧两组子节点的两个端点进行比较的算法，因此我们需要四个索引值，分别
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 475
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
深⼊理解指针2
ElePower9527的博客
11-01 385
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 95
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
【算法】奇数在偶数后、反转字符串中的单词
2401_84568462的博客
10-29 290
输入一个整数数组，实现一个接口来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分。
C语言中的数组并非指针：深入理解数组和指针的区别
极客代码
10-29 555
在C语言中，数组和指针是两个非常重要的概念，它们在很多方面有着紧密的联系，但也存在显著的区别。尽管数组名有时可以像指针那样使用，但它们本质上并不是一回事。理解这些差异对于编写正确和高效的代码至关重要。本文将深入探讨数组和指针的区别，并提供一些示例代码。1. 数组与指针的基础概念数组：数组是一系列相同类型数据的集合，它们在内存中连续存储。数组名本身是一个常量，指向数组的起始位置。指针：指针是一个变量，其值为另一个变量的地址。指针可以指向数组中的任何一个元素。2. 数组与指针的相似之处数组名作为指针。
力扣题目解析--正则表达式匹配
wxtg1921的博客
11-01 506
动态规划：使用动态规划方法来处理正则表达式的匹配问题，确保每个字符和模式的组合都被正确处理。索引检查：确保在访问字符串索引时，索引在有效范围内，避免越界错误。特殊情况处理：特别处理和的匹配规则，确保可以匹配零个或多个前面的字符，可以匹配任意字符。
Leetcode189. 轮转数组
GQ_666的博客
10-29 212
向右轮转 1 步: [99,-1,-100,3]向右轮转 2 步: [3,99,-1,-100]希望自己可以坚持下去。方法--天涯明月 共勉。，将数组中的元素向右轮转。
实系数多项式的运算算法
分享代码和经验
11-01 891
这段代码通过定义一个Polynomial类来表示多项式，并实现了多项式的基本操作，如求值、相乘和相除。用户可以通过输入多项式的系数来创建多项式对象，并进行各种运算。代码清晰易读，适合用于学习多项式相关的数学概念和运算。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3728
BSP驱动开发工程师-OS、4 道编程题
算法练习：四数之和
2302_80652761的博客
10-28 328
四数之和
力扣：120. 三角形最小路径和
qq_74924951的博客
10-31 155
从最底下开始往上遍历，以triangle[i][j]为顶的三角形最短距离为该点值加两个下处的最短距离的较小值。依次遍历，最后返回第一个。
算法有哪些
Mr.xing的博客
10-28 125
算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，代表着用系统的方法描述解决问题的策略机制。也就是说，算法能够对一定规范的输入，在有限时间内获得所要求的输出。算法应该具有有穷性、确切性、输入项、输出项以及可行性这五个重要的特征。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。在各个领域，算法都有着广泛的应用。例如，在数据分析与挖掘中，算法可以帮助开发人员有效地处理和分析海量数据，挖掘数据中隐藏的价值；
力扣225：用队列实现栈
最新发布
m0_56332819的博客
11-01 156
力扣225：用队列实现栈。C语言
《剑指Offer》精华思路总结：42道经典算法题
"《剑指offer》思路汇总---简化版的原书思路共42页，涵盖了数组、字符串、链表、树与二叉树、栈和队列、递归与循环六大主题的算法题目...这些题目覆盖了数据结构和算法的基础，对于提高编程思维和面试准备非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值