C语言链表（创建、遍历、释放、查找、删除、插入一个节点、排序，逆序）

最新推荐文章于 2024-04-27 12:03:30 发布
最新推荐文章于 2024-04-27 12:03:30 发布
阅读量5.5k 收藏 164
点赞数 28
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zonggu/article/details/123817773
版权

文章目录

前言

前面提到的线性表的顺序存储结构。它是有缺点的，最大的缺点就是插入和删除时需要移动大量元素，这显然就需要耗费时间。能不能想办法解决呢？

我们反正也是要让相邻元素间留有足够余地，那干脆所有的元素都不要考虑相邻位置了，哪有空位就到哪里，而只是让每个元素知道他下一个元素的位置在哪里，这样，我们可以在第一个元素时，就知道第二个元素的位置(内存地址)，而找到他；在第二个元素时，再找到第三个元素的位置（内存地址）。这样所有的元素我们就都可以通过遍历而找到。

1.1 线性表链式存储结构定义

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置

请添加图片描述

以前在顺序结构中，每个元素只需要存储数据元素信息就可以了。现在链式结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址。

因此，为了表示每个元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继元素的存储位置）。

我们把存储元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针或链。

这两部分信息组成数据元素ai的存储映像，称为结点(Node)。

n个结点（ai的存储映像）链结成一个链表，即为线性表（a1,a2,a3,…,an）的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

请添加图片描述

我们把链表中第一个结点的存储位置叫做头指针，那么整个链表的存取就必须是从头指针开始进行了。

之后的每一个结点，其实就是上一个结点的后继指针指向的位置。

那么最后一个结点，当然就意味着直接后继不存在。

所以规定，线性表的最后一个结点指针为“空”（通常用NULL或=="^"==符号表示，如下图所示）。

请添加图片描述

有时，我们为了更加方便地对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点

头结点的数据域可以不存储任何信息。（也可以存储如线性表的长度等附加信息，头结点的指针域存储指向第一个结点的指针，如下图所示）

请添加图片描述

头指针与头结点的异同

头指针

  • 头指针是链表指向第一个节点的指针，若链表有头结点，则是指向头结点的指针
  • 头指针具有标志作用，所以常用头指针冠以链表的名字
  • 无论链表是否为空，头指针均不为空。头指针是链表的必要元素

头结点

  • 头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可以存放链表的长度）
  • 有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他节点的操作就统一了
  • 头结点不一定是链表必须要素

1.2 线性表链式存储结构代码描述

1.2.1 定义结点结构体
//定义结点结构体
typedef struct student
{
    //数据域
    int num;			//学号
    int score;			//分数
    char name[20];	//姓名
    //指针域
    struct student* next;
}STU;

从这个定义中我们也就知道，结点由：存放数据元素的数据域和存放后继结点地址的指针域组成

假设p是指向线性表第i个元素的指针，则该结点ai的数据域我们可以用p->data来表示，p->data的值是一个数据元素，结点ai的指针域可以用p->next来表示，p->next的值是一个指针。p->next指向第i+1个元素，即指向ai+1的指针。也就是说，如果p->data等于ai，那么p->next->data等于ai+1，如下图所示。

请添加图片描述

1.2.2 链表的创建

第一步：创建一个结点

在这里插入图片描述

第二步：创建第二个结点，将其放在第一个结点的后面（第一个结点的指针域保存新结点的地址，以此类推）

请添加图片描述

第三步：再次创建结点，通过遍历找到最后一个结点，接着将最后一个结点的指针域保存新节点的地址，以此类推

请添加图片描述

代码实现

//链表创建
void link_creat_head(STU** p_head, STU* p_new)
{
    STU* p_mov = *p_head;
    if (*p_head == NULL)//当第一次加入链表为空时,head执行p_new
    {
        *p_head = p_new;
        p_new->next = NULL;
    }
    else //第二次及以后加入链表
    {
        while (p_mov->next != NULL)
        {
            p_mov = p_mov->next;		//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;//将新申请的节点加入链表
        p_new->next = NULL;

    }
}
1.2.3 链表的遍历

第一步：输出第一个结点的数据域，输出完毕后，让指针保存后一个结点的地址

请添加图片描述

第二步：以此类推，知道结点的指针域为NULL

代码实现

//链表的遍历
void link_print(STU* head)
{
    STU* p_mov;
    //定义新的指针保存链表的首地址,防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个节点的指针域为NULL时,循环结束
    while (p_mov != NULL)
    {
        //先打印当前指针保存节点的指针域
        printf("num=%d score=%d name:%s\n", p_mov->num, p_mov->score, p_mov->name);
        //指针后移,保存下一个结点的地址
        p_mov = p_mov->next;
    }
    printf("\n");
}
1.2.4 链表的释放

重新定义一个指针q，保存p指向结点的地址，然后p后移保存下一个结点的地址，然后释放q对应的结点，以此类推，知道p为NULL为止

请添加图片描述

代码实现

//链表的释放
void link_free(STU** p_head)
{
    //定义一个指针变量
    STU* pb;
    while (*p_head != NULL)
    {
        //先保存p_head指向的结点的地址
        pb = *p_head;
        //p_head保存下一个结点地址
        *p_head = (*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}
1.2.5 链表结点的查找

先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下一个结点，如果到达最后一个结点的时候都没有匹配的数，说明要查找数据不存在

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
    STU* p_mov;
    //定义的指针变量保存第一个结点的地址
    p_mov = head;
    //当没有到达最后一个结点的指针域时循环继续
    while (p_mov != NULL)
    {
        //如果找到是当前节点的数据,则返回当前节点的地址
        if (p_mov->num == num)//找到了
        {
            return p_mov;
        }
        //如果没有找到,则继续对比下一个结点的指针域
        p_mov = p_mov->next;
    }
    //当循环结束的时候还没有找到,说明查找的数据不存在,返回NULL进行标识
    return NULL;
}

//按照姓名查找
STU* link_search_name(STU* head, char* name)
{
    STU* p_mov;
    p_mov = head;
    while (p_mov != NULL)
    {
        if (strcmp(p_mov->name, name) == 0)//找到了
        {
            return p_mov;
        }
        p_mov = p_mov->next;
    }
    return NULL;//没有找到
}
1.2.6 链表结点的删除

如果链表为空，不需要删除。

如果删除的是第一个结点，则需要将保存链表首地址的指针保存第一个结点的下一个结点的地址。

如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结点的后一个结点的地址即可

//链表节点的删除
void link_delete_num(STU** p_head, int num)
{
    STU* pb, * pf;
    pb = *p_head;
    pf = *p_head;
    if (*p_head == NULL)//链表为空,不用删
    {
        printf("链表为空,没有您要删的结点\n");
        return;
    }
    while (pb->num != num && pb->next != NULL)
    {
        pf = pb;
        pb = pb->next;
    }
    if (pb->num == num)//找到了一个节点的num和num相同
    {
        if (pb == *p_head)//要删除的结点是头结点
        {
            //让保存头结点的指针保存后一个节点的地址
            *p_head = pb->next;
        }
        else
        {
            //前一个结点的指针域保存要删除的后一个节点的地址
            pf->next = pb->next;
        }
        //释放空间
        free(pb);
        pb = NULL;
    }
    else//没有找到
    {
        printf("没有找到您要删除的结点\n");
    }
}
1.2.7 链表中插入一个节点

链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置

请添加图片描述

情况（按照从小到大）：

  • 如果链表没有结点，则新插入的就是第一个结点

  • 如果新插入的结点的数值最小，则作为头结点

  • 如果新插入的结点的数值在中间位置，则找到前一个，然后插入到他们中间

  • 如果新插入的结点的数值最大，则插入到最后

代码实现

//链表的插入:按照学号的顺序插入
void link_insert_num(STU** p_head, STU* p_new)
{
    STU* pb, * pf;
    pb = pf = *p_head;
    if (*p_head == NULL)//链表为空链表
    {
        *p_head = p_new;
        p_new->next = NULL;
        return;
    }
    while ((p_new->num >= pb->num) && (pb->next != NULL))
    {
        pf = pb;
        pb = pb->next;
    }
    if (p_new->num < pb->num)//找到一个节点的num比新来的结点num大,插在pb的前面
    {
        if (pb == *p_head)
        {
            p_new->next = *p_head;
            *p_head = p_new;
        }
        else
        {
            pf->next = p_new;
            p_new->next = pb;
        }
    }
    else//没有找到pb的num比p_new->num大的结点,插在最后
    {
        pb->next = p_new;
        p_new->next = NULL;
    }
}
1.2.8 链表排序

如果链表为空，不需要排序

如果链表只有一个结点，不需要排序

先将第一个结点与后面所有的结点依次对比数据域，只要有比第一个结点数据域小的，则交换位置 ，交换之后，拿新的第一个结点的数据域与下一个结点再次对比，如果比他小，再次交换，以此类推

第一个结点确定完毕之后，接下来再将第二个结点与后面所有的结点对比，直到最后一个结点也对比完毕为止

代码实现

//链表的排序
void link_order(STU* head)
{
    STU* pb, * pf, temp;
    pf = head;
    if (head == NULL)
    {
        printf("只有一个结点,不用排序\n");
        return;
    }
    if (head->next == NULL)
    {
        printf("只有一个节点,不用排序\n");
        return;
    }
    while (pf->next != NULL)
    {
        pb = pf->next;//pb从基准元素的下个元素开始
        while (pb != NULL)
        {
            if (pf->num > pb->num)
            {
                temp = *pb;
                *pb = *pf;
                *pf = temp;

                temp.next = pb->next;
                pb->next = pf->next;
                pf->next = temp.next;
            }
            pb = pb->next;
        }
        pf = pf->next;
    }
}
1.2.9 链表逆序

请添加图片描述

第一步：将3结点移动到5结点前面

在这里插入图片描述

第二步：将5结点后面的1结点移动到3结点的前面

在这里插入图片描述

代码实现

//链表逆序
STU* link_reverse(STU* head)
{
    STU* pf, * pb, * r;
    pf = head;
    pb = pf->next;
    while (pb != NULL)
    {
        r = pb->next;
        pb->next = pf;
        pf = pb;
        pb = r;
    }
    head->next = NULL;
    head = pf;
    return head;
}

总结

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;			//学号
    int score;			//分数
    char name[20];	//姓名
    //指针域
    struct student* next;
}STU;

//链表创建
void link_creat_head(STU** p_head, STU* p_new)
{
    STU* p_mov = *p_head;
    if (*p_head == NULL)//当第一次加入链表为空时,head执行p_new
    {
        *p_head = p_new;
        p_new->next = NULL;
    }
    else //第二次及以后加入链表
    {
        while (p_mov->next != NULL)
        {
            p_mov = p_mov->next;		//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;//将新申请的节点加入链表
        p_new->next = NULL;

    }
}

//链表的遍历
void link_print(STU* head)
{
    STU* p_mov;
    //定义新的指针保存链表的首地址,防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个节点的指针域为NULL时,循环结束
    while (p_mov != NULL)
    {
        //先打印当前指针保存节点的指针域
        printf("num=%d score=%d name:%s\n", p_mov->num, p_mov->score, p_mov->name);
        //指针后移,保存下一个结点的地址
        p_mov = p_mov->next;
    }
    printf("\n");
}

//链表的释放
void link_free(STU** p_head)
{
    //定义一个指针变量
    STU* pb;
    while (*p_head != NULL)
    {
        //先保存p_head指向的结点的地址
        pb = *p_head;
        //p_head保存下一个结点地址
        *p_head = (*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表的插入:按照学号的顺序插入
void link_insert_num(STU** p_head, STU* p_new)
{
    STU* pb, * pf;
    pb = pf = *p_head;
    if (*p_head == NULL)//链表为空链表
    {
        *p_head = p_new;
        p_new->next = NULL;
        return;
    }
    while ((p_new->num >= pb->num) && (pb->next != NULL))
    {
        pf = pb;
        pb = pb->next;
    }
    if (p_new->num < pb->num)//找到一个节点的num比新来的结点num大,插在pb的前面
    {
        if (pb == *p_head)
        {
            p_new->next = *p_head;
            *p_head = p_new;
        }
        else
        {
            pf->next = p_new;
            p_new->next = pb;
        }
    }
    else//没有找到pb的num比p_new->num大的结点,插在最后
    {
        pb->next = p_new;
        p_new->next = NULL;
    }
}

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
    STU* p_mov;
    //定义的指针变量保存第一个结点的地址
    p_mov = head;
    //当没有到达最后一个结点的指针域时循环继续
    while (p_mov != NULL)
    {
        //如果找到是当前节点的数据,则返回当前节点的地址
        if (p_mov->num == num)//找到了
        {
            return p_mov;
        }
        //如果没有找到,则继续对比下一个结点的指针域
        p_mov = p_mov->next;
    }
    //当循环结束的时候还没有找到,说明查找的数据不存在,返回NULL进行标识
    return NULL;
}

//按照姓名查找
STU* link_search_name(STU* head, char* name)
{
    STU* p_mov;
    p_mov = head;
    while (p_mov != NULL)
    {
        if (strcmp(p_mov->name, name) == 0)//找到了
        {
            return p_mov;
        }
        p_mov = p_mov->next;
    }
    return NULL;//没有找到
}

//链表节点的删除
void link_delete_num(STU** p_head, int num)
{
    STU* pb, * pf;
    pb = *p_head;
    pf = *p_head;
    if (*p_head == NULL)//链表为空,不用删
    {
        printf("链表为空,没有您要删的结点\n");
        return;
    }
    while (pb->num != num && pb->next != NULL)
    {
        pf = pb;
        pb = pb->next;
    }
    if (pb->num == num)//找到了一个节点的num和num相同
    {
        if (pb == *p_head)//要删除的结点是头结点
        {
            //让保存头结点的指针保存后一个节点的地址
            *p_head = pb->next;
        }
        else
        {
            //前一个结点的指针域保存要删除的后一个节点的地址
            pf->next = pb->next;
        }
        //释放空间
        free(pb);
        pb = NULL;
    }
    else//没有找到
    {
        printf("没有找到您要删除的结点\n");
    }
}

//链表的排序
void link_order(STU* head)
{
    STU* pb, * pf, temp;
    pf = head;
    if (head == NULL)
    {
        printf("只有一个结点,不用排序\n");
        return;
    }
    if (head->next == NULL)
    {
        printf("只有一个节点,不用排序\n");
        return;
    }
    while (pf->next != NULL)
    {
        pb = pf->next;//pb从基准元素的下个元素开始
        while (pb != NULL)
        {
            if (pf->num > pb->num)
            {
                temp = *pb;
                *pb = *pf;
                *pf = temp;

                temp.next = pb->next;
                pb->next = pf->next;
                pf->next = temp.next;
            }
            pb = pb->next;
        }
        pf = pf->next;
    }
}

//链表逆序
STU* link_reverse(STU* head)
{
    STU* pf, * pb, * r;
    pf = head;
    pb = pf->next;
    while (pb != NULL)
    {
        r = pb->next;
        pb->next = pf;
        pf = pb;
        pb = r;
    }
    head->next = NULL;
    head = pf;
    return head;
}

int main()
{
    STU* head = NULL, * p_new = NULL;
    STU* pb;
    char name[32] = "";
    int num, i;
    int flag;
    printf("请输入链表初始个数:\n");
    scanf("%d", &num);
    for (i = 0; i < num; i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新的节点
        printf("请输入学号,分数,姓名:\n");//给新节点赋值
        scanf("%d %d %s", &p_new->num, &p_new->score, p_new->name);
        link_creat_head(&head, p_new);
    }
    link_print(head);
    //查学号
    do
    {
        printf("请输入您要查找学生的学号\n");
        scanf("%d", &num);
        pb = link_search_num(head, num);
        if (pb != NULL)
        {
            printf("找到了 num=%d score=%d name:%s\n", pb->num, pb->score, pb->name);
            printf("您是否要继续,退出请按1,重新请按0\n");
            scanf("%d", &flag);
        }
        else
        {
            printf("没有查找到您要查找到结点,是否退出?退出请按1,重新请按0\n");
            scanf("%d", &flag);
        }
    } while (flag != 1);

    //查姓名
    do
    {
        printf("请输入您要查找的学生的姓名:\n");
        scanf("%s", name);
        pb = link_search_name(head, name);
        if (pb != NULL)//找到了
        {
            printf("找到了 num=%d score=%d name:%s\n", pb->num, pb->score, pb->name);
            printf("您是否要继续,退出请按1,重新请按0\n");
            scanf("%d", &flag);
        }
        else
        {
            printf("没有查找到您要查找到结点,是否退出?退出请按1,重新请按0\n");
            scanf("%d", &flag);
        }
    } while (flag != 1);
    printf("请输入您要删除的结点的学号\n");
    scanf("%d", &num);
    link_delete_num(&head, num);
    printf("删除后的链表为:\n");
    link_print(head);
    do
    {
        printf("请输入您要插入节点的 num score name\n");
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        scanf("%d %d %s", &p_new->num, &p_new->score, p_new->name);
        link_insert_num(&head, p_new);
        link_print(head);
        printf("您是否要继续,继续请按0,退出请按1\n:");
        scanf("%d", &flag);
    } while (flag==0);
    printf("*********************\n");
    printf("排列后的顺序是:\n");
    link_order(head);
    link_print(head);
    printf("*********************\n");
    printf("逆序排列后的顺序是:\n");
    head = link_reverse(head);
    link_print(head);
    link_free(&head);
}
宗谷.
关注
  • 28
    点赞
  • 踩
  • 164
    收藏
    觉得还不错? 一键收藏
  • 236
    评论
专栏目录
C语言实现单向链表的创建、插入，删除节点，和2个链表合并
12-10
VC6.0下 用C语言实现单向链表的创建、插入，删除节点，和2个链表合并等操作
希尔排序
ChengChengxn的博客
12-16 314
希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。 public class ShallSort { public static void main(String[] args) { int[]
链表的创建及遍历（C语言）
2301_80284166的博客
03-08 452
链表这个东西，很多时候会让我们很头疼，因为链表需要用到指针，而指针正是我们学习C语言遇到的最大困难之一，而链表又不得不用指针。
C语言实现输出链表中倒数第k个节点
09-04
主要介绍了C语言实现输出链表中倒数第k个节点,主要涉及链表的遍历操作,是数据结构中链表的常见操作。需要的朋友可以参考下
C语言实现链表，创建、插入、查找、删除、遍历等基本操作
09-13
C与语言实现链表的创建、插入（头插法、尾插法）、遍历、查找、删除操作
C语言实现二叉排序树构造 查找删除节点 中序遍历
06-24
C语言实现二叉排序树构造 查找删除节点 中序遍历 已调试好
C语言 单链表的创建、遍历、释放
m0_74803157的博客
01-06 3018
【代码】C语言 单链表的创建、遍历、释放。
c语言释放链表的方式,C语言（4）--创建无序链表、释放链表
weixin_29467909的博客
05-21 3562
1.建立一个如图所示的简单链表，它由三个学生数据的结点组成 代码：#include #include #include struct student{int num;//学号char name[20];//姓名double score;//成绩struct student *next;//下一个结点地址};int main(){struct student *a,*b,*c,*head=NULL;...
单向链表之释放（C语言实现）
热门推荐
peng_fp的博客
03-19 1万+
链表的创建查看 同遍历链表类似，区别在于p_mov每指向某个节点后都将该节点释放 1、释放前要先保存下一个节点，释放后备份恢复给p_mov,否则释放了当前节点，下一个节点的地址就将失去； 2、依次将所有节点释放后，最后返回NULL（标示释放完毕）。 结构体节点： typedef struct student { int num; //学号 i
【数据结构学习】单链表的指定位置元素删除、链表的释放
冯宇的博客
02-03 5884
删除指定节点 //删除某个结点 int list_delete(linklist H,int pos){ if(H==NULL){ printf("删除结点失败，链表为空！\n"); return -1; } //获取要删除结点的上一个结点（前驱） listnode *lastnode = list_get(H,pos-1); //当没有前驱，或者该节点不存在的情况下 if(lastnode == NULL || lastnode
数据结构-单链表的实现（删除和释放）day5（复杂操作的实现）day6
楚子航
04-08 2963
一、链表的删除 链表的删除：即实现DeleteLinklist(h, i)， 算法对应的链表结构如图所示。 算法思路：同插入法，先调用函数GetLinklist(h, i-1),找到结点ai的前驱，然后将结点ai删除之。 1.用q指向要被删除的节点，2.将被删除节点前方的箭头直接指向下一个节点。3.释放q指向节点的空间。 二、把整个链表释放 H指针往后走，p指针负责删除，H =NULL时结束。 三、代码 1.linklist.h: 2.linklist.c: 3....
C++实现的链表类实例
01-20
本文实例讲述了C++实现的链表类。分享给大家供大家参考。具体如下： #include <iostream> using namespace std; class linklist { private: struct node { int data; node *link; }*p; public: linklist(); void append( int num ); void add_as_first( int num ); void addafter( int c, int num );
Linux运维-嵌入式物联网开发教程-获取链表结点个数和链表释放函数.mp4
05-30
Linux运维-嵌入式物联网开发教程-获取链表结点个数和链表释放函数.mp4
链表的C语言实现之动态内存分配
08-03
所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
主要介绍了C语言实现带头结点的链表的创建、查找、插入、删除操作方法,对于了解数据结构中链表的各项操作有很好的借鉴价值,需要的朋友可以参考下
数据结构---线性表（顺序表）附代码
2302_81153999的博客
04-27 752
假定数组有10个空间，已经使用了5个，向数组中插入数据步骤： 求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插⼊数据（注意：这里是否要判断数组是否满了，满了还能继续插⼊吗）..... 假设数据量非常庞大，频繁的获取数组有效数据个数会影响程序执行效率。同理，程序中如果不对数据进行管理，可能会导致数据丢失、操作数据困难、野指针等情况。常见的数值1、2、3、4.....、教务系统里保存的用户信息（姓名、性别、年龄、学历等 ）、网页里肉眼可以看到的信息（文字、图片、视频等等），这些都是数据。
数据结构八：线性表之循环队列的设计
最新发布
weixin_47040031的博客
04-27 991
上篇博客，学习了栈，我们可以知道他也是一种线性表，遵从先进后出的原则，在本节，我们进一步学习另一种线性表—队列。就像饭堂里排队打饭的的队伍，作为一种先进先出的线性表，他又有哪些特别之处呢？又该如何应用呢？接下来，跟我走近队列的世界里。目录一、队列的应用场景二、队列的基本概念和结构2.1 队列的基本概念2.2 队列的结构2.3 队列的实现方式三、循环队列栈的接口函数实现3.0 循环队列设计的思想来源3.0.1 从数组存放的角度分析3.0.2 从时间复杂度的角度分析3.1 循环队列的三个关键问题及如何解决？3
数据结构（C）：时间复杂度和空间复杂度
zcg3063126760的博客
04-23 1416
言C之言，聊C之识，以C会友，共向远方。各位CSDN的各位你们好啊，这里是持续分享数据结构知识的小赵同学，今天要分享的数据结构知识是时间复杂度和空间复杂度，在这一章，小赵将会向大家展开聊聊何为时间复杂度，何为空间复杂度。✊。
双向链表算法2.13-2.14
10-13
算法2.13是双向链表的插入操作，算法2.14是双向链表的删除操作。 算法2.13的步骤如下： 1. 创建一个新节点，并将其关键字设置为要插入的值。 2. 将新节点的next指针指向当前节点的next节点。 3. 将新节点的prev指针指向当前节点。 4. 将当前节点的next节点的prev指针指向新节点。 5. 将当前节点的next指针指向新节点。 算法2.14的步骤如下： 1. 将要删除的节点记为x。 2. 将x的prev节点的next指针指向x的next节点。 3. 将x的next节点的prev指针指向x的prev节点。 4. 释放x节点的内存空间。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值