链表问题

最新推荐文章于 2023-06-11 13:56:52 发布

原创最新推荐文章于 2023-06-11 13:56:52 发布 · 510 阅读

0 ·

CC 4.0 BY-SA版权

算法小结专栏收录该内容

18 篇文章

订阅专栏

本文详细探讨了多个链表相关的问题，包括链表是否有环、删除节点、合并排序链表、翻转链表等，并提供了相应的AC解决方案，涉及双指针、递归、排序等多种算法思想。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本博客解决链表问题

141. Linked List Cycle

要求：链表是否有环
ac:两个指针fast，slow

142. Linked List Cycle II

要求：发现链表是否有环，如果有环，返回环路起始位置
ac：两个指针的问题

237. Delete Node in a Linked List

ac：将下个结点的值赋给当前的结点

83. Remove Duplicates from Sorted List

要求：重复的元素只保留一个
ac：一个指针就可以解决

82. Remove Duplicates from Sorted List II

要求：重复的元素全部删除
ac：这个需要这个算是有点复杂了，需要连续的两个循环操作，

203. Remove Linked List Elements

要求：删除链表中的值等于某个值的结点. 类似的还有数组删除的情况
ac：注意dummy以及删除完列表结点为空的情况

206. Reverse Linked List

要求：链表反转
ac：需要三个指针

public ListNode reverse(ListNode node) {
    if (node == null || node.next == null) return node;
    ListNode dummy = null;
    while (node != null) {
        ListNode next = node.next;
        node.next = dummy;
        dummy = node;
        node = next;
    }
    return dummy;
}

92. Reverse Linked List II

要求：反转部分链表
ac：用到4个缓存结点，注意连接地方的拼接

234. Palindrome Linked List

要求：判断链表是否回文
ac：反转中点

21. Merge Two Sorted Lists

要求：有序链表合并
ac：归并排序的一部分

61. Rotate List

要求：旋转链表，
错误：空指针异常
ac：先找到长度，再找到新的链表的起点，对端点进行合理的处理

148. Sort List

要求：常数空间
ac：归并与快排
这里给出代码

 //归并排序
  public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode fast = head;
        ListNode pre = null;
        while (fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        pre.next = null;
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        return merge(l1, l2);
    }
    public ListNode merge(ListNode l1,ListNode l2) {
        ListNode head = new ListNode(0), p = head;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                p.next = l1;
                l1 = l1.next;
            } else {
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }
        if (l1 != null) {
            p.next = l1;
        } 
        if (l2 != null) {
            p.next = l2;
        }
        return head.next;
    }
   // hulu
   // 链表快排,经常考的
   public ListNode void quickSort(ListNode head, ListNode tail) {
        if (head != tail) {
            ListNode partion = getPartion (head, tail);
            quickSort(head, partion);
            quickSort(partion.next, tail);
        }
        return head;
    }
    public static ListNode getPartion(ListNode beg, ListNode end) {
        int key = beg.val;
        ListNode p = beg; 
        ListNode q = beg.next;// quick 
        while (q != end) {
            if (q.val < key) {
                p = p.next;
                swap(p, q);
            }
            q = q.next;
        }
        swap(beg, p);
        return p;
    }
    public static void swap(ListNode p, ListNode q) {
        int temp = p.val;
        p.val = q.val;
        q.val = temp;
    }

147. Insertion Sort List

要求：链表的插入排序
思路：每次每次插入的时候找到第一个大于当前结点的值的地方插入
错误：无思路, 忘记更新pre
ac：新建了一个链表

143. Reorder List

要求：给定链表 L0 L1 L2 L3 … LN
Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
思路：取到一半，反转另一半然后合并
错误：链表反转部分，指针异常，可以先将pre赋值为null