链表理论基础
-
类型
单链表：
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成：数据域(记录当前节点的数据)和指针域(记录下一个节点的指针位置，最后一个节点指针域是null，称为空指针)。
双链表：
双指针：每一个节点有两个指针域，一个指向前一个节点，一个指向后一个指针；可以向前查询也可以向后查询。
循环链表：
链表首尾相连，可以解决约瑟夫环问题
-
存储方式
数组地址是连续分布的，但是链表不是。链表通过指针连接在内存中的各个节点(节点散乱分布在内存中的某地址上)
-
定义
struct ListNode{ int val; //数据域 ListNode *next; //指向下一个节点的指针 ListNode(int x):val(x) next(NULL){}//节点的构造函数 };注意：C++默认生成节点的构造函数，所以代码中可以不构造，但自己不构造的话，初始化的时候不能直接给变量赋值。
如果用上面的自定义构造函数初始化节点：
ListNode* head = new ListNode(5);使用默认构造函数初始化节点：
ListNode* head = new ListNode(); head->val = 5; -
操作
删除节点：
如有A,B,C三个节点，删除B，只需要将A的next指针指向C就可以，然后手动释放B节点内存；
添加节点：
// 正确顺序： newNode->next = current->next; current->next = newNode;5.例题：
（1）203.移除链表元素
给定一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == 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
输出：[]
提示：
- 列表中的节点数目在范围
[0, 104]内 1 <= Node.val <= 500 <= val <= 50
解释：
考察删除节点，先验证头节点是否需要删除，再进行删除节点操作，比较简单。
代码：
/**
* 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* removeElements(ListNode* head, int val) {
//如果是头节点的话
while(head != NULL && head->val==val)
{
ListNode *tmp=head;
head=head->next;
delete tmp;
}
//非头节点
ListNode *p=head;
while(p!=NULL && p->next!=NULL)
{
if(p->next->val==val)
{
ListNode* tmp = p->next;
p->next=tmp->next;
delete tmp;
}else p=p->next;
}
return head;
}
};
（2）707.设计链表
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
MyLinkedList()初始化MyLinkedList对象。int get(int index)获取链表中下标为index的节点的值。如果下标无效，则返回-1。void addAtHead(int val)将一个值为val的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。void addAtTail(int val)将一个值为val的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)将一个值为val的节点插入到链表中下标为index的节点之前。如果index等于链表的长度，那么该节点会被追加到链表的末尾。如果index比长度更大，该节点将 不会插入 到链表中。void deleteAtIndex(int index)如果下标有效，则删除链表中下标为index的节点。
示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]
解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3
提示：
0 <= index, val <= 1000- 请不要使用内置的 LinkedList 库。
- 调用
get、addAtHead、addAtTail、addAtIndex和deleteAtIndex的次数不超过2000。
代码：
class MyLinkedList {
private:
// 定义链表节点结构体
struct LinkedNode {
int val;
LinkedNode* next;
};
int _size;
LinkedNode* head;
public:
//初始化链表
MyLinkedList() {
head = new LinkedNode();// 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
head->val=0;
_size = 0;
}
//获取链表中下标为index的节点的值
int get(int index) {
if (index > (_size - 1) || index < 0) {
return -1;
}
LinkedNode* cur = head->next;
while(index--)
{
cur=cur->next;
}
return cur->val;
}
void addAtHead(int val) {
if(val < 0 || val > 1000) return;
LinkedNode* p=new LinkedNode();
p->val = val;
p->next=head->next;//将p的指针域指向未修改的第一个实际节点
head->next=p;//令p成为链表的实际节点
_size++;
}
void addAtTail(int val) {
if(val < 0 || val > 1000) return;
LinkedNode* tail=new LinkedNode();
tail->val=val;
LinkedNode* p=head;
while(p->next)
{
p=p->next;
}
p->next = tail;
_size++;
}
void addAtIndex(int index, int val) {
if(val<0 || val>1000 ||index > _size) return;
if(index <= 0) addAtHead(val);
else if(index==_size)
{
addAtTail(val);
}
else
{
LinkedNode* newNode=new LinkedNode();
newNode->val = val;
LinkedNode* p=head;
while(index--)
{
p=p->next;
}
newNode->next=p->next;
p->next=newNode;
_size++;
}
}
void deleteAtIndex(int index) {
if(index < 0 || index > _size-1) return;
LinkedNode* tmp=nullptr;
LinkedNode* p=head;
while(index--) p=p->next;
tmp = p->next;
p->next = tmp->next;
delete tmp;
//delete命令指示释放了tmp指针原本所指的那部分内存，
//被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
//如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
//如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
tmp=nullptr;
_size--;
}
};
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/
（3）206.反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,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* cur=head;
ListNode* pre=nullptr;
while(cur)
{
ListNode* tmp=cur->next;
cur->next=pre;
pre=cur;
cur=tmp;
}
return pre;
}
};
（4）24. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
-
链表中节点的数目在范围
[0, 100]内 -
0 <= Node.val <= 100思路：创造虚拟头节点，如交换 1 2 ，先让虚拟头节点指向2，同时存下1 和 3 ，再让2指向1，1指向3 ，这样就实现了交换
代码：
/** * 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* swapPairs(ListNode* head) { ListNode* dummyHead=new ListNode(); dummyHead->next=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; tmp->next=tmp1; cur=cur->next->next; } ListNode* result=dummyHead->next; delete dummyHead; return result; } };
（5）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 <= 30 -
0 <= Node.val <= 100 -
1 <= n <= sz代码：
class Solution { public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode* dummyHead=new ListNode(); dummyHead->next=head; ListNode* fast=dummyHead; ListNode* slow=dummyHead; while(fast && n--) fast=fast->next; //快指针通过while循环指向了被删除节点的前驱的前驱 fast=fast->next;//让他再走一步 while(fast) { fast=fast->next; slow=slow->next; //这样使得slow最终指向了被删除节点的前驱节点 } //后面的就是删除节点的操作 ListNode* tmp=slow->next; slow->next=tmp->next; delete tmp; return dummyHead->next; } };
（6）02.07 链表相交
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,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
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 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) {
ListNode* p1=headA;
ListNode* p2=headB;
int num1=0,num2=0;
while(p1)
{
p1=p1->next;
num1++;
}
while(p2)
{
p2=p2->next;
num2++;
}
p1=headA;
p2=headB;
if(num1<num2)
{
swap(num1,num2);
swap(p1,p2);
}
int sub=num1-num2;
while(sub--)
{
p1=p1->next;
}
while(p1)
{
if(p1==p2) return p1;
p1=p1->next;
p2=p2->next;
}
return NULL;
}
};
（7）142.环形链表 II
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
解释：
如何判断有环？我们可以采用双指针法，让快指针一次走两个，让慢指针一次走一个，这样不断的走，肯定会找到一个相遇点，从而判断有环，假设快指针走啊走走到了NULL，说明没环；
如何找到环的第一个节点？假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：
那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：
(x + y) * 2 = x + y + n (y + z)
两边消掉一个（x+y）: x + y = n (y + z)
因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
所以要求x ，将x单独放在左面：x = n (y + z) - y ,
再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
这个公式说明什么呢？
先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。
当 n为1的时候，公式就化解为 x = z，
这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。
让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。如果n>1，只不过是转圈转多了，但是依旧能找到相遇节点，依然可以沿用此法。
代码：
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast=head;
ListNode* slow=head;
while(fast && fast->next)
{
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;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
