leetcode——链表总结

一、链表基础

#include <iostream>
using namespace std;
//链表结构
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) {}
};

int main(){
	//尾插法
	//1、创建链表 头结点 尾指针
	int count = 5;
	ListNode* head = new ListNode(0);
	ListNode* cur = head;
	while (count--) {
		//1.1、创建结点
		ListNode* node = new ListNode(count);
		//1.2、连接在链表后
		cur->next = node;
		//1.3、当前指针成了新的尾部
		cur = node;
	}
	//2、遍历链表——head保持在前面
	while (head) {
		cout << head->val << '\t';
		head = head->next;
	}

	//头插法
	//1、创建链表 头结点 头指针
	int count = 5;
	ListNode* head = new ListNode(0);
	ListNode* cur = head;
	while (count--) {
		//1.1、创建结点
		ListNode* node = new ListNode(count);
		//1.2、连接在头结点前
		node->next = cur-;
		//1.3、连接在头指针后
		cur = node;
	}
	
	//2、遍历链表——cur保持在前面
	while (cur) {
		cout << cur->val << '\t';
		cur = cur->next;
	}
	
}

二、高频题目

206. 反转链表——链表原地反转
1、初始化前驱pre为nullptr
2、创建遍历指针cur
3、while 记录后驱next防止丢失
4、修改当前结点next指针
5、当前结点cur设为前驱pre，后驱next设为当前结点cur
6、返回pre——即当前结点

876. 链表的中间结点——快慢指针
1、初始化快慢指针指向头结点
2、慢指针走一步，快指针走两步，注意出界判断fast->next!=nullptr
3、返回慢指针指向结点

160. 相交链表——交叉遍历
1、初始化两个指针分别指向两个链表
2、循环条件，当指针Ap不等于指针Bp{
3、指针Ap 遍历完A遍历B
4、指针Bp 遍历完B遍历A}
5、返回任意指针指向结点

141. 环形链表——快慢指针
1、初始化慢指针指向第一个元素，快指针指向第二个元素
2、循环条件，快慢指针不相等{
3、判断快指针是否走出链表 即指向nullptr 是的话返回false
4、慢指针走一步，快指针走两步}
5、跳出循环，证明快慢指针相遇，返回true

92. 反转链表 II——头插法
1、创建头结点，指向head，用于返回
2、寻找left前驱
3、获取left 即前驱的next
4、根据right-left进行头插遍历
4.1 next指向第一个需要头插元素 即left+1
4.2 原链表上删除next
4.3 next后驱指向left
4.4 next前驱为left-1

328. 奇偶链表——快慢指针，慢指针统计处理好的奇数，快指针指向未处理的奇数
1、申请头指针，用于返回
2、初始化快慢指针，slow初始化为head, fast不初始化
3、利用原先头指针进行遍历（head&&head->next）
3.1 获取偶数head->next
3.2 判断偶数是否还有奇数 没有就break
3.3 fast指向未处理的奇数
3.4 原链表删除该奇数
3.5 该奇数头插在slow后
3.6 show指字前移——处理奇数+1

三、问题思考

1. 什么时候申请头指针？
   利用头指针进行链表遍历时，防止链表头部丢失，申请头指针

1、
ListNode* Head;//假设已经有数据
while(Head) Head=Head->next;//利用头指针进行遍历链表
//现在的Head已经指向链表结尾，即为nullptr
return Head;//这样返回的是空结点  而不会再是原来的链表了

2、
ListNode* Head;//假设已经有数据
ListNode* Headp;
while(Head) Head=Head->next;//利用头指针进行遍历链表
return Headp;//这样返回的是原来的链表，因为一开始我们保存了链表的头结点

2. 什么时候申请头结点？
   链表的头结点在运行过程中可能发生改变，需要申请头结点，比如利用头插法时

ListNode* Head=new ListNode(0);//头结点
ListNode* cur=Head;//头指针
ListNode* node=new ListNode;//创建结点
node->next=cur;cur->next=node;//结点头插
return Head;//此时的Head已经不是链表的头结点了，这样返回无法打印整个链表

3. 链表基础操作有哪些？

1、创建指针，指向已存在的空间
ListNode* p=Z;

2、创建结点，为结点申请内存空间
ListNode* node=new ListNode(0);

3、节点头插
node->next=cur->next;cur->next=node;

4、节点尾插
cur->next=node;cur=node;

5、节点遍历
while(head) head=head->next;

4. 链表常考？

1、反转链表
2、查找链表第一个中点(需要借助头结点）
3、查找链表第二个中点
4、删除链表第n个结点
5、删除链表倒数第n个结点
6、合并链表
7、排序链表
8、交叉链表
9、链表环入口
10、判断是否有环

5、链表常用解法？

1、快慢指针
2、链表分割
3、链表原地反转
4、链表合并摘录
...