单链表经典算法 (详细思路解析和代码实现)

最新推荐文章于 2024-05-21 00:00:00 发布
最新推荐文章于 2024-05-21 00:00:00 发布
阅读量1.7k 收藏 22
点赞数 22
分类专栏： 数据结构（C语言实现） 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa114514aaaa/article/details/138283162
版权

单链表经典算法

注意！：

本文章中的所有头节点的说法 其实都是不太正确，不太严谨的，在本文章中为了便于理解，我将使用头节点作为链表的第一个节点的说法。

实际上头节点（放哨位）是带头链表中的的一个说法

1.1 移除链表元素

题目：

题目链接

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

image-20240420185252936

解答：

思路1：

  1. 遍历整个链表，让pcur指向第一个节点 然后向后去找
  2. 如果pcur指向的节点的数据是val那么就进行删除的操作
  3. 就是让prev指向前一个指针，next指向后一个指针
  4. 然后将pcur指向的指针删除，然后再让prev和next指向的节点链接起来
  5. 然后继续往后找 ，找到了就删除，没找到就一直往后找

image-20240420184842735

思路2：

  1. 创建一个新链表 同样也是让pcur去遍历整个链表
  2. 当pcur指向的节点存储的数据 != val的时候，就将该节点尾插到新链表中
  3. 要让newTail指向新的尾节点，让新的尾节点具备指向下一个新的尾节点的能力
  4. 这样才能不断地进行尾插
  5. 如果pcur指向的节点存储的数据 == val的时候，就跳过接着往后找

image-20240420185655557

解题代码：

这里我们采用思路2进行解题

struct ListNode
{
    int val;
    struct ListNode* next;
};
// 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点
typedef struct ListNode ListNode;
struct ListNode* removeElements(ListNode* head, int val)
{
    // 创建一个新的链表
    ListNode* newhead, * newtail;
    newhead = newtail = NULL;

    ListNode* pcur = head;
    // 遍历原链表 
    while (pcur)
    {
        // 找节点数据不是val的节点
        if (pcur->val != val)
        {
            // 要分类  新链表是否为空链表
            if (newhead == NULL)
            {
                // 空链表就让pcur节点插入,同时作为新的头和尾
                newhead = newtail = pcur;
            }
            else
            {
                newtail->next = pcur;
                newtail = newtail->next;
            }
        }
        // 走到这里说明插入节点到新链表完毕
        pcur = pcur->next;
    }
    // 走到这里说明 不为val的节点 都已经放到新链表中了
    // 但是我们要注意一个问题，就是最后一个节点所存储的指针要置为NULL
    // 因为其有可能指向的是原链表的下一个值为val的节点
    if (newhead) // 加一个判断是为了防止链表为空的情况
        newtail->next = NULL;
    return newhead;
}

1.2 反转链表

题目：

链接

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

image-20240420193712239

思路1：

  1. 首先我们创建一个新的链表
  2. 然后我们去遍历原链表
  3. 把原链表的每一个节点都头插到我们的新链表中
  4. 记得要不断的让newHead更新 这样我们才能访问这个新链表

image-20240421000227771

思路2：

  1. 首先我们创建三个指针， n1指向头节点，n2，n3分别指向下一个节点和下下个节点
  2. 然后让n2的next指针不再指向n3 而是指向n1
  3. 再让n1指向n2，n2指向n3，让n3指向n3的next指针 也就是n3的下一个节点
  4. 第2、3步做完就可以让一个节点倒着指向前面的节点
  5. 接着重复上述操作
  6. 直至将链表反转

image-20240421004529957

这里代码的实现我们采用思路2：

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 = n2->next;

    // 遍历原链表 并进行反转
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if(n3) // n3为NULL 无法进行解引用
            n3 = n3->next;
    }
    // 走到这里说明反转完成
    return n1;
}

思路1的代码也有：

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{
    // 创建一个新链表
    ListNode* newHead = NULL;

    ListNode* pcur = head;
    // 遍历原链表 并将其节点 头插到新链表当中
    while (pcur)
    {
        ListNode* temp = pcur; // 保存原链表的头节点
        pcur = pcur->next;// 移动到下一个节点

        temp->next = newHead; // 将当前节点头插到新链表的节点
        newHead = temp; // 更新新链表的头节点
    }
    return newHead;
}

1.3 合并两个有序链表

题目：

链接

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

image-20240421123935488

思路：

  1. 创建一个新链表
  2. 创建两个指针l1，l2分别指向第一个链表和第二个链表
  3. 通过l1，l2来比较链表中的数据谁小，谁小谁就尾插到新链表中。并让其指针向后走 指向下一个节点
  4. 最后停止循环的时候，只可能是l1为NULL 或者l2为NULL
  5. 这个时候判断是l1还是l2为NULL
  6. 判断完毕之后将 将另一个链表的剩余数据全部尾插到新链表中

注意：

要记得对空链表的情况进行处理，如果合并的两个有序链表中 有一个或者两个都是空链表 就返回另一个链表就行

image-20240421134555653

我们来看一下代码是如何是实现的：

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 *newHead, *newTail;
    newHead = newTail = NULL;

    //  创建l1 和 l2 指针去访问两个链表
    ListNode* l1 = list1;
    ListNode* l2 = list2;

    // 去分别遍历链表并比较 指向的节点存储的数据谁大谁小
    while(l1 && l2) // 当l1或者l2 访问完毕链表就退出循环
    {
        if(l1->val < l2->val) // l1节点的数据 小于 l2节点的数据 
        {
            if(newHead == NULL) // 判断新链表是否为空
            {
                newHead = newTail = l1;
            }
            else
            {
                newTail->next = l1; // 将l1尾插到 新链表中
                newTail = newTail->next;// 及时更新新链表的尾节点
            }
            l1 = l1->next; // 让l1向后遍历
        }
        else
        {
            if(newHead == NULL)
            {
                newHead = newTail = l2;
            }
            else
            {
                newTail->next = l2;
                newTail = newTail->next;
            }
            l2 = l2->next;
        }
    }
    // 退出循环代表着 l1 或者l2 已经遍历完链表了 已经是NULL了  
    //此时另外一个链表中还存在数据 要将这个剩下的数据全部尾插到我们的新链表当中
    if(l2)
    {
        // l2 还有数据 但是我们不知道里面还有多少数据 用循环把l2全部数据尾插到我们的新链表
        while(l2)
        {
            newTail->next = l2;
            newTail = newTail->next;
            l2 = l2->next;
        }
    }
    if(l1)
    {
        while(l1)
        {
            newTail->next = l1;
            newTail = newTail->next;
            l1 = l1->next;
        }
    }
    // 此时两个有序链表的数据 全部有序的放到了我们的新链表当中
    return newHead; // 我们返回访问新链表头节点的指针
}

但是我们会发现一个问题：
那就是每次我们判断完谁大谁小的时候 准备尾插的时候，我们都要去判断新链表是否为空，但实际上我们只有一开始需要判断一次而已，那后面所有的执行都是重复执行了。

image-20240421141923959

image-20240421142048376

那我们要怎么去优化这个代码呢？

思路：

  1. 首先我们在一开始的时候不在给新链表初始化为NULL
  2. 而是给他动态的申请一个节点的空间，但是里面不存储有效的数据
  3. 这个时候我们两个链表的节点全部尾插到这个不存储数据的节点的后边
  4. 这样我们就不用去判断这个新链表是否为空链表
  5. 但是需要注意，动态内存的申请到后边需要释放
  6. 释放之前要拿一个变量去存储 访问新链表的指针

代码如下：

typedef struct ListNode ListNode; 
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    // 对原链表进行判空
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    // 首先创建一个新链表
    ListNode *newHead, *newTail;
    // newHead = newTail = NULL;
    // 给新链表动态申请一个节点的空间，但是不存储有效数据
    // 这样后边就不用判断该链表是否为空链表
    newHead = newTail = (ListNode*)malloc(sizeof(ListNode));

    //  创建l1 和 l2 指针去访问两个链表
    ListNode* l1 = list1;
    ListNode* l2 = list2;

    // 去分别遍历链表并比较 指向的节点存储的数据谁大谁小
    while(l1 && l2) // 当l1或者l2 访问完毕链表就退出循环
    {
        if(l1->val < l2->val) // l1节点的数据 小于 l2节点的数据 
        {
            newTail->next = l1; // 将l1尾插到 新链表中
            newTail = newTail->next;// 及时更新新链表的尾节点
            l1 = l1->next; // 让l1向后遍历
        }
        else
        {
            newTail->next = l2;
            newTail = newTail->next;
            l2 = l2->next;
        }
    }
    // 退出循环代表着 l1 或者l2 已经遍历完链表了 已经是NULL了  
    //此时另外一个链表中还存在数据 要将这个剩下的数据全部尾插到我们的新链表当中
    if(l2)
    {
        // l2 还有数据 但是我们不知道里面还有多少数据 用循环把l2全部数据尾插到我们的新链表
        while(l2)
        {
            newTail->next = l2;
            newTail = newTail->next;
            l2 = l2->next;
        }
    }
    if(l1)
    {
        while(l1)
        {
            newTail->next = l1;
            newTail = newTail->next;
            l1 = l1->next;
        }
    }
    // 此时两个有序链表的数据 全部有序的放到了我们的新链表当中
    ListNode* ret = newHead->next;
    free(newHead);
    newHead = NULL;
    return ret; // 我们返回访问新链表头节点的指针
}

注意：

在我们优化的代码中，我们有给新链表一个不存储任何数据的节点

这种链表其实是链表分类当中的一种——带头链表

那么这个不存储任何数据的节点叫做头节点也叫哨兵位

其实之前我们说的链表的头节点 都是不太正确的说法，只是为了便于理解而已

1.4链表的中间节点

题目:
链接

给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

image-20240421115932729

思路1：

  1. 遍历原链表 ，通过count来统计节点个数 ， 最后返回第（count/2）的节点的next指针指向的节点—— 这个就是题目要求的中间节点

思路1的代码实现：

typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) 
{
    ListNode* pcur = head;
    int count = 0;
    // 遍历原链表统计 一共有多少个节点
    while(pcur)
    {
        pcur = pcur->next;
        count++;
    }
    // 找到中间节点
    ListNode* midnode = NULL;
    pcur = head;
    for(int i = 0; i<count/2 + 1; i++)
    {
        midnode = pcur;
        pcur = pcur->next;
    }
    // 找到中间节点之后就返回
    return midnode;
}

由于使用了两次循环遍历 ，导致效率没有思路2高效

思路2：

快慢指针

我们分为奇数个节点的链表 和偶数个节点的两种情况

首先是奇数个节点 的链表

  1. 我们让slow和fast两个指针都指向头节点
  2. 然后slow指针往后走一步， fast指针往后走两步
  3. 由于是奇数个节点，当fast->next == NULL 的时候，fast就走到尾节点了
  4. 此时的slow指针指向的节点就是中间节点

image-20240421120803154

我们再来看偶数个节点的链表：

  1. 首先让slow和fast指针都指向头节点
  2. 也是让slow往后走一步，让fast往后走两步
  3. 当fast==NULL 的时候，
  4. 此时slow指针指向的节点就是中间节点

image-20240421120941127

思路2的好处是，我们只需要通过一次循环就可以完成题目的要求

我们来看思路2的代码是如何实现的:

struct ListNode 
{
    int val;
	struct ListNode *next;
};
 
typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) 
{
    // 创建快慢指针
    ListNode* slow = head;
    ListNode* fast = head;

    // 开始遍历链表 让slow往后走一步， 让fast往后走两步 2slow = fast
    while(fast && fast->next) // 注意fast和fast->next的顺序不能掉换
    {
        slow = slow->next; // 往后走一步
        fast = fast->next->next; // 往后走两步
    }
    // 走到这里说明slow就是中间节点了
    return slow;
}

注意：
为什么说fast和fast->next的顺序不能掉换？

我们知道fast指针在奇数个节点的链表和在偶数个节点的链表的中止条件是不一样的

我们放在一个表达式里面判断

但是实际上 如果是 偶数个节点的情况

fast = fast->next->next; 在最后一次循环的时候 会让其 fast = NULL

如果是while(fast->next && fast)的话

那么会先执行fast->next ，但是你对一个NULL进行解引用 就会报错！！！

image-20240421121825729

1.5 环形链表的约瑟夫问题(有些难度)

这个是问题是循环链表的经典应用

题目：

题目链接

想要解决这个问题， 那么我们就得知道循环列表是什么

其实就是让最后一个节点的指针next不指向NULL ，而是指向第一个节点

image-20240421153325172

知道了循环链表的定义之后，我们来看看题目：

编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数，报到 m 的人离开。

下一个人继续从 1 开始报数。

n-1 轮结束以后，只剩下一个人，问最后留下的这个人编号是多少？

数据范围： 1≤𝑛,𝑚≤100001≤n,m≤10000

进阶：空间复杂度 𝑂(1)O(1)，时间复杂度 𝑂(𝑛)O(n)

示例1：

image-20240421153819369

示例2：
image-20240421153827830

要想做题，首先得思考，要有思路。

思路：

  1. 首先根据输入的n值编写一个函数创建一个环形链表，n是节点的个数
  2. 既然要创建链表，就要创建节点，编写一个函数用来创建节点，创建节点的时候记得往节点存储数据
  3. 有了节点之后就是链接了，将n个节点，通过尾插，链接成环形链表
  4. 用ptail 和 phead两个指针完成这个链接，ptail指向最后一个节点，phead指向第一个节点，最后让ptail->next = phead;
  5. 返回ptail的值，让prev和pcur 分别指向ptail和 ptail->next 也就是phead
  6. 这个时候做一个while循环，循环内要根据输入的m去删除 第m个节点，
  7. 删除就是让prev指向pcur的下一个节点
  8. 删除完pcur这个节点要让 pcur往后走 pcur = pcur->next,
  9. 然后继续让pcur报数，报到m，再删除，循环到只剩下一个节点的时候
  10. 返回该节点的地址，此时pcur的next指针指向自己

来看代码是如何实现的:

struct ListNode 
{
    int val;
    struct ListNode* next;
};

typedef struct ListNode ListNode;

ListNode* BuyNode(int x)
{
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    if (node == NULL)
    {
        perror("malloc");
        exit(1);
    }
    node->val = x;
    node->next = NULL;

    return node;
}

ListNode* CreateCircleList(int n)
{
    // 创建n个节点
    // 先创建第一个节点出来
    ListNode* phead = BuyNode(1);
    ListNode* ptail = phead;
    // 通过for循环 去尾插剩下要插入的n-1个节点
    for (int i = 2; i <= n; i++)
    {
        ListNode* node = BuyNode(i); // 创建节点
        // 将节点尾插到链表当中
        ptail->next = node;
        ptail = ptail->next;
    }
    // 走到这里创建了一个n个节点的链表 但是还不是环形链表
    // 让最后一个节点的next指针指向phead 也就是第一个节点
    ptail->next = phead; // 链表成环

    return ptail; // 返回最后一个节点才能找到第一个节点和第一个节点前面的节点
}

int ysf(int n, int m)
{
    // 根据n创造一个环形链表，n个节点
    ListNode* prev = CreateCircleList(n);
    ListNode* pcur = prev->next; // pcur指向链表的第一个节点

    // 这个时候开始约瑟夫删除节点 根据给的m来删除节点
    while (pcur->next != pcur) // 当剩下一个节点的时候才能退出循环 也就是pcur的next指针指向自己的时候
    {
        // 遍历链表 当pcur往后走了m - 1步之后  删除pcur指向的节点
        for (int i = 0; i < m - 1; i++)
        {
            prev = pcur; // prev是用来指向pcur的前一个节点的
            pcur = pcur->next;
        }

        // 此时的pcur指向的节点 要进行删除
        prev->next = pcur->next;// 让prev指向pcur的下一个节点
        free(pcur); // 删除pcur指向的节点
        pcur = prev->next; // 让pcur指向下一次要走m步的起点

    }
    // 这个时候就剩下一个节点  就是幸存者
    ListNode* ret = pcur->val;
    free(pcur); // 释放掉自己申请的动态内存空间
    pcur = NULL;
    return ret;
}

在删除节点的思路上 还可以有另外一个思路：

通过让count来储存 pcur向后走的此时 ， 每走一次就count++

当count == m的时候就说明 pcur指向的节点是要删除的节点

// int ysf函数还可以有另外一个思路
int ysf(int n, int m)
{
    // 根据n创造一个环形链表，n个节点
    ListNode* prev = CreateCircleList(n);
    ListNode* pcur = prev->next; // pcur指向链表的第一个节点

    int count = 1;
    // 这个时候开始约瑟夫删除节点 根据给的m来删除节点
    while (pcur->next != pcur) //当剩下一个节点的时候才能退出循环 也就是pcur的next指针指向自己的时候
    {
        // 要让pcur向后走到count = m才行能删除pcur指向的节点  
        // 分为不删除节点的情况和不删除的情况
        if (count == m) // 删除
        {
            // 删除pcur指向的节点
            prev->next = pcur->next;
            free(pcur);
            pcur = prev->next;
            count = 1; // 置为1 
        }
        else // 不删除
        {
            // 此时不删除pcur 指向的节点 
            // 让pcur往后走就行
            prev = pcur; // prev是用来指向pcur的前一个节点的
            pcur = pcur->next;// pcur往后走
            count++; // 让count统计此时pcur指向的的节点是否要删除
        }
    }
    // 这个时候就剩下一个节点  就是幸存者
    ListNode* ret = pcur->val;
    free(pcur); // 释放掉自己申请的动态内存空间
    pcur = NULL;
    return ret;
}

这个思路的效率稍高，但基本没有什么区别。

1.6 分割列表(面试题，难度：中等)

题目：

题目链接

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你不需要 保留 每个分区中各节点的初始相对位置。

image-20240421191454561

思路1：

  1. 在原链表上修改
  2. 若pcur节点的值小于x，就往后走。
  3. 若pcur节点的值 大于或等于x，就尾插到原链表后，删除旧节点
  4. 删除就是让prev的next指针指向pcur的下一个节点，删除pcur指向的节点，再让pcur = prev-》next 让pcur指向下一个节点
  5. 当pcur走到ptail也就是原链表的最后一个节点的时候，不再需要去判断其节点的数据是否大于小于x 。 因为此时刚好是分界点

image-20240421192740922

思路2：

创建一个新链表，将节点的值小于x的都放到新链表的左边，大于x的都放到新链表的右边

  1. 创建一个新链表，并给与它一个哨兵位（头节点）
  2. 让一个指针去遍历原链表，如果节点的值小于x就头插， 如果节点的值大于x就尾插
  3. 注意了，如果新链表是空的，那就不用判断节点的值，直接拿下来头插到哨兵位的后边。

image-20240421193947204

思路3：

创建两个新链表：小链表和大链表

  1. 首先创建两个链表，一个大链表，一个小链表
  2. 然后给两个新链表各一个哨兵位（头节点）[这样可以避免重复的判断新链表是否为空]
  3. 如果pcur指向节点的值小于x就尾插到小链表中
  4. 如果pcur指向节点的值大于x 就尾插到大链表中
  5. 将小链表的尾节点和大链表的第一个有效节点首尾相连
  6. 这样就是一个链表了

image-20240421194459489

我们来看思路3的代码实现：

typedef struct ListNode ListNode;
struct ListNode* partition(struct 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;
    // 遍历原链表， 判断节点该放到小链表还是大链表
    while(pcur)
    {
        // 判断pcur指向的节点的值和x的关系
        if(pcur->val >= x)
        {
            // 放到大链表当中
            greaterTail->next = pcur;
            greaterTail = greaterTail->next;
        }
        else
        {
            lessTail->next = pcur;
            lessTail = lessTail->next;
        }
        pcur = pcur->next;
    }
    // 此时已经将所有的节点分配完毕 
    greaterTail->next = NULL; // 注意要让大链表的最后一个节点的next指针指向NULL 不然会导致链表成环 陷入死循环
    // 并且当大链表没有插入节点的时候 还可以对哨兵位的next指针初始化  因为此时的greaterTail 指向的就是哨兵位

    // 这个时候要让大小链表相连 就是让小链表的尾节点指向大链表的第一个节点
    lessTail->next = greaterHead->next;
    // 完成了大小链表相连之后 我们就可以返回 访问链表的指针了
    ListNode* ret = lessHead->next; // lessHead 是哨兵位
    free(lessHead);
    free(greaterHead);
    lessHead = greaterHead = NULL;
    return ret;
}
WZF-Sang
关注
  • 22
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表倒序算法.doc
05-07
单链表倒序算法详解 单链表倒序算法是指将单链表中的节点顺序逆转的算法。在实际应用中，单链表倒序算法常用于解决一些特殊的问题，例如逆序打印链表、链表排序等。 单链表倒序算法的思路可以分为以下几步： 1. ...
实现单链表的各种基本运算的算法
热门推荐
kklv__lo的博客
05-15 1万+
内容：编写一个程序，实现单链表的各种基本算法和整体建表算法，并在此基础上设计一个程序，完成以下功能。 单链表的基本运算如下： (1)初始化单链表h。 (2)依次采用尾插法插入a,b,c,d,e元素。 (3)输出单链表h。 (4)输出单链表h的长度。 (5)判断单链表h是否为空。 (6)输出单链表h的第3个元素。 (7)输出元素a的位置。 (8)在第4个元素位置上插入f元素。 (9)输出单链表h。 (10)删除单链表h的第3个元素。 (11)输出单链表h。 (12)释放单链表h。 头文件+函数 #includ
数据结构与算法——单链表的基本操作的实现
weixin_68773927的博客
10-21 2148
（从链表的头指针出发，顺着链域next逐个结点往下搜索，直至搜索到第i个为止，因此，链表不是随机存取结）链表任然存在，但链表中无元素，成为空链表（头指针和头节点任然存在）空表：链表中无元素，称为空链表(头指针和头节点任然存在）按值查找：根据指定数据获取该数据所在的位置序号（是第几个数据元素）按值查找：根据指定数据获取该数据元素所在的位置（该数据的地址）算法思路：从首元结点开始，依次计算所有节点。算法思路：从头指针开始，依次释放所有结点。思路：判断头节点指针域是否为空。算法步骤：（找到i-1结点）
实现单链表各种基本运算的算法
最新发布
About_Yu的博客
05-21 1167
目的: 领会单链表存储结构和掌握单链表中各种基本运算算法设计，以及完成以下任务 编写头插法和尾插法编写代码，并且在main函数中使用头插法和尾插法进行实现导入数据。 内容: 编写一个程序linklist.cpp,实现单链表的各种基本运算和整体建表算法
单链表的基本算法实现
Gavin的博客
03-05 1905
单链表的基本算法实现
数据结构线性表实现单链表各种基本运算
weixin_57011178的博客
10-04 2108
单链表的各种基本运算 文章目录 前言 一，头插法，与尾插法 二，各种基本运算 三，代码展示 ​​​​​​​总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库..
数据结构-单链表基本操作的实现
Xiao_Ya__的博客
05-23 662
数据结构-单链表基本操作的实现
单链表逆置算法详解
10-29
详细描述了单链表逆转的思路及过程，并附源码
单链表的逆置的概要介绍与分析
04-27
2. **算法详解**：资源中常常图文并茂地阐述了两种典型算法思路：一是借助额外指针逐个调整节点的next指针；二是创建新的链表并通过头插法重建逆序链表。在迭代方法中，通常使用三个指针分别记录当前节点、前一个...
用单链表实现任意两个一元多项式的加减运算详解.pdf
06-25
"用单链表实现任意两个一元多项式的加减运算详解" 本文档旨在设计一个使用单链表实现任意两个一元多项式的加减运算的系统。该系统要求实现以下功能：输入一元多项式pn(x)和Qn(x)，升幂排序，输出一元多项式，计算...
Java经典算法50题——答案下载！
04-11
在解题过程中，可能会用到一些工具，如Java内置的Collections类库，或者第三方库如Guava、Apache Commons等，它们提供了丰富的数据结构和算法实现，能帮助简化代码并提高效率。 在"ClassicalAlgorithm50"这个压缩包...
C++实现单链表的基本运算
henry594xiaoli的博客
03-29 3900
领会单链表存储结构和掌握单链表中的各种基本运算算法设计，实现单链表的各种基本运算和整体建表算法（假设单链表的元素类型ElemType 为char）。
单链表各种基本运算的算法
Hey3399的博客
04-23 3782
初始化单链表 /初始化单链表 void InitList(LinkNode *&L) { //创建头结点 L=(LinkNode*)malloc(sizeof(LinkNode)); L->next=NULL; } 头插法建立单链表 //头插法建立单链表 void CreateListF(LinkNode *&L,ElemType a[],int n) { //创建头结点 LinkNode *s; L=(LinkNode*)malloc(sizeof(LinkNo
6-62 单链表基本运算算法的实现
燕朝铭的博客
01-15 1262
线性表实验二 实现单链表各种基本运算的算法 目的: 领会单链表存储结构和掌握单链表中各种基本运算算法设计。 内容: 实现单链表的各种基本运算(假设单链表的元素类型ElemType为char)，并在此基础上设计一个程序，完成如下功能:
实现单链表的基本运算
weixin_45018223的博客
09-25 275
单链表数据结构
实现单链表的各基本运算
For_whx的博客
09-26 248
#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <stdbool.h> typedef char ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LinkNode; int InitList(LinkNode *L) { L -> next = NUL.
编写一个算法，计算在头指针为head的单链表中数据域值为x的结点个数。
The_Handsome_Sir的博客
04-30 1万+
核心代码 void Count(LinkList head,int y) { LinkList p; p=head; int n=0; while(p->next!=NULL) { p=p->next; if(p->data==y) n++; //while循环统计出现次数 } printf("%d出现次数为：%d",y,n); } main函数...
编写算法，实现带头结点单链表的逆置算法。
zyjf011的博客
10-21 6860
//建立带头结点单链表时间复杂度O(n) void CreatList_head(Linklist &L,int n) { L=new Lnode; L->next=null; for(i=n;i>0;i--) { p=new Lnode; //p=(Lnode*)malloc(sizeof(Lnode)); scanf(&p-...
C语言超经典算法详细分析100例
09-14
C语言超经典算法详细分析100例

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值