算法细节系列（31）：链表

最新推荐文章于 2024-10-01 23:28:00 发布
最新推荐文章于 2024-10-01 23:28:00 发布
阅读量817 收藏
点赞数
分类专栏： 算法细节 算法集中营
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014688145/article/details/72902779
版权

算法细节系列（31）：链表

详细代码可以fork下Github上leetcode项目，不定期更新。

题目摘自leetcode：

Leetcode 206. Reverse Linked List

思路：
遍历的同时把指针反向，最后就能得到一个reversed List。
alt text

代码如下：（迭代版本）

public ListNode reverseList(ListNode head){
        if (head == null) return null;
        ListNode newHead = null;
        while (head != null){
            ListNode next = head.next;
            head.next = newHead;
            newHead = head;
            head = next;
        }
        return newHead;
    }

递归版本：

    public ListNode reverseList(ListNode head){
        return recurrsive(head, null);
    }

    private ListNode recurrsive(ListNode head, ListNode newHead){
        if (head == null) return newHead;
        ListNode next = head.next;
        head.next = newHead;
        return recurrsive(next, head);
    }

Leetcode 025. Reverse Nodes in k-Group

第一题的升级版，采用递归，无非要加入k的一个循环判断，超过k的链表进行翻转，有趣的是此时的newHead，就是递归返回的结果。

代码如下：

public ListNode reverseKGroup(ListNode head, int k) {
        return recurrsive(head, k);
    }

    private ListNode recurrsive(ListNode head, int k) {
        ListNode last = head;
        int count = 0;
        while (last != null && count != k){
            last = last.next;
            count++;
        }
        if (count == k){
            ListNode newHead = recurrsive(last, k);
            for (int i = 0; i < k; i++){
                ListNode next = head.next;
                head.next = newHead;
                newHead = head;
                head = next;
            }
            head = newHead;
        }
        return head;
    }

Leetcode 148. Sort List

采用归并，List在分裂时需要O(n)，最终采用归并就能 O(nlogn) 了？不明白。分治起初采用的是计数的方法，但需要遍历 n+n/2 次，优化采用快慢指针，始终以两倍的速度跑到指针末尾，那么慢指针所指向的Node，必然是第二个list的开始。

快慢指针有点并发的味道，while循环中两指针没有相互依赖关系，就好像在一个平行世界中蹦跑一样，直观上更加效率的原因。

public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode slow = head;
        ListNode fast = head;
        ListNode prev = null;

        while (fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        return merge(sortList(head), sortList(slow));
    }

    private ListNode merge(ListNode sorted1, ListNode sorted2){
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;
        while (sorted1 != null && sorted2 != null){
            if (sorted1.val < sorted2.val){ 
                curr.next = sorted1;
                sorted1 = sorted1.next;
            }else{
                curr.next = sorted2;
                sorted2 = sorted2.next;
            }
            curr = curr.next;
        }

        if (sorted1 != null){
            curr.next = sorted1;
        }

        if (sorted2 != null){
            curr.next = sorted2;
        }

        return dummy.next;
    }

Leetcode 082. Remove Duplicates from Sorted List II

我的思路：

  • 两次遍历，第一次统计所有结点出现的次数。（区分dup结点和非dup结点）
  • 遇到非dup结点，直接加入链表，遇到dup结点，跳过。

代码如下：

    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return head;
        Map<Integer,Integer> map = new HashMap<>();
        ListNode pos = head;
        while (pos != null){
            map.put(pos.val, map.getOrDefault(pos.val, 0) + 1);
            pos = pos.next;
        }
        ListNode dummy = new ListNode(Integer.MAX_VALUE);
        ListNode cur = dummy;
        pos = head;

        while (pos != null){
            int cnt = map.get(pos.val);
            if (cnt >= 2){ //duplicate
                cur.next = pos.next;
                pos = pos.next;
            }
            else{
                cur.next = pos;
                pos = pos.next;
                cur = cur.next;
            }
        }

        return dummy.next;
    }

需要克服直接扫描的恐惧啊，这样就能在一个循环内解决战斗了。遇到dup直接pos = pos.next，直到下一个位置不再相等，代码如下：

public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return null;
        ListNode dummy = new ListNode(0);
        ListNode slow = dummy, fast = head;
        slow.next = fast;
        while (fast != null){
            while (fast.next != null && fast.val == fast.next.val) fast = fast.next;
            if (slow.next != fast){ //dup
                slow.next = fast.next;
                fast = fast.next;
            }else{
                slow = slow.next;
                fast = fast.next;
            }
        }
        return dummy.next;
    }

slow.next 连接的都是待检测的内容，如果pos位置没有移动（无重复元素，slow.next == fast），两指针均后移，而当出现重复元素，则slow.next指向下一个待检测区域fast.next，且让fast = fast.next，模拟一遍就好了。

Leetcode 002. Add Two Numbers

很简单，维护一个carry就好了，我的思路比较直接，如果l1和l2任何一个为空，直接跳出while循环，转向单纯的plus。代码相对复杂，plus采用递归，为了解决进位溢出，需要加入一些边界判断。

代码如下：

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;

        int carry = 0;
        while (l1 != null && l2 != null){
            int a1 = l1.val;
            int a2 = l2.val;
            int a3 = a1 + a2 + carry;
            carry = a3 / 10;
            ListNode node = new ListNode(a3 % 10);
            cur.next = node;
            cur = cur.next;
            l1 = l1.next;
            l2 = l2.next;
        }

        if (l1 != null){
            cur.next = plus(carry, l1);
        }

        if (l2 != null){
            cur.next = plus(carry, l2);
        }

        if (l1 == null && l2 == null && carry == 1){
            cur.next = new ListNode(1);
        }

        return dummy.next;
    }

    private ListNode plus(int val,ListNode l1){
        if (l1 == null){
            return new ListNode(val);
        }
        if (l1.val + val != 10){
            l1.val = l1.val + val;
            return l1;
        }else{
            ListNode ans = new ListNode(0);
            ans.next = plus(1, l1.next);
            return ans;
        }
    }

简化思路，l1和l2其中的某个到达了链表尾，可以看成与0相加。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;

        int carry = 0;
        while (l1 != null || l2 != null){
            int a1 = l1 != null ? l1.val : 0;
            int a2 = l2 != null ? l2.val : 0;
            int a3 = a1 + a2 + carry;
            carry = a3 / 10;
            ListNode node = new ListNode(a3 % 10);
            cur.next = node;
            cur = cur.next;
            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }

        if (carry == 1) cur.next = new ListNode(1);

        return dummy.next;
    }

Leetcode 138. Copy List with Random Pointer

直观的想法：
copy需要记录node和index之间的关系，所以一个map用来维护pos和index的关系，方便寻找当前node所在的下标。另一个map用来维护index和pos的关系，方便根据index找当前的pos，相当于一个双向map，可以通过value找index，也可以通过index找value。

代码如下：

    public RandomListNode copyRandomList(RandomListNode head) {
        RandomListNode dummy = new RandomListNode(0);
        RandomListNode cur = dummy;

        RandomListNode pos = head;
        Map<Integer, RandomListNode> index = new HashMap<>();
        Map<RandomListNode, Integer> originIndex = new HashMap<>();

        int cnt = 0;
        while (pos != null){
            cur.next = new RandomListNode(pos.label);
            originIndex.put(pos, cnt);
            index.put(cnt++, cur.next);
            cur = cur.next;
            pos = pos.next;
        }

        pos = head;
        cur = dummy.next;

        while (pos != null){
            if (pos.random != null){
                int idx = originIndex.get(pos.random);
                cur.random = index.get(idx);
            }
            cur = cur.next;
            pos = pos.next;
        }
        return dummy.next;
    }

可以简化代码么？其实之所以叫深度拷贝的原因是一个节点的引用关系也要拷贝。而此题的特点在于每个结点都是RandomListNode，且RandomListNode中的引用关系也是RandomListNode，所以我们完全可以建立 原始node和克隆node的一一对应关系。现在无非就是根据原始node找到相应位置的克隆node把引用关系加上即可。

代码如下：

    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) return null;

        Map<RandomListNode, RandomListNode> map = new HashMap<>();
        RandomListNode pos = head;
        while (pos != null){
            map.put(pos, new RandomListNode(pos.label));
            pos = pos.next;
        }

        pos = head;
        while (pos != null){
            map.get(pos).next = map.get(pos.next);
            map.get(pos).random = map.get(pos.random);
            pos = pos.next;
        }
        return map.get(head);
    }

代码简洁很多。

空间复杂度为 O(n) ，看了dicuss发现还能优化空间复杂度，核心思想和Map保存位置关系差不多，无非就是利用相对位置，来记录random的随机指针。看图：
alt text

蓝色结点为旧结点，红色结点为新结点，如果我们把链表改成这种形式，就可以根据蓝色和红色的相对位置来给红色结点的random指针进行赋值。

思路：

  • 构造新旧结点交替的链表
  • 复制随机指针，因为相对位置清楚，所以很容易复制（该算法的核心）
  • 抽取新旧结点，还原链表。

代码如下：

    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) return null;
        RandomListNode pos = head;
        while (pos != null){
            RandomListNode copy = new RandomListNode(pos.label);
            copy.next = pos.next;
            pos.next = copy;
            pos = pos.next.next;
        }

        pos = head;
        while (pos != null){
            pos.next.random = pos.random != null ? pos.random.next : null;
            pos = pos.next.next;
        }

        pos = head;
        RandomListNode copy = pos.next;
        RandomListNode curr = copy;
        while (pos != null){
            pos.next = pos.next.next;
            pos = pos.next;
            curr.next = pos != null ? pos.next : null;
            curr = curr.next;
        }
        return copy;
    }

以相对位置来记录链表新旧结点的对应关系很新颖，省去了map的记录。

Leetcode 143. Reorder List

思路：

  • 链表对半分成两部分，记为l1和l2
  • 对l2进行逆序
  • 合并 l1 和 l2，注意合并的规则

代码如下：

public void reorderList(ListNode head) {
        if (head == null || head.next == null)
            return;
        ListNode slow = head, fast = head;
        ListNode prev = null;
        while (fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        ListNode reverse = reverse(slow);
        merge(head, reverse);
    }

    private void merge(ListNode l1, ListNode l2) {
        while (l1 != null) {
            ListNode n1 = l1.next, n2 = l2.next;
            l1.next = l2;

            if (n1 == null)
                break;
            l2.next = n1;
            l1 = n1;
            l2 = n2;
        }
    }

    private ListNode reverse(ListNode head) {
        if (head == null)
            return null;
        ListNode newHead = null;
        ListNode pos = head;
        while (pos != null) {
            ListNode next = pos.next;
            pos.next = newHead;
            newHead = pos;
            pos = next;
        }
        return newHead;
    }

合并操作重在把握操作指针，而不是在赋值，容易出错。

Leetcode 061. Rotate List

思路：

找到旋转的四个位置即可，首先遍历一遍链表得到长度，判断k是否超出链表的长度，超出的部分让k = i - k % i，最后进行旋转即可。

代码如下：

    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || head.next == null) return head;
        int i = 1;
        ListNode fast = head, slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next;
            i++;
        }

        for (int j = i - k % i; j > 1; --j){
            slow = slow.next;
        }

        ListNode dummy = new ListNode(0);
        fast.next = head;
        dummy.next = slow.next;
        slow.next = null;
        return dummy.next;
    }
Demon的黑与白
关注
专栏目录
哈希算法之 hashCode 为什么选择数字31作为优质乘子？
Aaron的blog
11-19 5380
哈希算法之 hashCode 为什么选择数字31作为优质乘子？ 详细说明 String hashCode 方法选择数字31的作为乘子的原因之前，我们先来看看 String hashCode 方法实现： public int hashCode() { int h = hash; if (h == 0 &amp;&amp; value.length &gt; 0) { char val[]...
js代码-面试题9：链表
07-15
6. **判断链表是否有环**：使用快慢指针（Floyd 判断环算法）来检查链表是否存在环。 ```javascript function hasCycle(head) { if (!head || !head.next) return false; let slow = head; let fast = head.next...
算法三十一：字符串匹配
闲狗的博客
07-04 927
问题描述 给定一个大串 A 和一个模式串 B，求 B 在 A 的哪些位置出现（输出这些出现位置的起始位置，下标从 0 开始）。 输入格式 第一行一个正整数 n，表示串 A 的长度。 第二行包含一个长度为 n 的串 A。 第三行一个正整数 m，表示串 B 的长度。 第四行包含一个长度为 m 的串 B。 保证串 A,B 只包含小写字母。 输出格式 对于每个 B 在 A 中出现的位置，...
算法-链表：反转链表的艺术
master_chenchen的博客
07-06 743
反转链表，顾名思义，就是将链表中的节点按照相反的顺序重新链接，使得链表的头部变成尾部，尾部变成头部。这一操作在数据结构的调整、算法优化等领域有着广泛的应用，尤其在需要改变数据访问顺序或进行数据预处理的场景中，更是不可或缺。
算法-链表：探索相交链表的奥秘
master_chenchen的博客
07-06 579
相交链表是指两个或多个链表共享一部分节点的现象。在C++中，链表由一系列节点构成，每个节点包含数据和指向下一个节点的指针。当两个链表的某部分节点重叠时，便形成了相交链表。这一特性在数据结构的分析和设计中显得尤为重要，尤其是在处理复杂的数据关系和优化数据查询效率方面。
数据结构：链表的奥秘与艺术
master_chenchen的博客
07-06 912
链表，一种线性数据结构，不同于数组，它不依赖于连续的内存位置，而是通过一系列的节点来存储数据，每个节点包含数据和指向下一个节点的指针。链表的灵活性和动态性，使其在需要频繁插入和删除元素的场景下大放异彩。
掌握核心数据结构与算法：链表、队列、栈、二叉树和哈希表
weixin_33816734的博客
09-01 1304
本文还有配套的精品资源，点击获取 简介：本主题旨在深入探讨IT编程中的核心数据结构和算法，包括链表、队列、栈、二叉树和哈希表，以及排序和查找算法。详细讨论了各种数据结构的特点、操作和应用场景，以及实现这些数据结构的基本方法和常见算法的时间复杂度。这对于面试准备和项目开发具有重要价值。 1. 链表、队列、栈、二叉树、哈希表概述 在计算机科学中，数据结构是组织和存储...
难题：反转链表
admin_zbn的博客
08-09 965
我要在反转链表中让2结点指向1结点，那我就要知道这两者的地址值，此时2这个结点的地址值就是prev，1结点的地址值就要在前面没有反转之前的链表中找了，
【算法】链表题的常用技巧及算法题（C++）
卜及中的博客
01-10 1224
通过对链表常用技巧、操作的介绍首先通过几道例题进行使用；后通过一系列算法题进行链表题的熟练
【算法】链表：21.合并两个有序链表（easy）
最新发布
m0_73726899的博客
10-01 388
双指针解决合并链表。
线性表实验：链表算法实现与源代码分析
4. 链表的实现细节 在链表的实现过程中，需要关注以下几个关键点： - 节点的定义：通常包含数据域和指向下一个节点的指针域。 - 链表头的定义：链表头通常需要一个指针指向链表的第一个节点。 - 插入和删除算法：...
数据结构与算法分析：链表合并及ADT解析
在图2-5中，算法通过指针pa、pb和pc来追踪当前处理的结点，最终形成一个新的合并后的链表Lc。这种操作通常在数据结构的排序算法中出现，比如归并排序。 接下来，提到了学习数据结构时需要掌握的技能，包括C语言编程...
C语言深度解析：链表、图及排序算法实现
链表是一种常见的基础数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。在C语言中实现链表通常涉及到结构体(struct)的定义，指针操作，以及动态内存分配（malloc和free函数）。 - 单向...
【Python数据结构与排序选择】：链表、数组与算法的最佳搭配
[【Python数据结构与排序选择】：链表、数组与算法的最佳搭配](https://media.geeksforgeeks.org/wp-content/cdn-uploads/20230726162542/Linked-List-Data-Structure.png) # 1. 数据结构和排序算法简介 数据结构和...
算法细节系列（18）：凸包的三种计算
热门推荐
Demon-初来驾到
05-15 2万+
算法细节系列（18）：凸包的三种计算 详细代码可以fork下Github上leetcode项目，不定期更新。 题目摘自leetcode： 1. Leetcode 587. Erect the Fence刷一道周赛题时遇到了相关的凸包计算，特此整理下，方便日后复查。不得不吐槽下，网上有很多关于凸包的算法，但完整实现的却不多，所以本文借着leetcode提供的测试数据，把一些基本的凸包算法都实现下
算法细节系列（3）：梯度下降法，牛顿法，拟牛顿法
Demon-初来驾到
12-16 1万+
算法细节系列（3）：梯度下降法，牛顿法，拟牛顿法迭代算法原型话不多说，直接进入主题。在我看来，不管是梯度下降法还是牛顿法，它们都可以归结为一个式子，即 x=ϕ(x) x = \phi(x) 也就是我们的不动点迭代法（fixed pointed iteration）最核心的迭代公式。神奇的式子，它该如何操作呢？用来干什么呢？不动点迭代法主要用于求解函数的零点。如求以下函数的零点， f(x)=x3
算法细节系列（13）：买卖股票
Demon-初来驾到
04-30 9518
买卖股票 该系列的题目意思很简单，但要在规定的时间复杂度内完成算法颇有难度。它有趣的地方在于它的解决思路，非常有趣。如果上一篇文章是为了破除想当然，那么这篇文章一定可以用异想天开来总结，我们一定得拎出一些核心的想法来引导算法。 题目均摘自leetcode，分为以下五题（买卖股票系列）。 121 Best Time to Buy and Sell Stock 122 Best Time to
POJ刷题指南
Demon-初来驾到
12-06 5886
POJ刷题指南 好久没写代码，编码能力退步了，后期争取每日一题，能刷多少是多少。 OJ上的一些水题(可用来练手和增加自信) (poj3299(√),poj2159(√),poj2739(√),poj1083(√),poj2262(√),poj1503(√),poj3006(√),poj2255(√),poj3094(√)) 好吧，这9道题的确挺水的，不过对于我们这种业余选手还是可以练
算法细节系列（25）：加减乘除
Demon-初来驾到
05-27 3710
算法细节系列（25）：加减乘除 详细代码可以fork下Github上leetcode项目，不定期更新。 题目摘自leetcode： Leetcode 227. Basic Calculator II Leetcode 150. Evaluate Reverse Polish Notation Leetcode 224. Basic Calculator Leetcode 227. Basic C
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值