链表题目总结

最新推荐文章于 2023-08-04 17:52:15 发布

weixin_39759634

最新推荐文章于 2023-08-04 17:52:15 发布

阅读量138

点赞数

分类专栏：算法与数据结构

本文链接：https://blog.csdn.net/weixin_39759634/article/details/113954419

版权

算法与数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文详细介绍了链表的基础操作，包括搜索、删除、特殊值查找，如链表中间节点、环形链表判断、回文链表检测。此外，还讲解了链表的各种操作，如反转、旋转、两两交换、重排、删除重复元素，以及如何将链表转换为二叉搜索树。同时，文章提到了哨兵节点和双指针等链表操作技巧。

摘要由CSDN通过智能技术生成

最近刷了一些链表相关的题目，在这里总结一下

1.单向链表的基础操作

class ListNode:
     def __init__(self, val=0, next=None):
         self.val = val
         self.next = next

1）搜索：就是一个接一个的遍历

2）返回一个链表只需要返回其头部节点即可

2）删除：有两道题，

（237）最基础的是完成删除的基本操作把当前节点变成下一个节点，val，next分别改成下一个节点的val和next
（203）稍微复杂一点的是真正的移除这个元素，即把前一个后一个元素连接在一起，需要考虑到没有前面的元素，因此需要构造一个虚节点指向头节点（常用技巧）

初始化哨兵节点为 ListNode(0) 且设置 sentinel.next = head。
初始化两个指针 curr 和 prev 指向当前节点和前继节点。
当 curr != nullptr：
比较当前节点和要删除的节点：
若当前节点就是要删除的节点：则 prev.next = curr.next。
否则设 prve = curr。
遍历下一个元素：curr = curr.next。
返回 sentinel.next。

作者：LeetCode
链接：https://leetcode-cn.com/problems/remove-linked-list-elements/solution/yi-chu-lian-biao-yuan-su-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.搜索列表中的特殊的值

1）链表的中间结点：

最简单的解法是遍历列表找到长度，第二遍遍历时到N/2返回值。还可以用快慢指针的方法，是一种常见的思路。

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow

2）环形链表：给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

构建快慢指针，如果快指针指向none则说明无环。如果有环，快慢指针第一次相遇时，slow指针位置不变，将fast指针重新指向链表头部节点；slow和fast同时每轮向前走 11步，当两指针重合时，返回slow指针的节点。

最直接的思路是路过这个节点就记录下来，如果之前走过则返回有环，否则是遍历结束后就是无环。

4）回文链表：

把链表的val添加到一个数组里面，看数组和反过来的数组是否相等。

3.对列表进行操作

1）反转链表：直观想可能会遍历完之后再反转，但是其实是一个一个的反转，把原来在后面的next的反转给前一个。需要设定pre和cur，然后反转完了，再把pre和cur按原来的顺序向后移动一位。

2）反转链表2：与上题的区别是反转m到n的链表，先反转前n个链表，然后在找到第m个节点。

第一步，如何递归的反转一个链表

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

第二部分，反转链表的前n个，只需要加一个参数n，每一次递归时n-1，最后的条件改变一下

if (n == 1) {
        topNSuccessor = head.next;
        return head;
    }

第三部分，增加参数m，每次递归时m-1，终止时返回reverse(head, n)

public ListNode reverseBetween(ListNode head, int m, int n) {
    if (m == 1) {
        return reverseTopN(head, n);
    }

    ListNode between = reverseBetween(head.next, m-1,n-1);
    head.next = between;
    return head;
}

//作者：hardcore-aryabhata
//链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/yi-bu-yi-bu-jiao-ni-ru-he-yong-di-gui-si-lowt/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3）旋转链表：给定一个链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

首先遍历链表，找到链表的尾部，将其与链表的头部相连形成环。然后新的尾部是n-k%n-1，新的头部是n-k%n，然后断开，令尾部的next等于0即可。

4）两两交换链表中的节点:

用迭代的思路，构造一个哑节点连接头节点，temp用于临时储存节点，要做的是交换temp.next 和temp.next.next 两个节点，要保证其存在，然后交换完了之后更新temp为交换后的第二个节点。

5）重排链表：给定一个单链表 L：L0→L1→…→Ln-1→Ln ，将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…注意是要不改变节点只改变其关系

利用快慢指针的方法找到中间的节点，l2为mid.next的部分，然后将l2倒过来，然后在重新派列表，一个l1的一个l2的。

6）删除排序链表中的重复元素 II：

先设定一个哑节点，指向头节点，比较dummy.next 和dummy.next.next如果不相等，则都往后移动一位。如果相等，直到找到不等的，再更新。

def deleteDuplicates(self, head):
        if not (head and head.next):
            return head
        dummy = ListNode(-1)
        dummy.next = head
        a = dummy
        b = head
        while b and b.next:
            # 初始化的时a指向的是哑结点，所以比较逻辑应该是a的下一个节点和b的下一个节点
            if a.next.val!=b.next.val:
                a = a.next
                b = b.next
            else:
                # 如果a、b指向的节点值相等，就不断移动b，直到a、b指向的值不相等 
                while b and b.next and a.next.val==b.next.val:
                    b = b.next
                a.next = b.next
                b = b.next
        return dummy.next

7）有序链表转换二叉搜索树

先找到链表的中间节点作为二叉树的根节点，根节点的val等于节点的val，然后更新root.left = buildTree(head, mid) 和root.right = buildTree(mid.next, None)。如果right和left相等，则返回None。

8）合并两个链表