数据结构--单链表的c语言实现（超详细注释/实验报告）

最新推荐文章于 2024-04-16 17:17:01 发布
最新推荐文章于 2024-04-16 17:17:01 发布
阅读量1.4w 收藏 269
点赞数 60
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_of_grass/article/details/120473998
版权

数据结构–单链表的c语言实现（超详细注释/实验报告）

知识小回顾

在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序和物理顺序是一致的。而链表则不然，链表是用一组任意的存储单元来存放线性表的结点，这组储存单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此链表中结点的逻辑顺序和物理顺序不一定相同。为了正确地表示结点间的逻辑关系，必须存储线性表的每个数据元素值的同时，存储知识其后继结点的地址（位置）信息，这两部分信息组成的存储映像成为结点（Node）。

实验题目

实现单链表表各种基本运算

实验目的

  1. 熟悉将算法转换为程序代码的过程；
  2. 熟练掌握顺序表的基本运算：头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素、删除指定元素等。

实验要求

  1. 以单链表表作为存储结构；
  2. 实现单链表上的数据元素的头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素、删除指定元素等操作。

实验内容和实验步骤

1）需求分析

以菜单的形式作为用户与程序的接口，用户输入菜单号来实行相应的操作。

2）概要设计

设计几个函数来实现初始化、头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素和删除指定元素的功能，然后再主函数中调用函数来实现操作。

3）详细设计

导入相关的库

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

单链表的存储结构。
注意：LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的。
通常习惯上用LinkList说明指针变量，强调它是某个单链表的头指针变量。
such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,* LinkList;
/*LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的。
通常习惯上用LinkList说明指针变量，强调它是某个单链表的头指针变量。
such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。*/

初始化单链表

//初始化单链表
void Init_LinkList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//建立头结点
    (*L)->next=NULL;//建立空的单链表
    //注意：L是指向单链表头结点的指针，用来接收主程序中带初始化单链表的头指针变量的地址，
    //*L相当于主程序中带初始化单链表的头指针变量。
}

头插法建表（逆序建表法）
算法思想：从一个空表开始，每次读入数据，生成新结点，将读入数据存放到新结点的数据域中，然后将新节点插入到当前链表的表头结点之后，直至读入结束标志为止。

//用头插法建立单链表
void CreateFromHead(LinkList L)
{
    //L是带头结点的空链表头指针，通过键盘输入表中个元素值，利用头插法建单链表L
    Node *s;//s为只想单链表中结点的指针变量
    char c;
    int flag=1;
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node *)malloc(sizeof(Node));//建立新的结点
            s->data=(int)c;//给s赋值
            s->next=L->next;//把s变成头结点的后一个，后面的话，新的s都是L的后一个，这样也就导致了逻辑顺序和输入元素顺序相反
            L->next=s;
        }
        else flag=0;
    }
}

尾插法建表（顺序）
算法思想：将新节点插到前单链表的表尾上。为此需要增加一个尾指针r，使之只想当前单链表的表尾。

//尾插法建表
void CreateFromTail(LinkList L)
{
    Node *r,*s;//一个动态的尾指针r
    int flag=1;
    r=L;
    char c;
    while(flag)
    {
        c=getchar();
       // printf(" ");
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=(int)c;
            r->next=s;
            r=s;//r始终是在最后的
        }
        else
        {
            flag=0;
            r->next=NULL;//将最后一个结点的next链域设为空，表示链表的结束
        }
    }
}

按序号查找元素。
算法思想：在单链表中，由于每个系欸但的存储位置都放在其前一结点的next域中，所以即使知道被访问结点的序号i，也不能像顺序表那样直接按序号i访问以为数组中的相应元素，实现随机存取，而只能从来链表的头指针出发，顺链域next逐个结点往下搜索，直至搜索到第i个结点为止。

//在单链表L中查找第i个结点
Node* Get(LinkList L,int i)
{
    int j;
    Node *p;
    if(i<0)
        return NULL;
    p=L;
    j=0;//j是一个计数器，用来与i比较
    while((p->next!=NULL)&&(j<i))//判断条件为：到达表尾或等于要查找的结点
    {
        p=p->next;
        j++;
    }
    if(i==j)
        return p;
    else
        return NULL;
}

按值查找元素。
算法思想：从单链表的头指针指向的头结点出发，顺链逐个将结点值和给定值 e e e作比较，打印出查找结果。

//在单链表中查找值为x的结点
int Locate(LinkList L,int x)
{
    LinkList p;
    int j=1;
    p=L->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
        j++;
    }
    if(p)
    {
        printf("%d在链表中，是第%d个元素",p->data-48,j);//由于是ascii，所以-48
    }
    else
    {
        printf("该数值不在链表里。\n");
        return 0;
    }
}

求单链表的长度。
算法思想：采用“数结点”的方法求出带头结点单链表的长度。即从“头”开始“数”（p=l->next）,用指针p依次指向各个结点，并附设计数器j技术，一直“数"到最后一个结点（p->next==NULL），从而得到单链表的长度。

//求单链表的长度
int ListLength(LinkList L)
{
    Node *p;
    p=L->next;
    int j=0;//计数器j
    while(p!=NULL)
    {
        p=p->next;
        j++;
    }
    printf("%d",j);
    return 0;
}

单链表插入操作。
算法思想：

  1. 查找：在单链表中找到第i-1个结点，并由指针p表示。
  2. 申请：申请新结点s，将其数值域的值置为e。
  3. 插入：尾插法插入。
//单链表插入操作
int Insert_LinkList(LinkList L,int i,char x)
{
    Node *p,*s;
    p=Get(L,i-1);//这是一个小细节，如果设为i的话就不能实现在第1个元素前面插入的操作了
    if(p==NULL)
    {
        printf("参数i输入有误！\n");
        return 0;
    }
    else
    {
        //其实就是尾插法
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        s->next=p->next;
        p->next=s;
        return 1;
    }
}

单链表删除操作。
算法思想：

  1. 查找：通过计数方式找到第i-1个基点，并由pre指示。
  2. 删除第i个结点并释放空间。
//单链表删除操作
int Delete_LinkList(LinkList L,int i)
{
    //在带头结点的单链表L中删除第i个元素
    Node *pre,*r;
    int k;
    pre=L;k=0;
    while(pre->next!=NULL&&k<i-1)
    {
        pre=pre->next;
        k++;
    }
    if(pre->next==NULL)
    {
        printf("删除结点的位置i不合理!\n");
        return 0;
    }
    r=pre->next;//r指向要删除的第i个结点
    pre->next=r->next;//第i个结点前的结点的后一个结点变成第i个结点后一个结点
    free(r);//释放r
    return 1;
}

显示单链表。
算法思想：顺着指针一个一个地打印。

//display单链表
void Display_LinkList(LinkList L)
{
    //printf("display调用开始\n");
    Node *p;
    ElemType s;
    p=L;
    while(p->next)
    {
        //p=p->next;
        printf("%c  ",p->next->data);//由于前面是getchar（），所以%c
        //printf("  ");
        p=p->next;
    }
    //printf("display调用结束\n");
}

主函数，用一种“菜单”的形式使单链表的操作更加地清晰地展示出来。
主函数1
主函数2

int main()
{


    LinkList L;
    ElemType e,x;
    int i=1,k,j;
    Init_LinkList(&L);
    printf("尾插法建立单链表如下：\n(输入规则：一个数字一个数字地输入，不用加空格和回车，空格和回车也会被当作是一个字符，结束的时候请输入'$')\n");
    CreateFromTail(&L);
    system("cls");//清屏
    while(i)//保证一直进行
    {
        printf("\n现在的链表:  ");
        Display_LinkList(&L);
        printf("\n-------------------------------------\n");
        printf("             Main Menu         \n");
        printf("    1   在单链表中查找第i个结点    \n");
        printf("    2   在单链表中查找值为key的结点   \n");
        printf("    3   求单链表的长度   \n");
        printf("    4   单链表插入(在第i个结点插入e)   \n");
        printf("    5   单链表删除操作   \n");
        printf("    6   清屏   \n");
        printf("    0   结束程序      \n");
        printf("--------------------------------------\n");
        printf("请输入你选择的菜单号<1, 2, 3, 4, 5, 6, 0>:\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            printf("请输入要查找的结点：");
            scanf("%d",&x);
            Node *p1;
            p1=Get(&L,x);
            //printf("%d",p1->data-48);
            printf(p1);
            printf("\n");
            break;
        case 2:
            printf("请输入要查找的值x：");
            scanf("%d",&x);
            Locate(&L,x+48);
            printf("\n\n");
            break;
        case 3:
            printf("长度为");
            //ListLength(&L);
            int p3=ListLength(&L);
            //printf(ListLength(&L));
            //Display_LinkList(&L);
            //printf("%d",p3);
            printf("\n\n");
            break;
        case 4:
            printf("要插入到哪个结点前？\n");
            int i;
            scanf("%d",&i);
            //ElemType e;
            int e;
            printf("要插入哪个值呢？\n");
            scanf("%s",&e);
            Insert_LinkList(&L,i,e);
            printf("\n\n");
            break;
        case 5:
            printf("要删除到哪个结点呢？\n");
            int ii;
            scanf("%d",&ii);
            ElemType ee;
            Delete_LinkList(&L,ii);
            //Display_LinkList(&L);
            printf("\n\n");
            break;
        case 6:
            system("cls");
            break;
        case 0:
                exit(0);
                break;
        default:
            printf("输入有误~");
        }
    }
return 0;
}

4）调试分析

遇到的问题及解决方法
  • 有很多细节需要好好琢磨和调试
算法的时空分析
  • 都是比较基础的操作，没有涉及很复杂的算法，故时空复杂度也还不算很大。
实验结果

实验结果很不错，所有操作都能正常执行，并且自己加入了“清屏”选项，使得界面更加的整洁。

实验总结

这是第二个数据结构的代码实现，这一次就没有直接照着实验指导敲了，是结合教材和实验指导以及同学的代码写出来的，这次写完之后收获很大！多多重复，百炼成钢！

最后附上完整的代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//用typedef 给int定义个名字为ElemType，意思是表中元素的type
typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,* LinkList;
/*LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的
。通常习惯上用LinkList说明指针变量，强调它是某个单链表的头
指针变量。such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。*/

//初始化单链表
void Init_LinkList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//建立头结点
    (*L)->next=NULL;//建立空的单链表
    //注意：L是指向单链表头结点的指针，用来接收主程序中带初始化单链表的头指针变量的地址，
    //*L相当于主程序中带初始化单链表的头指针变量。
}

//用头插法建立单链表
void CreateFromHead(LinkList L)
{
    //L是带头结点的空链表头指针，通过键盘输入表中个元素值，利用头插法建单链表L
    Node *s;//s为只想单链表中结点的指针变量
    char c;
    int flag=1;
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node *)malloc(sizeof(Node));//建立新的结点
            s->data=(int)c;//给s赋值
            s->next=L->next;//把s变成头结点的后一个，后面的话，新的s都是L的后一个，这样也就导致了逻辑顺序和输入元素顺序相反
            L->next=s;
        }
        else flag=0;
    }
}

//尾插法建表
void CreateFromTail(LinkList L)
{
    Node *r,*s;//一个动态的尾指针r
    int flag=1;
    r=L;
    char c;
    while(flag)
    {
        c=getchar();
       // printf(" ");
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=(int)c;
            r->next=s;
            r=s;//r始终是在最后的
        }
        else
        {
            flag=0;
            r->next=NULL;//将最后一个结点的next链域设为空，表示链表的结束
        }
    }
}

//在单链表L中查找第i个结点
Node* Get(LinkList L,int i)
{
    int j;
    Node *p;
    if(i<0)
        return NULL;
    p=L;
    j=0;//j是一个计数器，用来与i比较
    while((p->next!=NULL)&&(j<i))//判断条件为：到达表尾或等于要查找的结点
    {
        p=p->next;
        j++;
    }
    if(i==j)
        return p;
    else
        return NULL;
}

//在单链表中查找值为x的结点
int Locate(LinkList L,int x)
{
    LinkList p;
    int j=1;
    p=L->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
        j++;
    }
    if(p)
    {
        printf("%d在链表中，是第%d个元素",p->data-48,j);//由于是ascii，所以-48
    }
    else
    {
        printf("该数值不在链表里。\n");
        return 0;
    }
}

//求单链表的长度
int ListLength(LinkList L)
{
    Node *p;
    p=L->next;
    int j=0;//计数器j
    while(p!=NULL)
    {
        p=p->next;
        j++;
    }
    printf("%d",j);
    return 0;
}

int Insert_LinkList(LinkList L,int i,char x)
{
    Node *p,*s;
    p=Get(L,i-1);//这是一个小细节，如果设为i的话就不能实现在第1个元素前面插入的操作了
    if(p==NULL)
    {
        printf("参数i输入有误！\n");
        return 0;
    }
    else
    {
        //其实就是尾插法
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        s->next=p->next;
        p->next=s;
        return 1;
    }
}

//单链表删除操作

int Delete_LinkList(LinkList L,int i)
{
    //在带头结点的单链表L中删除第i个元素
    Node *pre,*r;
    int k;
    pre=L;k=0;
    while(pre->next!=NULL&&k<i-1)
    {
        pre=pre->next;
        k++;
    }
    if(pre->next==NULL)
    {
        printf("删除结点的位置i不合理!\n");
        return 0;
    }


    r=pre->next;
    pre->next=r->next;
    //e=r;
    free(r);
    return 1;

}

//display单链表
void Display_LinkList(LinkList L)
{
    //printf("display调用开始\n");
    Node *p;
    ElemType s;
    p=L;
    while(p->next)
    {
        //p=p->next;
        printf("%c  ",p->next->data);
        //printf("  ");
        p=p->next;
    }
    //printf("display调用结束\n");
}




int main()
{
    LinkList L;
    ElemType e,x;
    int i=1,k,j;
    Init_LinkList(&L);
    printf("尾插法建立单链表如下：\n(输入规则：一个数字一个数字地输入，不用加空格和回车，空格和回车也会被当作是一个字符，结束的时候请输入'$')\n");
    CreateFromTail(&L);
    system("cls");
    while(i)//保证一直进行
    {
        printf("\n现在的链表:  ");
        Display_LinkList(&L);
        printf("\n-------------------------------------\n");
        printf("             Main Menu         \n");
        printf("    1   在单链表中查找第i个结点    \n");
        printf("    2   在单链表中查找值为key的结点   \n");
        printf("    3   求单链表的长度   \n");
        printf("    4   单链表插入(在第i个结点插入e)   \n");
        printf("    5   单链表删除操作   \n");
        printf("    6   清屏   \n");
        printf("    0   结束程序      \n");
        printf("--------------------------------------\n");
        printf("请输入你选择的菜单号<1, 2, 3, 4, 5, 6, 0>:\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            printf("请输入要查找的结点：");
            scanf("%d",&x);
            Node *p1;
            p1=Get(&L,x);
            //printf("%d",p1->data-48);
            printf(p1);
            printf("\n");
            break;
        case 2:
            printf("请输入要查找的值key：");
            //char key;
            scanf("%d",&x);
            //Node *p2;
            Locate(&L,x+48);
            printf("\n\n");
            break;
        case 3:
            printf("长度为");
            //ListLength(&L);
            int p3=ListLength(&L);
            printf("\n\n");
            break;
        case 4:
            printf("要插入到哪个结点前？\n");
            int i;
            scanf("%d",&i);
            int e;
            printf("要插入哪个值呢？\n");
            scanf("%s",&e);
            Insert_LinkList(&L,i,e);
            printf("\n\n");
            break;
        case 5:
            printf("要删除到哪个结点呢？\n");
            int ii;
            scanf("%d",&ii);
            ElemType ee;
            Delete_LinkList(&L,ii);
            printf("\n\n");
            break;
        case 6:
            system("cls");
            break;
        case 0:
                exit(0);
                break;
        default:
            printf("输入有误~");
        }
    }
return 0;
}
Dream of Grass
关注
  • 60
    点赞
  • 踩
  • 269
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
数据结构课程设计-导游系统的C语言实现（95分以上项目）.zip
01-12
数据结构课程设计-导游系统的C语言实现（95分以上项目）.zip 该项目是个人课程设计项目源码，评审分达到95分以上，都经过严格调试，确保可以运行！放心下载使用。 数据结构课程设计-导游系统的C语言实现（95分以上...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
《数据结构与算法》实验报告---单链表
m0_72056916的博客
12-20 3146
单链表实验报告包含实验源代码，实验运行结果，算法描述，算法流程图.......
【c语言篇】每日一题-pta-实验11-2-8 单链表结点删除
clriszjgson的博客
03-17 345
【代码】【c语言篇】每日一题-pta-实验11-2-8 单链表结点删除。
单链表实验报告.doc
03-10
单链表的基本操作 1.实验题目 问题描述：实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除 等单链表的基本操作。通过代码的编写理解并掌握单链表的过程编写以及作用。 2.实验要求 （1）依次从键盘读入数据，建立一个单链表并将单链表的初始化设置为空； （2）通过操作选择，输出单链表中的数据元素 （3）显示单链表的长度； （4）根据指定条件能够查找出元素和修改元素； （5）实现在指定位置插入和删除元素的功能 （6）显示操作后的结果 3.算法设计 （1）用到的结构（逻辑结构、存储结构） 逻辑结构：线性结构 存储结构：带头结点的单链表 （2）算法设计思路 定义结点类型LNode，每个结点包括数据域data和指针域next。定义头指针LinkList 。编写如下函数： 1、createlist(LinkList &L)；用尾插法创建一个带头结点的单链表。 2、print(LinkList L)；输出该单链表中的数据元素。 3、ListLength(LinkList L)；求该单链表的长度。 4、GetElem(LinkList &L,int i,ElemType &e)；查找第i个元素。 5、SetElem(LinkList &L,int i,ElemType m)；修改第i个元素。 6、ListInsert (LinkList &L, int i, ElemType e )；在第i个元素前插入一个元素。7、ListDelete(LinkList &L,int i,ElemType &e2)；删除第i个元素。 8、main()；通过case结构来调用createlist(LinkList &L)、GetElem(LinkList &L,int i,ElemType &e)、SetElem(LinkList &L,int i,ElemType m)、ListInsert (LinkList &L, int i, ElemType e )、ListDelete(LinkList &L,int i,ElemType &e2) 4.调试和测试 调试过程总结经过多次调试，本程序能很好的完成实验要求的各项功能。给出几组测 试数据及实验结果： 4.1 系统界面 4.2 创建带头结点的单链表 （先输入单链表整数，每输入完一个整数后按回车键，数据输入完后以0结束） 4.3 打印链表中的数据 4.4 打印链表长度 4.5 按位置取元素 4.6 修改链表中的元素 4.7 插入结点 4.8 按结点位置编号删除结点 4.8 显示做了修改后的链表元素： 5.实验总结 对比这次试验，在上机的时候明显感觉到比之前更加有思路，能够很好地找个关键性 的语句对程序进行修改，这次试验虽然说比上次好，但是也暴漏出了许多的缺陷，在编 写的时候，感觉整个流程都挺对，但是就是运行不出来，或者是不能够实现原有的功能 ，通过与同学的交流，然后慢慢地参照课本才将本次试验很好地完成。 6.附录（源程序） #include<stdio.h> #include<conio.h> #include"stdafx.h" #define OK 1 #define ERROR 0 typedef char ElemType; typedef int Status; typedef struct LNode { ElemType data; LNode *next; } LNode,*LinkList; Status createlist(LinkList &L) //尾插法创建带头结点的单链表 { int ch; L=new LNode; L->next=NULL; printf("请输入单链表中的数据:"); scanf("%d", &ch); LinkList r=L; while(ch!=0) { LinkList p=new LNode; p->data=ch; p->next=NULL; r->next=p; r=p; scanf("%d", &ch); } return OK; } void print(LinkList L) //输出单链表 { LinkList p=L->next; printf("单链表为：\n"); while(p) { printf("%2d",p->data); p=p->next; }} Status ListLength(LinkList L) //求单链表的长度 { int k=0; LinkList p=L->next; while(p){ k++; p=p->next;} printf("\n"); printf("单链表的长度为 %d:" , k); printf("\n"); return k; } Status GetElem(Lin
数据结构 单链表操作实验报告
06-13
单链表操作实验报告 单链表插入、删除、查找等操作的程序。 数据结构
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构学习记录连载3（链表的学习）
BruceWoo的专栏
10-18 1021
基本要求：1) 用模板方法建立链表的结点类ListNode和单链表类LinList，编写程序实现向单链表插入100整数，然后，以插入次序删除这100个整数。提高要求：1) 简单修改程序，将单链表类LinList改为双向循环链表类。向双向循环链表插入100字符，然后，以插入次序删除这100个字符。2) 编写函数实现单链表类LinList的对象B连接到单链表类LinList的对象A的尾
基于单链表实现直接插入排序算法详解
sunnyoldboy博客
09-26 7717
插入排序属于稳定排序法，是一种常用的排序算法。直接插入排序算法可以利用静态数组来实现，也可以使用静态链表或者单链表来实现。本文给出了直接插入算法的单链表实现方法。
C语言实现单链表
m0_60447315的博客
03-20 1808
📋 个人简介 💖 作者简介：大家好，我是菀枯😜 🎉 支持我：点赞👍+收藏⭐️+留言📝 💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️ 一.为什么使用链表 在学习链表以前，我们存储数据用的方式就是数组。使用数组的好处就是便于查找数据，但缺点也很明显。 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 为了解决上述的问题，我们就可以使用链表来存储数据。 二.链表的概念 概念：链表是一种物理存储结构上非连续、
数据结构-动态顺序表的实现（含全部代码）
qq_45967533的博客
03-07 1533
本篇的内容是使用C语言实现一个动态顺序表 文章目录顺序表的概念及结构动态顺序表的接口实现初始化接口销毁接口打印接口检查是否增容接口尾插接口头插接口尾删接口头删接口查找接口在指定位置插入元素接口删除指定位置数据接口修改指定位置元素接口动态顺序表代码 顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 我们可以把顺序表理解为一个数组 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。
GridView控件数据绑定
sir_hanhanhan的博客
10-21 550
GridView中平常在编辑列中绑定数据 数据少的话用这种方法 还是比较简单的，但倘若你的数据库中数据比较多的话，最好还是选择数据源进行数据绑定 首先选择数据源然后新建数据源之后选择数据库点击确定 新建连接 输入数据库名之后选择数据库名称点击确定 之后开始编写你要查询的数据 如果你要绑定的数据源比较多的话 我还是比较倾向这种 ...
C#程序开发范例宝典（第2版）.part08
11-12
一部久享盛誉的程序开发宝典。精选570个典型范例，全面覆盖实用和热点技术，涉及面广，实用性强源于实际项目开发，帮助读者短时间掌握更多实用技术，提高编程水平范例经过精心编排，重点、难点突出，易学易懂书后附录提供快速索引，即查、即学、即用。 第１章 窗体与界面设计 1 1.1 菜单应用实例 2 实例001 带历史信息的菜单 2 实例002 菜单动态合并 3 实例003 像开始菜单一样漂亮的菜单 4 实例004 任务栏托盘菜单 4 实例005 可以拉伸的菜单界面 5 实例006 级联菜单 6 1.2 工具栏设计 6 实例007 带背景的工具栏 7 实例008 浮动工具栏 7
C语言顺序表
12-08
C语言，顺序表的构建和简单操作。顺序表 //定义结构类型 typedef struct list //构建一个空线性表 void CreateList(List *lst, int maxsize) //若线性表为空，则返回TURE，否则返回FALSE BOOL IsEmpty(List lst) //若线性表已满，则返回TURE，否则返回FALSE BOOL IsFull(List lst) //移除所有元素，线性表为空表 void Clear(List *lst) //若线性表未满且0<=pos<=n，则原表中位置在pos及其以后的所有元素后移一位，元素x插在位置pos处，并且函数返回TURE，否则返回FALSE BOOL Insert(List *lst, int pos, int x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，从原表中移去该元素，表中pos之后所有元素前移一位，并且函数返回TURE，否则返回FALSE BOOL Remove(List *lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，并且函数返回TURE，否则返回FALSE BOOL Retrive(List lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素值被x替代，并且函数返回TURE，否则返回FALSE BOOL Replace(List *lst, int pos, int x) //输出顺序表 void PrintList(List lst,int maxsize)
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
数据结构-单链表删除绝对值相同的元素-c语言代码
11-07
单链表删除绝对值相同的元素
【数据结构】红黑树
最新发布
muyuteacher的博客
04-16 620
红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，它在每个节点上增加了一个额外的属性，即颜色，可以是红色或黑色。通过满足一定的约束条件，红黑树能够保持较佳的平衡性，从而保证基本的操作（插入、删除、查找）的时间复杂度为 O(log n)。红黑树常见的应用包括标准库中的关联容器（例如C++中的std::map和std::set）、数据库的索引结构、以及在操作系统中的进程调度等方面。
【数据结构】复习题(二)
2302_76305195的博客
04-13 745
设一组初始记录关键字序列为（25,50,15,35,80,85,20,40,36,70），其中含有5个长度为2的有序表，则用归并排序的方法对该记录关键字序列进行一趟归并排序后的结果为（）。1.计算如图所示的AOE网中各顶点所表示的事件的发生时间ve(j),vl(j),各边所表示的活动的开始时间e(i),e(j) ,并找出其关键路径。设连通图G中的边集E={(a,(e,d),(d,f),(f, c)}则从顶点a出发可以得到一种深度优先遍历的顶点序列为（）。⑤计算活动的时间余量 l(i)-e(i)
c语言数据结构--单链表 算法函数的实现(查找位序)
09-04
单链表是一种常见的数据结构，它由一个或多个节点组成，每个节点包含一个数据域和一个指针域，指针域指向下一个节点。 实现单链表的查找位序算法函数需要以下步骤： 1. 定义一个指针p指向链表的头节点，并定义一个变量count，用于计数。 2. 从头节点开始，遍历链表，当p指向某个节点时，计数器count加1。 3. 如果p指向的节点的数据与目标数据相等，则返回当前的计数器count，即为目标数据的位序。 4. 如果p指向的节点不是目标数据，则将p指向下一个节点，重复步骤3。 5. 如果遍历完链表后仍未找到目标数据，则返回-1，表示未找到。 下面是C语言实现单链表查找位序算法函数的代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义单链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域 } Node; // 查找位序的算法函数 int findPosition(Node* head, int target) { Node* p = head; // 指向头节点 int count = 0; // 计数器初始化为0 while (p != NULL) { count++; // 计数器加1 if (p->data == target) { return count; // 找到目标数据，返回当前计数器的值 } p = p->next; // 指向下一个节点 } return -1; // 遍历完链表未找到目标数据，返回-1 } int main() { // 创建链表 Node* head = (Node*)malloc(sizeof(Node)); head->data = 1; // 头节点数据为1 Node* node1 = (Node*)malloc(sizeof(Node)); node1->data = 2; Node* node2 = (Node*)malloc(sizeof(Node)); node2->data = 3; head->next = node1; node1->next = node2; node2->next = NULL; // 查找位序示例 int target = 3; // 目标数据为3 int position = findPosition(head, target); if (position != -1) { printf("目标数据 %d 的位序为 %d\n", target, position); } else { printf("未找到目标数据 %d\n", target); } // 释放链表内存 free(node2); free(node1); free(head); return 0; } ``` 在上述代码中，我们首先定义了一个指向头节点的指针p和一个计数器count，然后使用while循环遍历链表。当p指向某个节点时，计数器加1，并判断该节点的数据是否与目标数据相等。如果找到了目标数据，则返回当前计数器的值，即为目标数据的位序。如果遍历完链表仍未找到目标数据，则返回-1表示未找到。最后在主函数中演示了调用该算法函数的示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值