算法：链表

已于 2023-04-26 19:45:33 修改
阅读量428 收藏 4
点赞数
分类专栏： 面试 数据结构和算法 文章标签： 算法
于 2023-03-02 22:04:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love667767/article/details/129300708
版权

链表

一、概述

链表（Linked List）是最简单的线性的、动态数据结构。理解它是理解树结构、图结构的基础。

区别于数组，链表中的元素不是存储在内存中连续的一片区域，链表中的数据存储在每一个称之为「结点」复合区域里，在每一个结点除了存储数据以外，还保存了到下一个节点的指针（Pointer）。
在这里插入图片描述

由于不必按顺序存储，链表在插入数据的时候可以达到 O(1) 的复杂度，但是查找一个节点或者访问特定编号的节点则需要 O(n) 的时间。

二、常见算法

1. 反转：反转链表(单链表)

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

在这里插入图片描述

解题思路：

需要引入两个变量来记录当前节点和上一个节点，用于链表反转的时候使用。

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    // 定义一个前置节点，用于设置反转后的next值。
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
    	// 1.取当前Node节点的下一个Node节点，因为当前Node节点反转后，Node.next要指向上一个Node节点，所以这里要先获取到。
        ListNode next = cur.next;
        // 2.将上一个Node节点放到当前节点的next属性中，表示反转过程。
        cur.next = pre;
        // 3.pre和cur两个Node节点向右平移一个Node，从而进入下次循环。
        pre = cur;
        cur = next;
    }
    // 4.最终pre指向最后一个Node节点，而它又是反转后的新链表头。
    return pre;
}

2. 反转：反转链表(双链表)

给你双链表的头节点 head ，请你反转链表，并返回反转后的链表。

解题思路：

相比于单链表，双链表多了一个当前Node节点指向上一个Node节点的操作。

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = pre;
        // 相比于单链表，双链表多了一个当前Node节点指向上一个Node节点的操作。
        cur.last = next; 
        pre = cur;
        cur = next;
    }
    return pre;
}

3. 反转：K 个一组翻转链表

LeetCode K 个一组翻转链表
LeetCode 两两交换链表中的节点

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

  • k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

在这里插入图片描述
解题思路：

  1. 要对一个单链表进行每k个节点为一组进行反转。所以需要有一个函数可以返回第n组的第k个的节点。
  2. 对第n组的k个元素进行反转，这就是单纯的单链表反转。
  3. 链表头尾连接。
    • 将第 i-1 组的尾节点与第 i 组的头结点进行连接。
    • 将第 i+1 组的头结点与第 i 组的尾节点进行连接。
  4. 移动前一个节点和当前节点的Node节点指向。
public ListNode reverseKGroup(ListNode head, int k) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode virtualNode = new ListNode(0);
    virtualNode.next = head;
	// 设置虚拟节点。
    ListNode pre = virtualNode;
    // 从第1个虚拟节点开始。
    ListNode end = virtualNode;
	
    while (end != null) {
        // 找到第1组的最后一个节点。
        end = findKNode(end, k);
        // 如果end为null，说明最后一组节点个数不足k个，因此不需要执行后面的链表反转。
        if (end == null) {
            break;
        }
        // 获取实际需要反转的链表。
        // pre.next为第i组的头节点。
        ListNode start = pre.next;
        // end.next为第i组的尾节点，也是第i+1组的头结点。
        ListNode next = end.next;
        // 反转第i组的k个元素，并返回第i组的头结点。
        ListNode groupHead = reverseK(start, next);
        // 将第i组的头结点与第i-1组的尾结点进行关联。
        pre.next = groupHead;
        // 将第i组的尾结点与第i+1的头结点进行关联。
        start.next = next;
		// 移动pre和end节点到第i组元素的尾结点。
        pre = start;
        end = pre;
    }
    // 虚拟节点的下一个节点为实际的链表头。
    return virtualNode.next;
}

// 获取传入节点的后面第k个节点。
public ListNode findKNode(ListNode head, int k) {
    for (int i = 0; i < k; i++) {
        if (head != null) {
            head = head.next;
        } else {
            break;
        }
    }
    return head;
}

// 单链表反转，传入的end节点为结束节点，该节点不包含在当前这一组中。并返回反转后的头结点。
public ListNode reverseK(ListNode head, ListNode end) {
    ListNode pre = null;
    ListNode cur = head;
    while (cur != end) {
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}

4. 合并：两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

在这里插入图片描述
解题思路：

  1. 两数和的关键点在于同一个位置上的两个数之和如果大于等于十，需要进位。
  2. 通过设置虚拟节点作为头部方便操作。
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    if (l1 == null && l2 == null) {
        return null;
    }
    ListNode virtualNode = new ListNode(0);
    ListNode curNode = virtualNode;
    // 用于求和
    int sum = 0;
    while (l1 != null || l2 != null) {
    	// 计算l1节点与sum的和。
        if (l1 != null) {
            sum += l1.val;
            l1 = l1.next;
        }
        // 计算l2节点与sum的和。
        if (l2 != null) {
            sum += l2.val;
            l2 = l2.next;
        }
        // 利用除余来计算个位数的值。
        curNode.next = new ListNode(sum % 10);
        curNode = curNode.next;
        // 计算十位数，如果sum>=10，则值为1；如果sum<10，则值为0。
        sum /= 10;
    }
    // 判断最后一位是否有进位。
    if (sum == 1) {
        curNode.next = new ListNode(sum);
    }
    return virtualNode.next;
}

5. 合并：合并两个有序链表

LeetCode 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

在这里插入图片描述

解题思路：

  1. 利用双指针分别指向两个链表，然后遍历比较两个链表的值，将值较小的节点放入合并后的链表中。
  2. 利用虚拟节点作为头结点来简化操作。
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
    if (list1 == null && list2 == null) {
        return null;
    }
    // 构建虚拟节点，方便头结点的操作。
    ListNode virtualNode = new ListNode();
    ListNode curNode = virtualNode;
    
    while (list1 != null || list2 != null) {
    	// 两个链表都有值。
        if (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                curNode.next = new ListNode(list1.val);
                list1 = list1.next;
                curNode = curNode.next;
            } else {
                curNode.next = new ListNode(list2.val);
                curNode = curNode.next;
                list2 = list2.next;
            }
        } else if (list1 != null) {
        	// list1有值，list2已经没有值了，所以将list1剩余部分添加到链表尾部。
            curNode.next = list1;
            break;
        } else if (list2 != null) {
        	// list2有值，list1已经没有值了，所以将list2剩余部分添加到链表尾部。
            curNode.next = list2;
            break;
        }     
    }
    return virtualNode.next;
}

6. 合并：合并K个升序链表

LeetCode 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。

在这里插入图片描述

解题思路：

从上一题合并两个有序链表我们可以知道，要将K个有序链表合并成1个，就需要对K个链表的头结点进行值的比较。如果采用遍历的方式进行，效率会相对较低。此时我们可以利用最小堆的特点，即最小的元素在堆顶此时我们只需要将堆顶元素取出并放入合并后的链表中，并将取出的节点的下一个节点放入最小堆中进行比较，如此往复即可合并K个有序链表。

public ListNode mergeKLists(ListNode[] lists) {
    if (lists == null || lists.length == 0) {
        return null;
    }
    // 构建最小堆。
    PriorityQueue<ListNode> heap = new PriorityQueue(new Comparator<ListNode>() {
        @Override
        public int compare(ListNode o1, ListNode o2) {
            return o1.val - o2.val;
        }
    });

    ListNode virtualNode = new ListNode();
    ListNode curNode = virtualNode;
    // 先将K个链表的头结点放入堆中。
    for (int i=0; i<lists.length; i++) {
        if (lists[i] != null) { //这里需要过滤null的值。
            heap.offer(lists[i]);
        }
    }
    
    while (!heap.isEmpty()) {
    	// 从堆顶取出元素放入合并后的链表中，并将堆顶元素的下一个节点放入堆中。
        ListNode pop = heap.poll();
        if (pop.next != null) {
            heap.offer(pop.next);               
        }
        curNode.next = new ListNode(pop.val);
        curNode = curNode.next;
    }
    return virtualNode.next;
}

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

LeetCode 删除链表的倒数第 N 个结点
LeetCode 删除排序链表中的重复元素

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

在这里插入图片描述
解题思路：

  1. 利用虚拟节点作为头结点，避免删除第1个节点引起的操作复杂性。
  2. 利用快慢指针来实现。
    • 让快指针先往前走n步，然后两个指针一起走。当快指针指向的节点为null时，此时慢指针所指向的节点即为要删除的节点。但是由于这是一个单链表，慢指针所指向的节点无法知道它的前一个节点，所以我们需要使用一个变量保存慢指针的前一个节点，方便进行节点的删除操作。
public ListNode removeNthFromEnd(ListNode head, int n) {
    if (head == null || n <= 0) {
        return head;
    }
    ListNode virtualNode = new ListNode(0);
    virtualNode.next = head;
    // 快指针
    ListNode fastNode = virtualNode;
    // 慢指针
    ListNode slowNode = virtualNode;
    // 保存慢指针的前一个节点
    ListNode preSlowNode = null;
    // 结束条件为快指针指向null。
    while (fastNode != null) {
        if (n == 0) {
        	// 移动慢指针的指向。
            preSlowNode = slowNode;
            slowNode = slowNode.next;
        } else {
        	// 快指针先向后走n步。
            n--;
        }
        // 移动快指针的指向。
        fastNode = fastNode.next;
    }
    // 通过慢指针的前一个节点删除慢指针节点。
    preSlowNode.next = slowNode.next;
    return virtualNode.next;
}

8. 删除：删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

在这里插入图片描述

解题思路：

  1. 构建虚拟节点，方便操作。
  2. 保存当前节点的前一个节点，用于比较前后两个节点值是否相同，如果相同，则当前节点继续向后执行。
public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode virtualNode =  new ListNode();
    virtualNode.next = head;
    ListNode pre = virtualNode;
    ListNode cur = virtualNode;
    while (cur != null) {
        if (pre != virtualNode && pre.val == cur.val) {
            pre.next = cur.next; // 删除节点
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return virtualNode.next;
}

9. 删除：删除排序链表中的重复元素 II

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

在这里插入图片描述

解题思路：

  1. 解法与上一题类似，但是需要跳过所有相同元素的节点，所以需要一个while循环执行此操作。
  2. 需要注意对 pre 和 pre.next 进行赋值操作的条件判断。
    • 如果对 pre 进行赋值，说明 cur 的节点值是唯一的。
    • 如果对 pre.next 进行赋值，说明 cur 的节点值不唯一，需要直接跳到下一个与cur 不同值的节点。
public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode virtualNode =  new ListNode(-1);
    virtualNode.next = head;
    ListNode pre = virtualNode;
    ListNode cur = head;
    while (cur != null) {
    	// 循环跳过相同的元素。
        while (cur.next != null && cur.val == cur.next.val) {
            cur = cur.next;
        }
        // 这个条件成立，说明cur指向的节点元素只有一个。
        if (pre.next == cur) {
            pre = pre.next;
        } else {
        	// 否则，就将pre.next指向cur相同元素的最后一个节点。
            pre.next = cur.next;
        }
        cur = cur.next;
    }
    return virtualNode.next;
}

10. 环形：环形链表的判断 I

LeetCode 环形链表

  • 给你一个链表的头节点 head ，判断链表中是否有环。
  • 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
  • 如果链表中存在环 ，则返回 true 。 否则，返回 false 。

在这里插入图片描述

解题思路：

  1. 利用快慢指针，快指针一次走2步，慢指针一次走1步。
    • 如果链表有环，必然存在快慢指针指向同一个Node节点。
    • 如果快指针值为 null 时，则表示链表无环。

有环：

public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head;
    ListNode fast = head;
	// 如果两个指针不指向同一个节点，就一直循环下去，直到快指针指向链表末尾
    while (true) {
    	// 退出条件，fast指针优先走到链表末尾。
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) {
			return true;
		}
    }
}

11. 环形：环形链表 II (入环点)

如果单项链表有环，请返回入环点的节点。

在这里插入图片描述

解题思路：

  1. 利用快慢指针，快指针一次走2步，慢指针一次走1步。
    • 如果链表有环，必然存在快慢指针指向同一个Node节点。
    • 如果快指针值为 null 时，则表示链表无环。
  2. 当两个指针指向同一个Node节点时，此时将快指针指向链表头，然后让快慢指针每次直走1个节点，当他们再次相遇时，该节点即为入环节点。
public ListNode detectCycle(ListNode head) {
    if (head == null || head.next == null) {
        return null;
    }
    ListNode slow = head;
    ListNode fast = head;
	// 这部分与校验链表是否有环一样。
    while (true) {
        if (fast == null || fast.next == null) {
            return null;
        }
        slow = slow.next;
        fast = fast.next.next;
        if (fast == slow) break;
    }
	// 将快指针挪回到链表头，然后与慢指针一起每次向后移动1个节点，当快慢指针指向同一个节点时，该节点即为入环点。
    fast = head;
    while (slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    // 返回入环点
    return fast;
}
Elson_6
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表相关算法汇总（详细）
泛泛之素
06-06 7995
链表基础知识 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(log
算法题：链表
qq_43721730的博客
12-29 313
算法题：链表 1.反转链表 描述 给定一个单链表的头结点pHead，长度为n，反转该链表后，返回新链表的表头。 数据范围： n\leq1000n≤1000 要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(N
链表——基本算法
sy2453的博客
02-09 2034
1、反转链表 给出3个指针，一个cur，用于遍历链表中的每个节点，一个prev，用于保存cur指向的节点的上一个节点地址，还有一个after，用于保存cur指向的节点的下一个节点地址，链表操作遵循先连后断，即 ...
常见链表算法
谢华龙的专栏
05-10 719
链表节点的数据结构为 struct node { int data; struct node* next; } 1.创建链表 1）前插法 void create_list() { int len; head=(node*)malloc(sizeof(node)); head->next=NULL; cout>len; while(le
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
详解链表相关算法
LynnWonder
02-02 408
链表（linked list）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。[算法导论链表相关的题解](https://walkccc.me/CLRS/Chap10/10.2/)。本文将从概念，基础算法，常见题目等方面进行陈述。
算法-链表
weixin_51360664的博客
03-07 303
1.移除链表元素 删除链表中等于给定值 val 的所有节点。 class Solution: def removeElements(self,head,val): dummy_head = ListNode(next=head) cur = dummy_head while cur.next: if cur.next.val == val: cur.next = cur.next.next
数据结构与算法：链表、二叉树、并查集、图、排序算法、贪心算法、动态规划、单调栈、KMP等.zip
01-04
图算法包括最短路径算法（如Dijkstra算法和Floyd-Warshall算法）、拓扑排序、最小生成树（如Prim算法和Kruskal算法）等。 5. **排序算法**：排序是将一组数据按特定顺序排列的过程。常见的排序算法有冒泡排序、插入...
LinkedList:链表算法
04-13
链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中。 GET n-从...
算法：给定一个链表，判断链表中是否存在环
最新发布
07-11
中等难度算法。 重在对链表的使用。对算法有一定的认识。 用python、c语言、java、javascript语言实现算法方便不同语言学习者的理解。
C++算法：N个排序链表合并
10-10
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [  1->4->5,  1->3->4,  2->6 ] 输出: 1->1->2->3->4->4->5->6
【数据结构】链表的十三种操作
littlegengjie的博客
10-25 1326
双向链表链表的初始化、销毁、清空、链表长度、求双向链表前驱、后继、遍历链表，头插法输入链表、双向链表逆序存放。
链表相关算法
weixin_41297594的博客
07-02 451
大道无形
链表相关算法详解：揭秘链表操作的奥秘
fudaihb的博客
12-15 693
链表是数据结构中常见的一种形式，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表操作是编程中常用的技术之一，本文将详细介绍链表的常见操作及相关算法，并通过举例说明，帮助读者更好地理解和运用链表。
一文搞懂leetcode加法运算
凯凯王的技术生涯
08-04 397
运算公式 sum=x+y+carry; current=sum%10; carry=sum/10;
【面试高高手】—— 笔试题（4题）
是江迪呀 的博客
09-22 892
笔试题
【数据结构-链表】链表的相关算法
Mount256的博客
11-07 670
【数据结构-链表】链表的相关算法
数据结构(List) — ArrayQueue 源码分析
Elson的博客
05-18 3571
一、概述 二、类图 三、源码分析 四、小结 一、概述 版本： JDK1.8 ArrayQueue 是一个循环队列(Queue)，继承了 AbstractList 抽象类，内部通过数组的方式来实现。 二、类图 三、源码分析 public class ArrayQueue&amp;lt;T&amp;gt; extends AbstractList&amp;lt;T&amp;g...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值