单链表力扣题（leetcode）
单链表力扣题（leetcode）
2. 两数相加
难度：中等
题目：
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1:
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2:
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3:
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
- 每个链表中的节点数在范围
[1, 100]内 0 <= Node.val <= 9- 题目数据保证列表表示的数字不含前导零
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
{
// 哨兵节点，方便处理头节点
ListNode* nodePtr = new ListNode(0);
ListNode* cur = nodePtr;
int t = 0; // 进位
// 只要还有节点没遍历完，或者还有进位，就继续循环
while (l1 != nullptr || l2 != nullptr || t != 0)
{
int sum = t;
// 加上l1当前位
if (l1 != nullptr)
{
sum += l1->val;
l1 = l1->next;
}
// 加上l2当前位
if (l2 != nullptr)
{
sum += l2->val;
l2 = l2->next;
}
// 计算当前位的值和新的进位
t = sum / 10;
cur->next = new ListNode(sum % 10);
cur = cur->next;
}
// 返回哨兵节点的下一个节点，即结果链表的头节点
return nodePtr->next;
}
};
相似题目
子集 II中等
字母大小写全排列中等
19. 删除链表的倒数第 N 个结点
难度：简单
题目：
给你一个链表，删除链表的倒数第 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]
提示：
- 链表中结点的数目为
sz 1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* removeNthFromEnd(ListNode* head, int n)
{
ListNode* node = new ListNode(0, head);
ListNode* fast = node;
ListNode* slow = node;
for(int i = 0; i < n; i++)
{
fast = fast->next;
}
while(fast->next != nullptr)
{
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
ListNode* result = node->next;
delete node;
return result;
}
};
相似题目
交换链表中的节点中等
21. 合并两个有序链表
难度：简单
题目：
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2:
输入：l1 = [], l2 = []
输出：[]
示例 3:
输入：l1 = [], l2 = [0]
输出：[0]
提示：
- 两个链表的节点数目范围是
[0, 50] -100 <= Node.val <= 100l1和l2均按 非递减顺序 排列
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
{
// 1. 创建哨兵节点，指向结果链表的头部
ListNode* node = new ListNode(-1);
// 2. 创建游标指针，用于构建新链表（dummy不动，保留头部信息）
ListNode* cur = node;
// 3. 同时遍历两个链表，直到其中一个遍历完毕
while (list1 != nullptr && list2 != nullptr)
{
// 3.1 谁小就把谁连上去
if (list1->val <= list2->val)
{
cur->next = list1; // 链接list1当前节点
list1 = list1->next; // list1指针后移
}
else
{
cur->next = list2; // 链接list2当前节点
list2 = list2->next; // list2指针后移
}
cur = cur->next; // 结果指针后移，准备下一次链接
}
// 4. 处理剩余节点（其中一个链表已空）
// 如果list1还有剩余，直接链接上去，否则链接list2的剩余
cur->next = list1 != nullptr ? list1 : list2;
// 5. 返回结果链表的头节点（哨兵节点的下一个）
ListNode* result = node->next;
delete node; // 释放哨兵节点内存（LeetCode不强制，但规范）
return result;
}
};
相似题目
合并两个有序数组简单
排序链表中等
160. 相交链表
难度：简单
题目：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
自定义评测：
评测系统 的输入如下（你设计的程序 不适用 此输入）：
intersectVal- 相交的起始节点的值。如果不存在相交节点，这一值为0listA- 第一个链表listB- 第二个链表skipA- 在listA中（从头节点开始）跳到交叉节点的节点数skipB- 在listB中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。
示例 1:
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。
示例 2:
输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3:
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：No intersection
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
listA中节点数目为mlistB中节点数目为n- \(1 <= m, n <= 3 * 10^4\)
- \(1 <= Node.val <= 10^5\)
- \(0 <= skipA <= m\)
- \(0 <= skipB <= n\)
- \(如果 listA 和 listB 没有交点，intersectVal 为 0\)
- \(如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]\)
进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？
代码：
/**
* 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)
{
if(headA == nullptr || headB == nullptr) return nullptr;
ListNode* pA = headA;
ListNode* pB = headB;
while(pA != pB)
{
pA = (pA == nullptr) ? headB : pA->next;
pB = (pB == nullptr) ? headA : pB->next;
}
return pA;
}
};
相似题目
206. 反转链表
难度：简单
题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1:
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2:
输入：head = [1,2]
输出：[2,1]解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3:
输入：head = []
输出：[]
提示：
- 链表中节点的数目范围是
[0, 5000] -5000 <= Node.val <= 5000
进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
ListNode* reverseList(ListNode* head)
{
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr != nullptr)
{
ListNode* nextTemp = curr->next; // 保存下一个节点
curr->next = prev; // 当前节点指向前一个
prev = curr; // prev后移
curr = nextTemp; // curr后移
}
return prev; // prev最终指向新链表头
}
};
相似题目
反转链表 II中等
上下翻转二叉树中等
回文链表简单
链表最大孪生和中等
从链表中移除节点中等
234. 回文链表
难度：简单
题目：
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1:
输入：head = [1,2,2,1]
输出：true
示例 2:
输入：head = [1,2]
输出：false
提示：
- \(链表中节点数目在范围[1, 10^5]内\)
- \(0 <= Node.val <= 9\)
进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution
{
public:
bool isPalindrome(ListNode* head)
{
if (head == nullptr || head->next == nullptr)
return true; // 空链表或单个节点是回文
// 1. 快慢指针找中点（slow最终指向前半段的尾节点）
ListNode* slow = head;
ListNode* fast = head;
while (fast->next != nullptr && fast->next->next != nullptr)
{
slow = slow->next;
fast = fast->next->next;
}
// 2. 反转后半部分链表（slow->next 开始）
ListNode* secondHalf = reverseList(slow->next);
ListNode* firstHalf = head;
// 3. 逐位比较前半部分和反转后的后半部分
bool result = true;
ListNode* p = secondHalf;
while (result && p != nullptr)
{
if (firstHalf->val != p->val)
{
result = false;
}
firstHalf = firstHalf->next;
p = p->next;
}
// 4. 恢复链表（可选，但在实际工程中必须做）
slow->next = reverseList(secondHalf);
return result;
}
private:
// 辅助函数：反转链表（标准模板）
ListNode* reverseList(ListNode* head)
{
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr != nullptr)
{
ListNode* nextTemp = curr->next; // 保存下一个节点
curr->next = prev; // 当前节点指向前一个
prev = curr; // prev后移
curr = nextTemp; // curr后移
}
return prev; // prev最终指向新链表头
}
};
相似题目
反转链表 II中等
上下翻转二叉树中等
回文链表简单
链表最大孪生和中等
从链表中移除节点中等
浙公网安备 33010602011771号