leetcode-链表十题

最新推荐文章于 2025-05-21 08:35:29 发布
原创 最新推荐文章于 2025-05-21 08:35:29 发布 · 197 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析链表算法，涵盖删除倒数第N个节点、删除链表节点、去除重复元素、链表旋转、节点配对交换、链表反转、链表区间反转、查找链表交点、检测链表环、链表排序等核心问题，提供详尽的思路与代码实现。

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

总结自：https://www.bilibili.com/video/BV1jt411J7tC

19. Remove Nth Node From End of List

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.
Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

思路：

双指针，因为要删除倒数第n个节点，那么就要找到倒数第n+1个节点，所以其中一个指针先向右移动n个节点，这样当靠右的节点到达链表尾的时候，另一个指针即指向倒数第n+1个节点

要点：

ListNode(int x) : val(x), next(NULL) {}	// 用来初始化
auto dummy = new ListNode(-1);	// auto会根据等号右边的值的类型对确定变量的类型
ListNode* dummy = new ListNode(-1); // 跟上一条等价

因为可能删除的是头节点，因此我们创建一个虚拟的节点指向头节点，并且最终返回虚拟节点的下一个节点，这样当被删除的是头节点时也不需要特殊判断

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}	
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        auto dummy = new ListNode(-1);
        dummy->next = head;

        auto first = dummy, second = dummy;
        while(n--) first = first->next;
        while(first->next)
        {
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next;

        return dummy->next;
    }
};
237. Delete Node in a Linked List

Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.

Given linked list – head = [4,5,1,9], which looks like following:

image-20200401111218974

Example 1:

Input: head = [4,5,1,9], node = 5
Output: [4,1,9]
Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
Example 2:

Input: head = [4,5,1,9], node = 1
Output: [4,5,9]
Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.

Note:

The linked list will have at least two elements.
All of the nodes’ values will be unique.
The given node will not be the tail and it will always be a valid node of the linked list.
Do not return anything from your function.

思路：一般要删除一个节点，我们要找到该节点的前一个节点，但这道题只给出要删除的节点，所以我们复制该节点的后一个节点的值，然后删除后一个节点，这样从整个链表上看就好像是删除了该节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
        // 上面两句可以简写为
        // *(node) = *(node->next);
    }
};
83. Remove Duplicates from Sorted List

Given a sorted linked list, delete all duplicates such that each element appear only once.

Example 1:

Input: 1->1->2
Output: 1->2
Example 2:

Input: 1->1->2->3->3
Output: 1->2->3

思路：遍历一遍，如果该节点的值和下一个节点的值相同，就删去下一个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        auto temp = head;
        while(temp)
        {
            if(temp->next && temp->val == temp->next->val) // 注意判下个节点是否为空
                temp-> next = temp->next->next;
            else
                // 只有当前后两个节点值都不同时才指向下一个节点
                // 否则如果再下一个节点的值仍然跟前两个值相等，就会出错
                temp = temp->next; 
        }

        return head;
    }
};
61. Rotate List

Given a linked list, rotate the list to the right by k places, where k is non-negative.

Example 1:

Input: 1->2->3->4->5->NULL, k = 2
Output: 4->5->1->2->3->NULL
Explanation:
rotate 1 steps to the right: 5->1->2->3->4->NULL
rotate 2 steps to the right: 4->5->1->2->3->NULL
Example 2:

Input: 0->1->2->NULL, k = 4
Output: 2->0->1->NULL
Explanation:
rotate 1 steps to the right: 2->0->1->NULL
rotate 2 steps to the right: 1->2->0->NULL
rotate 3 steps to the right: 0->1->2->NULL
rotate 4 steps to the right: 2->0->1->NULL

思路：旋转k次，相当于以倒数第k个节点当头节点，链表尾指向原先的头节点，因此可以用19. Remove Nth Node From End of List的双指针方法定位两个目标节点，由于k可能很大，因此需要先取模

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head) return NULL;	// 判空
        int n = 0;
        for(auto p = head; p; p = p->next) n++;

        k %= n;

        auto left = head, right = head;
        while(k--) right = right->next;
        while(right->next)
        {
            left = left->next;
            right = right->next;
        }   

        right->next = head;	// 链表末尾指向原先的头
        head = left->next;	// 新的头节点
        left->next = NULL;	// 新的链表尾

        return head;
    }
};
24. Swap Nodes in Pairs

Given a linked list, swap every two adjacent nodes and return its head.

You may not modify the values in the list’s nodes, only nodes itself may be changed.

Example:

Given 1->2->3->4, you should return the list as 2->1->4->3.

思路：头节点有变化，因此用一个虚拟节点指向头节点，用临时节点p遍历链表，用a和b分别表示p后面两个要交换的节点，交换结束后p指向a，继续交换后两个节点，如果长度为奇数，那最后一个节点不做改动

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        
        for(auto p = dummy; p->next && p->next->next;)
        {
            auto a = p->next, b = p->next->next;
            p->next = b;
            a->next = b->next;
            b->next = a;
            p = a;
        }
        
        return dummy->next;	// 第一次循环时p和dummy指向同一个地址
        					// 因此p->next的改变相当于改变dummy->next
        					// 这跟int a = b，a改变后b不变不同
    }
};
206. Reverse Linked List

Reverse a singly linked list.

Example:

Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL
Follow up:

A linked list can be reversed either iteratively or recursively. Could you implement both?

思路：类似于以c为媒介，交互a和b的值

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head) return NULL; // 判空
        
        auto a = head, b = head->next;
        head->next = NULL;
       while(b)	// b为空时,由于a在b的左侧，则此时a为头节点
        {
            auto c = b->next;
            b->next = a;
            a = b;
            b = c;
        }

        
        return a;
    }
};
92. Reverse Linked List II

Reverse a linked list from position m to n. Do it in one-pass.

Note: 1 ≤ m ≤ n ≤ length of list.

Example:

Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

思路：

由于头节点可能出现变化，使用一个虚拟节点

1 -> 2 -> 3 -> 4 -> 5 -> NULL m = 2 n = 4

a b d c

a节点和c节点分别在要反转的链表两侧，我们先用206. Reverse Linked List的方法把d到d之间的链表反转，接着a节点的next指向d（1->4），b节点的next指向c（2->5）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head; // 特殊情况
        
        auto dummy = new ListNode(-1);
        dummy->next = head;
        
        auto a = dummy, d = dummy;
        for(int i = 0; i < m - 1; i++) a = a->next;
        for(int i = 0; i < n; i++) d = d->next;
        
        auto b = a->next, c = d->next;
        
        for(auto p = b, q = b->next; q != c;)
        {
            auto o = q->next;
            q->next = p;
            p = q;
            q = o;
        }
        
        b->next = c;
        a->next = d;
        
        return dummy->next;
    }
};
160. Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

image-20200401221644781

begin to intersect at node c1.

image-20200401221719034

image-20200401221739110

思路：设A的头节点到相交节点的长度为a（暂且假设相交），B的头节点到相交节点的长度为b，共同链表的长度为c

节点p从A头节点开始出发，走到链表尾之后转到B的头节点继续走，走到相交节点，则一共走了a+c+b个节点

节点q从B头节点开始出发，走到链表尾之后转到A的头节点继续走，走到相交节点，则一共走了a+b+c个节点

所以我们发现，只要p、q分别从两个链表头往下遍历，每次各自指向下一个节点，并在走到链表尾之后转向另一条链表继续遍历，如果两条链表有交点，则p、q必定在交点处相遇，即节点p == 节点q，为同一个节点，因为此时它们都走了a+b+c个节点，当然如果恰好a==b，则它们在第一次经过相交点时就会相遇

而如果两条链表没有交点，则在走完a+b个节点后，p和q分别为NULL，当然此时也满足p == q，但返回的结果时NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto p = headA, q = headB;
        while(p != q)
        {
            if(p) p = p->next;
            else p = headB;
            if(q) q = q->next;
            else q = headA;
        }
        
        return p;
    }
};
142. Linked List Cycle II

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.

Note: Do not modify the linked list.

image-20200402123328495

思路：快慢指针

假设有环，环的入口为b点，head（即a点）到b的距离为x

bj

在head即a点设置快慢指针各一个，快指针一次移动两个节点，慢指针一次一个，我们假设慢指针移动到b时，快指针移动到c‘处（可能快指针已经绕环很多圈），设此时快指针到b的距离为y，然后继续移动，因为快指针的移动速度是慢指针移动速度的两倍，慢指针继续移动y个节点，快指针移动2y个节点，所以它们相遇的点c跟c’是对称的（都距离b点y个节点）

第一次相遇以后，将慢指针放回到head，即a点，然后两个指针都以每次一个节点的速度向前移动，它们再次相遇时的点就是环的入口

解释：因为慢指针第一次到达b点时，快指针已经移动了2x个节点，即快指针从b点开始移动x个节点以后会停留在c‘处，慢指针第二次到达b点时，由于快指针也是每次一个节点，因此也移动了x个节点，但此时的起点是c，由于c和c’是对称的，相当于我们把原先的起点b向前移动y个节点到c，那么原先的终点c’也随之向前移动y个节点，恰好是环的入口b

/**
 * 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) {
        auto fast = head, slow = head;
        while(fast)	// 如果退出循环，说明有节点的next指向NULL，即没有环
        {
            slow = slow->next;
            fast = fast->next;
            if(fast) fast = fast->next;
            else break;
            
            if(fast == slow)	// 第一次相遇以后
            {
                slow = head;
                while(slow != fast)
                {
                    fast = fast->next;
                    slow = slow->next;
                }
                
                return fast;
            }
        }
        
        return NULL;
    }
};
148. Sort List

Sort a linked list in O(n log n) time using constant space complexity.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4
Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

思路：

要求时间复杂度O(n log n)，常数空间，如果使用快速排序等，递归时用到系统栈，则空间为O(log n)

使用归并排序的方法，不用递归，循环log n次，每次处理n个数据，所以为O(n log n)

比如第一次循环，两个数一组，按升序排号，第二次循环四个数一组，前两个数和后两个数都已经是升序，将它们归并以后，得到的四个数就是升序，再八个数一组……

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        
        int n = 0;
        for(auto p = head; p; p = p->next) n++;
        
        // 归并排序的思想
        for(int i = 1; i < n; i *= 2)   // 每次对2*i个数进行排序
        {
            auto cur = dummy;
            for(int j = 0; j + i < n; j += i * 2)
            {
                auto left = cur->next, right = cur->next;
                // left和right分别指向一组排好序的数字
                for(int k = 0; k < i; k++) right = right->next;
                int l = 0, r = 0;
                // 进行归并
                while(l < i && r < i && right)
                    if(left->val <= right->val)
                    {
                        cur->next = left;
                        cur = left;
                        left = left->next;
                        l++;
                    }
                    else
                    {
                        cur->next = right;
                        cur = right;
                        right = right->next;
                        r++;
                    }
                // 结束后可能有一组数字还有剩余
                while(l < i)
                {
                    cur->next = left;
                    cur = left;
                    left = left->next;
                    l++;
                }
                // 有可能右边一组的长度不足
                while(r < i && right)
                {
                    cur->next = right;
                    cur = right;
                    right = right->next;
                    r++;
                }
                // 归并结束后，cur指向下一组要归并的数据的前一个节点
                // 这样后一组2*i个数据排序时left和right都指向这2*i个节点的第一个节点
                cur->next = right;
            }
                
        }
        return dummy->next;
    }
};
【LeetCode攻略】使用LeetCode刷题时你必须注意的几个点
捡起一束光的博客
02-17 2万+
LeetCode刷题攻略：详细介绍LeetCode刷题时的各种常用技巧和注意点
leetcode-链表笔记
02-06
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着至关重要的角色，特别是在算法和数据结构的学习中，LeetCode 是一个很好的实践平台。本笔记将深入探讨 LeetCode 中涉及的链表相关问题，旨在帮助你...
分门别类刷leetcode——链表（C++实现）
一直走，不要回头
10-27 423
链表结构 struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; 构建链表——尾插法 ListNode * CreateNode(int n) { ListNode *head = NULL, *pnew = NULL, *ptail = ...
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
小乔美哒哒
03-12 3704
有的时候我们在写LeetCode等编程题时，会发现有人用了下面的初始化方法： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 这是允许我们用 TreeNode node(int x)的法式把val赋值为x，left，right为NULL。 ...
struct ListNode { * int val； * ListNode *next； * ListNode(int x) : val(x), next(NULL)
qq_30334533的博客
07-10 8597
构造函数的初始化
Leetcode刷题——树篇2
w137093940的博客
05-01 691
文章目录2、树（简单篇2）2.1、965. 单值二叉树2.1、 669. 修剪二叉搜索树2.3 102. 二叉树的层序遍历2.4 107. 二叉树的层次遍历 II2.5、 637. 二叉树的层平均值 2、树（简单篇2） 2.1、965. 单值二叉树 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回 true；否则返回 false。 示例 1： ...
leetcode-链表合并
qq_63959489的博客
04-21 997
递归思路解决链表合并
LeetCode--链表
weixin_43323252的博客
11-25 421
记录一下刷题
Leetcode-链表的中间结点
随缘更新
12-07 400
C实现
LeetCode-链表-反转链表+链表的中间结点
最新发布
Wneosy的博客
05-21 1034
介绍了LeetCode中两个常见的链表问题：反转链表和链表的中间结点。
【leetcode-链表】扁平化多级双向链表
01-20
本题是关于扁平化多级双向链表的问题，来自LeetCode。在多级双向链表中，每个节点除了拥有指向下一个节点（next）和前一个节点（prev）的指针，还有一个子链表指针（child），可以指向一个单独的双向链表。这种结构...
【leetcode-链表】环形链表
12-21
在给定的LeetCode问题中，我们需要判断链表中是否存在环，并通过整数`pos`来表示环的位置。如果`pos`为-1，则链表没有环。提供的解决方案使用了“快慢指针”（Floyd's Cycle-Finding Algorithm，也称为龟兔赛跑算法...
js代码-leetCode--链表 两数相加
07-16
在JavaScript编程领域，LeetCode是一个非常知名的在线平台，它提供了大量的编程题目，帮助开发者提升算法能力和解决问题的能力。在这个特定的题目“链表两数相加”中，我们需要编写一个JavaScript函数来解决链表数据...
53. 最大子序和
冲冲冲
01-28 1150
链接：https://leetcode-cn.com/problems/maximum-subarray/ 给定一个整数数组 nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例: 输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释:连续子数组[4,-1,2,1] 的和最大，为6。 进阶: 如果你已经实现复杂度为 O(n)...
1078. Bigram 分词
冲冲冲
01-16 360
链接：https://leetcode-cn.com/problems/occurrences-after-bigram/ 给出第一个词first 和第二个词second，考虑在某些文本text中可能以 "first second third" 形式出现的情况，其中second紧随first出现，third紧随second出现。 对于每种这样的情况，将第三个词 "thir...
1047. 删除字符串中的所有相邻重复项
冲冲冲
01-27 356
链接：https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/ 给出由小写字母组成的字符串S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。 在 S 上反复执行重复项删除操作，直到无法继续删除。 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。 示例： 输入："abbac...
1295. 统计位数为偶数的数字
冲冲冲
02-07 283
链接：https://leetcode-cn.com/problems/find-numbers-with-even-number-of-digits/ 给你一个整数数组nums，请你返回其中位数为偶数的数字的个数。 示例 1： 输入：nums = [12,345,2,6,7896] 输出：2 解释： 12 是 2 位数字（位数为偶数） 345 是 3 位数字（位数为奇数）...
1299. 将每个元素替换为右侧最大元素
冲冲冲
02-07 280
https://leetcode-cn.com/problems/replace-elements-with-greatest-element-on-right-side/ 给你一个数组arr，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用-1 替换。 完成所有替换操作后，请你返回这个数组。 示例： 输入：arr = [17,18,5,4,6,1] 输出：[18,...
1200. 最小绝对差
冲冲冲
02-08 241
链接：https://leetcode-cn.com/problems/minimum-absolute-difference/ 给你个整数数组arr，其中每个元素都 不相同。 请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。 示例 1： 输入：arr = [4,2,1,3] 输出：[[1,2],[2,3],[3,4]] 示例 2： 输入：arr = [1,3,6,10...
Python解法汇总：Leetcode-Python练习题解析
类似于LeetCode，Lintcode是一个在线编程问题和练习的网站，它提供了一系列的编程题目，覆盖了从基础算法到高级算法以及一些常见的编程面试题。通过解决Lintcode上的问题，程序员可以提高解决实际编程问题的能力。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值