【数据结构】-- 链表专题

prettyxian

已于 2024-05-04 17:31:12 修改

阅读量666

点赞数 29

文章标签：数据结构

于 2024-04-30 23:09:04 首次发布

本文链接：https://blog.csdn.net/prettyxian/article/details/138325829

版权

链表的分类

前面我们实现了单链表，单链表只是链表的一种。可以根据以下几个标准来判断链表的类型：

1.单向或者双向

如图所示，单向链表中一个节点的指针域只储存了下一个节点的指针，能通过前一个节点访问后一个节点，无法通过后一个节点访问前一个节点，只能实现单向访问。

而双向链表则没有这样的限制，双向链表的指针域既有上一个节点的指针又有下一个节点的指针，所以双向节点能实现双向访问。

2.带头或者不带头

头节点通常被称为哨兵节点或者头哨兵节点。在链表中，哨兵节点是一种特殊的节点，通常位于链表的头部或尾部，而不存储实际的数据。哨兵节点的作用是简化链表的操作，例如插入、删除或遍历等。通过使用哨兵节点，可以避免在操作链表时需要特殊处理头部或尾部节点的情况，使得代码更加简洁和高效。

3.循环或者不循环

循环链表是一种特殊类型的链表，其中最后一个节点指向第一个节点，形成一个循环。这意味着在循环链表中，没有真正意义上的“尾节点”。所以遍历链表时需要特别注意循环终止条件，以避免进入无限循环。

循环链表和不循环链表主要区别在于：

结束节点指向： 在不循环链表中，最后一个节点的指针通常指向空（NULL），表示链表的结束。而在循环链表中，最后一个节点的指针指向第一个节点，形成循环。
遍历： 在不循环链表中，遍历链表时需要检查每个节点的指针是否指向 NULL 来确定结束。而在循环链表中，可以定义一个遍历的起点，然后遍历整个链表，直到返回到起点为止。
插入和删除操作： 对于不循环链表，插入和删除节点时需要特殊处理最后一个节点。而循环链表中，由于没有明确的“尾节点”，插入和删除节点相对简单，不需要特殊处理尾节点。

循环链表通常用于需要循环访问的场景，比如游戏中的循环遍历玩家列表。

总结

根据链表的这几种特性排列组合，一共有八种链表类型。一般我们只研究其中两种----单链表（单向不带头不循环）和双向链表（双向带头循环）。

链表刷题

1.移除链表元素

思路：创建一个新链表，遍历原链表，找值不为val的值，尾插到新链表中。

图解：

如果1不为val,尾插到新链表中,newTail更新，pcur指向下一个节点：

如果2不为val,尾插到新链表中，newTail更新，pcur指向下一个节点：

重复此操作。

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

 typedef struct ListNode ListNode;

struct ListNode* removeElements(struct ListNode* head, int val) {
    //创建一个空链表
    ListNode* newHead,*newTail;
    newHead = newTail = NULL;
    
    //遍历原链表
    ListNode* pcur = head;
    while(pcur)
    {
       //找值不为val的值，尾插到新链表
       if(pcur->val != val)
       {
        //链表为空
        if (newHead == NULL)
        {
            newHead = newTail = pcur;
        }else{
        //链表不为空
            newTail->next = pcur;//拿下来的不只是pcur这一个节点，拿的是地址，后面的一连串节点都拿下来了
            newTail = newTail->next;
        }
       } 
       pcur = pcur->next;      
    }
            if(newTail)
            newTail -> next = NULL;
    return newHead;
}

2.反转链表

图解：

创建n1,n2,n3三个指针。使n1指向NULL，n2指向head。n3指向head->next。

改变n2的指向，使n2的next指向n1：

使n1指向n2:

使n2指向n3:

使n3指向n3->next：

重复上述操作。

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

 typedef struct ListNode ListNode;

struct ListNode* reverseList(struct ListNode* head) {
    //判空
    if (head == NULL)
    {
        return head;
    }
    //创建三个指针

    ListNode* n1,*n2,*n3;
    n1 = NULL;
    n2 = head;
    n3 = head->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if(n3)
        n3 = n3->next;
    }
    return n1;
}

3.链表的中间节点（快慢指针的使用）

在这里我们要用到快慢指针算法，快慢指针算法，也称为龟兔赛跑算法，是一种用于解决链表相关问题的常用技巧。它通常用于判断链表是否有环，以及找到环的起始点。

算法的基本思想：使用两个指针，一个快指针和一个慢指针，它们以不同的速度遍历链表。在遍历过程中，快指针每次移动两步，慢指针每次移动一步。如果链表中有环，那么快指针最终会追上慢指针；如果没有环，快指针会先到达链表的末尾。通过这种方式，可以快速检测出链表是否有环，而且还可以找到环的起始点。一旦快指针追上慢指针，说明链表中存在环，然后可以使用一些技巧来找到环的起始点，例如将其中一个指针重新指向链表头部，然后两个指针以相同的速度向前移动，它们相遇的地方就是环的起始点。快慢指针算法的时间复杂度为 O(n)，其中 n 是链表的长度。

在这里，我们用来找链表的中间节点，可以设置两个指针，慢指针一次走一步，快指针一次走两步。当快指针遍历完链表时，慢指针所在的就是中间节点。当然也可以尝试用这个方法求1/4节点等等。

求中间节点有两种情况，节点个数为奇数还是偶数，依次来作为循环的条件。

图解：

1.奇数个节点

当节点为奇数个时，当fast走到尾节点时，slow刚好到中间节点，所以循环的条件为fast->next != NULL。

2.偶数个节点

当节点为偶数个时，fast走到NULL,slow刚好到后面的一个中间节点，所以循环的条件时fast != NULL;

结合两种情况，此题的循环条件为whlie(fast && fast->next)。这两个指针都不为NULL的时候进入循环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;

struct ListNode* middleNode(struct ListNode* head) {
    //创建快慢指针
    ListNode* slow;
    ListNode* fast;
    slow = fast = head;
    while(fast && fast->next)//不能改变fast与fast->next的顺序，fast可能为空
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

4.合并两个有序数组

原来的两个链表就是按升序排列的，我们可以创建一个新链表，用l1和l2两个指针遍历两个原链表，将较小值尾插到新链表中，依次循环，直到l1或者l2为空。再将非空的另一个链表中的数据尾插到新链表中。

图解：

当l1或l2为NULL时，把另一个不为NULL的尾插到新链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    //判空
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    ListNode* l1 = list1;
    ListNode* l2 = list2;
    //创建新链表
    ListNode* newHead,*newTail;
    newHead = newTail = (ListNode*)malloc(sizeof(ListNode));//哨兵位
    while(l1 && l2)
    {
        if (l1->val < l2->val)
        {
            newTail->next= l1;
            newTail = newTail->next;
            l1 = l1->next;
        }
        else
        {
           newTail->next= l2;
            newTail = newTail->next;
            l2 = l2->next; 
        }
        
    }
    //跳出循环:要么l1为空，要么l2为空
    if (l1 == NULL)
    {
        newTail->next = l2; 
    }
    else
    {
        newTail->next = l1;
    }
    //动态申请的内存要释放
    ListNode* ret = newHead->next;
    free(newHead);
    newHead = NULL;
    return ret;
}

5.分割链表

/*
struct ListNode {
    int val;
    struct ListNode *next;
};*/
#include <csignal>
#include <cstdlib>
typedef struct ListNode ListNode;

 ListNode* partition(ListNode* head, int x) {
       //创建两个带头链表
       ListNode *lessHead,*lessTail;
       ListNode *greaterHead,*greaterTail;
       lessHead = lessTail = (ListNode*)malloc(sizeof(ListNode));
       greaterHead = greaterTail = (ListNode*)malloc(sizeof(ListNode));

       //遍历原链表

       ListNode* pcur = head;
       if (head == NULL)
       return head;
       while(pcur)
       {
        if (pcur->next < x)
        {
            //尾插到小链表
            lessTail->next= pcur;
            lessTail= lessTail->next;

        }
        else 
        {
            greaterTail ->next = pcur;
            greaterTail = greaterTail->next;
        }

        pcur = pcur->next
       }
       greaterTail->next = NULL;//防止死循环   初始化next指针


       //使小链表的为节点和大链表的第一个有效节点首尾相连

       lessTail->next =greaterHead->next

       //释放动态申请的内存

       ListNode* ret = lessHead->next;
       free(lessHead);
       free(greaterHead);
       lessHead = greaterHead = NULL;
       return ret;
    }