【leecode】2-链表

原创 已于 2022-12-06 21:56:15 修改 · 290 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #leetcode

于 2022-12-04 21:29:00 首次发布
本文深入讲解了链表的基本概念及多种链表算法，包括移除链表元素、设计链表、反转链表等，并提供了详细的解题思路与代码实现。

2-链表

基础知识

  1. 链表是通过指针域的指针链接在内存中各个节点。
    所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
  2. 链表定义
// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

代码随想录

刷题参考：《代码随想录》

1-移除链表元素

链接: 203

题意：删除链表中等于给定值 val 的所有节点。
示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6， 输出：[1,2,3,4,5]
示例 2： 输入：head = [], val = 1， 输出：[]
示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

解法一

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

解法二：递归

  • 时间复杂度：O(n)，其中 n 是链表的长度。递归过程中需要遍历链表一次。
  • 空间复杂度：O(n)，其中 n 是链表的长度。空间复杂度主要取决于递归调用栈，最多不会超过 n 层。
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if (head == nullptr) {
            return head;
        }
        head->next = removeElements(head->next, val);
        return head->val == val ? head->next : head;
    }
};

2-设计链表

链接: 707

在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。 deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int val) {
        if (index > _size) {
            return;
        }
	if (index < 0) {
            index = 0;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

3-反转链表

链接: 206

题意：反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

解法一：双指针法

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

解法二：递归法

  • 时间复杂度：O(n)。
  • 空间复杂度：O(n)。
class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

解法三：递归法

  • 时间复杂度：O(n)。
  • 空间复杂度：O(n)。
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

4-两两交换链表中的节点

链接: 24

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例1：输入：head = [1,2,3,4]，输出：[2,1,4,3]
示例2：输入：head = [1]，输出：[1]

解法一：

代码随想录

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

解法二：递归法

思路
递归本质是不断重复相同的事情，而不是去思考完整的调用栈。我们应该关注一级调用小单元的情况，也就是单个f(x)。
其中我们应该关心的主要有三点：

  1. 返回值
  2. 调用单元做了什么
  3. 终止条件

在本题中：

  1. 返回值：交换完成的子链表
  2. 调用单元：设需要交换的两个点为 head 和 next，head 连接后面交换完成的子链表，next 连接 head，完成交换
  3. 终止条件：head 为空指针或者 next 为空指针，也就是当前无节点或者只有一个节点，无法进行交换
  • 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
  • 空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

5-删除链表的倒数第 N 个结点

链接: 19

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？
示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
示例 2： 输入：head = [1], n = 1 输出：[]
示例 3： 输入：head = [1,2], n = 1 输出：[1]

  • 时间复杂度：O(L)，其中 L 是链表的长度。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};

6-链表相交

链接: 面试题 02.07

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。

解法一： 双指针

  • 时间复杂度：O(m+n)，其中 m 和 n 是分别是链表headA 和headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        ListNode *pA = headA, *pB = headB;
        while (pA != pB) {
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return pA;
    }
};

解法二：哈希表

  • 时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。需要遍历两个链表各一次。
  • 空间复杂度：O(m)，其中 m 是链表headA 的长度。需要使用哈希集合存储链表 headA 中的全部节点。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

解法三：双指针法

  • 时间复杂度：O(m+2n)，其中 m 和 n 是分别是链表headA 和headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

7-环形链表II

链接: 142

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。

快慢指针

思路

设开始位置到入环为a，环为b，相遇处距环入口为x，慢指针每次走1步，走s，快指针每次走2步，走f

  1. f = 2s；
  2. f = a + nb + x
  3. s = a + x //快指针相对慢指针每次走1，因此在慢指针走完一圈前一定能被追上
    ----> a + x = nb //n为相遇前快指针多走的圈数
  4. 环入口：a + mb //m为任意整数
    ----> 快慢指针相遇后再走a即可到达环入口
  • 时间复杂度 O(N) ：第二次相遇中，慢指针须走步数 a<a+b；第一次相遇中，慢指针须走步数a+b−x<a+b，其中 x 为双指针重合点与环入口距离；因此总体为线性复杂度；
  • 空间复杂度 O(1) ：双指针使用常数大小的额外空间。
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1278
Leetcode刷题方法总结---链表全解
【leecode链表】面试刷题-链表 python3实现
wenxuegeng的专栏
04-04 830
待补充（简单） leecode 19 : 删除链表的倒数第 N 个结点（python3）（中等） 题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 常规解法： 踩坑点：这道题主要要考虑的问题是边界处理，当n=1和n=链表长度时要做特殊处理 思路： 1. 获取链表总长度len，如果n==len，返回head.next 2.设置两个指针，如果n==1，将最后一个节点设置为No..
LEECODE-链表-链表相交
m0_51587184的博客
10-13 176
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。在 B 中，相交节点前有 3 个节点。在 B 中，相交节点前有 1 个节点。相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。链表中有一个环，其尾部连接到第一个节点。
leecode--链表对折
Tom098的博客
07-05 1089
面试中问了一个链表对折的问题，写的完全不着边。后来百度了一下，自己根据原理重新写了一下。 package leecode; public class FoldLinkedList { public static void main(String[] args) { Node node1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node.
Leecode题解---链表
m0_51435111的博客
05-05 609
文章目录27.移除元素82.删除排序链表中的重复元素206.反转链表 27.移除元素 解题思路: 思路1: 看到这个题,首先我们想到是创建一个新数组,然后遍历数组,将值不是val的元素,插入到新数组,然后返回新数组,但是这个题目要求的空间复杂度是O(1),不能这样做,但是我们还是写下这个方法的题解 public int removeElement(int[] nums, int val) { if (nums.length == 0) { return 0;
LEECODE-链表-链表操作
m0_51587184的博客
10-11 161
难度简单1045给你一个链表的头节点head和一个整数val，请你删除链表中所有满足的节点，并返回。
leecode 141- 环形链表
qq_46440072的博客
10-11 575
null ，因为Java中存在短路机制当前面的条件不满足时，是不会判断后面的条件的，如果把 fast.next!一直向HashSet中加入节点，当加不进去得时候就说明存在环，如果加到最后都没问题，那就不存在环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。用两个指针，一个快一个慢，快指针一次走两步，慢指针一次走一步，如果它们能相遇，那么就说明链表里存在环。
leecode 206-反转链表
qq_46440072的博客
10-08 530
很基础一个链表操作，思路就是新建一个链表，然后把原来的链表按照头插法插入到新链表就行了，注意最好是用一个带头结点的链表，这样在插入元素时方便一点。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]链表中节点的数目范围是 [0, 5000]输入：head = [1,2]输出：[5,4,3,2,1]输入：head = []
LEECODE-链表-初步
m0_51587184的博客
10-11 349
或C++的默认构造。
leecode 142-环形链表 II
qq_46440072的博客
10-11 504
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。简单来说就是，当相遇时，快指针走的路程减去慢指针走的路程是等于链表中环的整数倍，又因为快指针路程是慢指针的两倍，所以慢指针走的路程是环的整数倍，从相遇点与头节点一起出发，第一次相遇的点一定是环的入口。利用HashSet非常简单，首先利用HashSet不能重复存储的机制，让每一个节点挨个存储到HashSet中，第一个存不进去的节点就是入环的第一个和节点。解释：链表中有一个环，其尾部连接到第一个节点。
leecode-反转链表
weixin_63082397的博客
10-25 281
使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret .此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转。pre 在前 cur 在后。每次让 pre 的 next 指向 cur ，实现一次局部反转。局部反转完成之后，pre 和 cur 同时往前移动一个位置。循环上述过程，直至 pre 到达链表尾部。当递归函数全部出栈后，链表反转完成。
Leecode--offer:关于Leecode上剑指优惠的全部题解以及思路
04-05
2. **链表**：链表题目常常考察节点操作，如判断环、合并两个有序链表、反转链表等。例如，"删除链表中的节点"需要理解链表结构并能精确修改节点指针。 3. **字符串**：字符串处理涉及到字符比较、模式匹配、编码...
Leecode-Solutions:利码
03-21
通过解决这些问题，你不仅能够掌握编程语言的语法，还能深入理解数据结构，如链表、树、堆、队列、栈等，以及如何在实际问题中应用它们。 最后，压缩包中的"Leecode-Solutions-master"可能是指包含所有LeetCode问题...
LeetCode 445 - 两数相加 II
网罗天下方法，方便你我开发！！！
12-09 778
这道题是经典链表加法的“升级版”。和普通相加不同的是： 数字是“从高位到低位”存储的（反着来）。 输入链表不能被翻转（进阶要求）。 因此不能直接像 LeetCode 2 那样从头开始相加，只能想办法把最高位的数字放到最后进行计算。
力扣513 找树左下角的值 java实现
m0_58648798的博客
12-10 276
摘要 本文介绍了一个二叉树问题：找出二叉树最底层最左边节点的值。通过深度优先搜索（DFS）遍历二叉树，记录当前最大深度和对应的节点值。算法实现使用递归方式，优先遍历左子树，当遇到叶子节点时更新最大深度和结果值。代码示例展示了Java实现，时间复杂度为O(n)，空间复杂度为O(h)，其中h为树的高度。该解法适用于任意非空二叉树，能够正确处理各种树形结构的情况。
LeetCode 49. 字母异位词分组 | 从排序到计数的哈希表优化之路
最新发布
MTYSYS19990212的博客
12-12 438
本文介绍了LeetCode「字母异位词分组」题目的两种解法：暴力法和优化法。暴力法通过两两比较和排序判断异位词，时间复杂度为O(n²k log k)，效率较低。优化法利用哈希表，以排序后的字符串为键自动分组，时间复杂度降为O(nk log k)。文章详细解析了两种方法的实现逻辑、代码示例和复杂度分析，并附有图文演示说明哈希表的工作过程。最终推荐采用排序+哈希表的优化方案，能高效解决字母异位词分组问题。
力扣-从中序与后序遍历序列构造二叉树
2501_92020469的博客
12-08 355
具体实现时，反向遍历后序数组（遍历顺序为「根→右→左」），用栈记录待处理的节点，通过哈希表快速定位节点在中序数组的索引：若当前节点索引大于栈顶节点索引，说明是栈顶的右子节点；若更小，则回溯栈找到父节点，作为父节点的左子节点，最终迭代完成整棵树的构建。两种方法逻辑完全对称：仅根节点位置（先序首元素/后序尾元素）、遍历方向（先序正序/后序逆序）、子节点判断条件（左子节点索引更小/右子节点索引更大）不同，核心都是通过栈记录节点、哈希表快速定位索引，规避递归缺陷的同时保证高效性。三、与先序+中序迭代法的核心关联。
day28（12.8）——leetcode面试经典150
2401_82757880的博客
12-08 269
这个跟上面的那道题有点类似。
day32（12.12）——leetcode面试经典150
2401_82757880的博客
12-12 213
这道题的重点是在获取更新最小值的时候，一定要加上<=，因为栈中可能为空；同时比较大小的时候要用equals来比较数值。
leecode链表
03-28
<think>好的，我现在需要帮助用户寻找LeetCode上链表相关的练习题和解法。首先，我得回忆一下用户提供的引用内容，看看里面提到的题目有哪些。引用[1]提到合并链表，引用[2]列出了多个题目，比如203移除链表元素、707设计链表、206反转链表、142环形链表、19删除倒数第N个节点、面试题02.07链表相交。引用[3]补充了更多题目，比如链表的中间节点、链表分割、回文结构、相交链表、环形链表II、复制带随机指针的链表。引用[4]主要讲反转链表的解法。 接下来，我需要将这些题目分类整理，方便用户逐步练习。可能的基础题包括移除链表元素、反转链表、设计链表，这些题目帮助掌握链表的基本操作。然后是进阶题，比如环形链表、合并有序链表、删除倒数节点，这些涉及快慢指针和递归等技巧。最后是综合应用题，如链表相交、回文结构、复杂链表的复制，这些题目需要综合运用多种方法。 在整理每个题目时，需要简要说明解题思路和关键点，比如移除元素可能需要虚拟头节点，反转链表可以用迭代或递归，环形链表使用快慢指针找环。同时，要确保提到的解法与引用中的内容相符，比如引用[4]提到的反转链表的自解代码，可以建议用户参考。 另外，用户可能需要相关的学习资源，所以应该根据引用提供的链接，比如代码随想录的刷题指南，推荐给用户。同时，提醒用户注意链表处理的常见技巧，如虚拟头节点、指针操作等，这些都是引用[2]和[3]中提到的内容。 最后，生成相关问题时要考虑用户可能的后续需求，比如不同难度题目的区分、时间复杂度的优化、具体题目的代码实现等。这样用户可以根据自己的进度进一步探索。</think>### LeetCode链表练习题及解法指南 链表是数据结构中的基础题型，以下整理LeetCode经典题目及解法思路，按难度分级并标注关键技巧： --- #### **一、基础操作题（掌握指针操作）** 1. **203. 移除链表元素** - **要求**：删除链表中所有等于给定值的节点。 - **解法**：使用**虚拟头节点**简化删除逻辑，避免处理头节点特殊情况[^2]。 - **示例代码**： ```python def removeElements(head, val): dummy = ListNode(0, head) curr = dummy while curr.next: if curr.next.val == val: curr.next = curr.next.next else: curr = curr.next return dummy.next ``` 2. **206. 反转链表** - **要求**：将链表完全反转。 - **解法**：迭代法（双指针）或递归法。迭代法中维护`prev`和`curr`指针逐步反转[^4]。 - **关键代码**： ```python def reverseList(head): prev, curr = None, head while curr: next_node = curr.next curr.next = prev prev = curr curr = next_node return prev ``` 3. **707. 设计链表** - **要求**：实现链表的增删查操作。 - **关键点**：使用虚拟头节点统一操作逻辑，注意边界条件。 --- #### **二、进阶技巧题（快慢指针/递归）** 4. **142. 环形链表 II** - **要求**：判断链表是否有环，并返回环的入口。 - **解法**：快慢指针相遇后，重置指针找入口[^3]。 - **公式推导**：设环前长度$L$，环周长$C$，相遇时快指针比慢多走$C$，可证入口在$L$处[^3]。 5. **21. 合并两个有序链表** - **要求**：合并两个升序链表为一个新链表。 - **解法**：递归（比较头节点大小，递归合并剩余部分）或迭代（双指针遍历）。 6. **19. 删除链表的倒数第N个节点** - **要求**：删除倒数第N个节点。 - **解法**：快指针先走$N$步，再同步移动快慢指针[^2]。 --- #### **三、综合应用题（多方法结合）** 7. **160. 相交链表** - **要求**：找到两个链表的相交节点。 - **解法**：双指针遍历两链表，路径长度互补消除差值。 8. **234. 回文链表** - **要求**：判断链表是否为回文。 - **解法**：快慢指针找中点，反转后半部分后比较。 9. **138. 复制带随机指针的链表** - **要求**：深拷贝含随机指针的链表。 - **解法**：哈希表映射原节点到新节点，分两步处理`next`和`random`指针。 --- #### **四、学习资源推荐** - **系统教程**：参考[代码随想录的链表专题](https://leetcode-cn.com/circle/article/wGp7Y9/)。 - **高频题目**：按顺序练习上述题目，逐步掌握**虚拟头节点、双指针、递归**等技巧。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值