单向链表

单链表的创建

动态的建立单链表的常用方法有两种：头插法、尾插法。

头插法建表

从一个空表开始，重复读入数据，生成新的结点，将读入的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到读入结束标志为止。即每次插入的结点都作为链表的第一个结点。

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)：是一种头尾相接的链表。其特点是最后一个结点的指针域指向链表的头结点，整个链表的指针域链接成一个环。从循环链表的任意一个位置出发都可以找到链表中的其他结点。

image.png

对于单循环链表，除了链表的合并外，其他的操作和单线性链表上一致，仅仅是判断条件进行简单的修改：

1. 判断是否是空链表：head->next == head;
2. 判断尾结点：p->next == head;

双向链表

双向链表(Double Linked List)：指的是构成链表的每个节点中设立两个指针域：一个指向其直接前趋的指针域prior，一个指向其直接后继的指针域next。这样形成的链表中有两个方向不同的链，故称为双向链表。双向链表是为了克服单向链表的单向性缺陷而引入的。

双向链表的结点及其类型定义

• 定义

typedef struct Dulnode{
    ElemType data;
    struct Dulnode *prior,*next;
}DulNode;

• 双向链表的结点形式

  
  
  

  image.png

• 空双向链表

image.png

• 带头结点的非空双向链表

[图片上传失败...(image-d4161c-1650443081341)]

双向链表的插入

将值为e的结点插入到双向链表中。图示：

image.png

如果插入时仅仅提供了直接前驱结点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);

双向循环链表

在双向链表的基础上，把它的头结点和尾结点链接起来就构成了循环链表，并称之为双向循环链表。结构如下：

image.png

它的插入和删除操作和双向链表相似。

---

以上简单的介绍了链表的结构和一些基础的概念，下面来看一下链表相关的习题。

链表经典LeeCode习题

合并两个有序链表

题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：

image.png

伪代码：

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 ，请你反转链表，并返回反转后的链表。
示例：

image.png

伪代码：

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的业务开发中用到链表的情况非常少，但是在底层，链表有着大量的应用，感兴趣可以进一步进行链表相关的算法学习。