单向链表
单链表的创建
动态的建立单链表的常用方法有两种：头插法、尾插法。
头插法建表
从一个空表开始，重复读入数据，生成新的结点，将读入的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到读入结束标志为止。即每次插入的结点都作为链表的第一个结点。
LNode * create_LinkList(void){
int data;
LNode *head,*p;
//创建新表 头结点指向首地址
head = (LNode*)malloc(sizeof(LNode));
head->next = NULL;
while(1){
//输入要插入的int类型的数据 直到输入0为止
scanf("%d",&data);
if(data == 0)break;
p = (LNode *)malloc(Sizeof(LNode));
//数据域赋值
p->data = data;
//输入的p总是第一个 然后head再指向p就连接起来了
p->next = head->next;
head->next = p;
}
return(head);
}
尾插法建表
头插法建立链表虽然算法简单，但是生成的链表中结点的次序和输入的顺序相反。如果希望两者保持一致，可以采用尾插法建表。该方法是将新结点插入到当前链表的表尾，使其成为当前链表的尾结点。
LNode * create_LinkList(void){
int data;
LNode *head,*p,*q;
head=p=(LNode*)malloc(sizeof(LNode));
p->next = NULL;
while(1){
scanf("%d",&data);
if(data == 0) break;
q = (LNode*)malloc(sizeof(LNode));
//数据域赋值
q->data = data;
//p是最后一个结点 q的next指向原来p的next
q->next = p->next;
//p的next和q连接上
p->next = q;
//q把p替换掉
p=q;
}
return(head);
}
不论是哪一种建表法，插入n个结点的时间复杂度都是O(n)。
单链表的查找
按序号查找
取出链表中的第i个元素。对于单链表，不能像顺序表那样直接按序号i访问结点，而只能从链表的头结点出发，沿着链域next逐个结点往下搜索，直到搜索到第i个结点为止。因此，链表不是随机存储结构。
ElemType Get_Elem(LNode *L，int i){
int j;
LNode *p;
p=L->next;
j=1;
while(p!=NULL&&j<i){
p=p->next;
j++;
}
if(j!=i) return fales;
else return p>data;
}
按值查找
ElemType Get_Elem(LNode *L，int key){
int j;
LNode *p;
p=L->next;
while(p!=NULL&&p->data != key){
p=p->next;
}
if(p->data == key) return p;
else return NULL;
}
查找就相对来说非常简单，就是一个简单的遍历然后比较位置或者值的过程。
单链表的删除
按序号删除
删除序号为i的结点。
void Delete_LinkList(LNode *L,int i){
int j=1;
LNode *p,*q;
p=L;
q=L->next;
while(p->next!=Null&&j<i){
//p记录当前的
p=q;
//挪到下一个结点
q=q->next;
j++;
}
if(j!=i) printf("error!i太大或者i为0");
else{
//q的前一个结点 直接指向q的后一个结点 删除q
p->next = q->next;
free(q);
}
}
按值删除
删除单链表中值为key的第一个结点。
void Delete_LinkList(LNode *L,int key){
LNode *p = L,q=L->next;
//遍历
while(p->next!=Null&&q->data!=key){
p=q;
q=q->next;
}
if(q->data == key){
p->next = q->next;
free(q);
}else{
printf("error!要删除的结点不存在");
}
}
单向循环链表
循环链表(Circular Linked List)：是一种头尾相接的链表。其特点是最后一个结点的指针域指向链表的头结点，整个链表的指针域链接成一个环。从循环链表的任意一个位置出发都可以找到链表中的其他结点。
对于单循环链表，除了链表的合并外，其他的操作和单线性链表上一致，仅仅是判断条件进行简单的修改：
- 判断是否是空链表：head->next == head;
- 判断尾结点：p->next == head;
双向链表
双向链表(Double Linked List)：指的是构成链表的每个节点中设立两个指针域：一个指向其直接前趋的指针域prior，一个指向其直接后继的指针域next。这样形成的链表中有两个方向不同的链，故称为双向链表。双向链表是为了克服单向链表的单向性缺陷而引入的。
双向链表的结点及其类型定义
- 定义
typedef struct Dulnode{
ElemType data;
struct Dulnode *prior,*next;
}DulNode;
-
双向链表的结点形式
image.png 空双向链表
- 带头结点的非空双向链表
[图片上传失败...(image-d4161c-1650443081341)]
双向链表的插入
将值为e的结点插入到双向链表中。图示：
如果插入时仅仅提供了直接前驱结点p，钩链的时候必须注意“先右后左”。部分语句如下：
S->data = e;
//先处理S的后继
S->next = p->next;
p>next->prior=S;
//再处理前驱
p->next=S;
S->prior=p;
双向链表的删除
设要删除的结点为p，删除时可以不引入新的辅助指针变量，可以直接先断链，再释放结点。部分语句：
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
双向循环链表
在双向链表的基础上，把它的头结点和尾结点链接起来就构成了循环链表，并称之为双向循环链表。结构如下：
它的插入和删除操作和双向链表相似。
以上简单的介绍了链表的结构和一些基础的概念，下面来看一下链表相关的习题。
链表经典LeeCode习题
合并两个有序链表
题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
伪代码：
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
//list1 为空返回list2
if(list1 == nullptr){
return list2;
}
//list2为空返回list1
if(list2 == nullptr){
return list1;
}
//创建一个新的链表 并用一个变量cur指向当前位置
ListNode* head = new ListNode(-1);
ListNode * cur = head;
//遍历到有一个表为空时停止
while( list1 !=nullptr && list2 != nullptr){
//list1的位置的val 和list2的val比较 小的给cur指向 并且list1后移
if(list1->val < list2->val){
cur->next = list1;
list1 = list1->next;
}else{
cur->next = list2;
list2 = list2->next;
}
//当前指针向后
cur = cur->next;
}
//list1遍历完 但是list2没完 直接把剩下的lis2接到cur的后边就行了 因为有序
if(list1 == nullptr){
cur->next = list2;
}
//同样list2遍历完 但是list1没完 把剩下的lis1接到cur的后边
if(list2 == nullptr){
cur->next = list1;
}
//返回head指向的链表
return head->next;
}
思路解析:
- 先判断l1或者l2是不是有空表，进行处理
- 新创建的一个链表设置一个哨兵记录当前结点的位置
- 因为l1和l2都是有序的，所以进行比较l1和l2的结点的大小
- 把较小的结点插入到当前位置上，并且较小的那个链表进行后移，遍历下一个进行再比较
- 插入结点后哨兵位置后移
- 在循环终止的时候，l1和l2至多有一个是非空的。两个链表都是有序的，所以不管哪个链表是非空的，它包含的所有元素都比前面已经合并链表中的所有元素都要大。所以将非空链表接在合并链表的后面就可以了。
- 最后返回链表。
当然以上代码可以更改的更加简洁一些，上网搜索也有有递归的方式实现的，代码非常简洁：
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if (l1 == nullptr) {
return l2;
} else if (l2 == nullptr) {
return l1;
} else if (l1->val < l2->val) {
l1->next = mergeTwoLists(l1->next, l2);
return l1;
} else {
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
}
😂😂递归真心，一看就会，一写就废😂😂
反转链表
题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例：
伪代码：
ListNode* reverseList(ListNode* head) {
if(head == nullptr) return head;
if(head->next == nullptr) return head;
ListNode *cur = new ListNode();
ListNode *temp = head;
while(head!= nullptr){
temp = temp->next;
head->next = cur->next;
cur->next = head;
head = temp;
}
return cur->next;
}
思路解析:
我自己分析的时候是用了创建链表的特性，因为头插法创建出来的链表和实际的输入顺序正好相反，所以通过头插法来实现链表反转。
- 创建新的空表
- 创建一个temp来记录当前的位置
- 进行head遍历
- temp先移动到下一个位置，最后要把head指向给temp，找到遍历的表
- 先断右边的链，head的next = cur->next
- 链接左边的链，cur->next = head，此时cur完成了一次插入。
- 最后head移动到下一个位置
这个也可以用递归的方式来实现：
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;
}
这个递归的解法我感觉挺不好理解的，我通过力扣里面的图解演示搞明白了，看递归解法那个幻灯片演示非常清楚。链接在这里
关于链表还有非常多的操作，虽然我们平时在iOS的业务开发中用到链表的情况非常少，但是在底层，链表有着大量的应用，感兴趣可以进一步进行链表相关的算法学习。
