数据结构 单链表（C语言）

最新推荐文章于 2023-03-17 14:55:38 发布
最新推荐文章于 2023-03-17 14:55:38 发布
阅读量820 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46499906/article/details/105283838
版权

数据结构 单链表

一、 线性表
1.数据结构中，线性结构习惯称为线性表，线性表是最简单也是最常用的一种数据结构。
2.线性表可以表示为：（A_1,A_2,A_3,…,A_N）,其中，A_i（i=1,2,…,n）是线性表的数据元素，也称为线性表的一个结点，同一线性表中的数据元素必定具有相同的特性，即属于同一数据对象。数组、矩阵、向量等都是线性表。大小为0的表为空表。
3.对于除空表外的任何表，我们说A_(i+1)后继A_i并且称A_(i-1)（i<N）前驱A_i（i>1）。表中的第一个元素是A_1，而最后一个元素是A_N。不定义A_1的前驱元，也不定义A_N的后继元。元素A_i在表中的位置为i。

二、链表
1.链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。最后一个结点的指针域为空，用NULL（空指针）表示。用一个单独的指针储存第一个结点的地址（或者头结点的地址），该指针被称为头指针。头指针指向链表中的第一项（或者头结点）。
在这里插入图片描述

单链表的结点结构

2.单链表
带头结点的单链表：在单链表的第一个结点之前附设一个头结点，此时头指针指向头结点。
在这里插入图片描述

3.单链表的存储结构定义:

#define SIZE 20
typedef struct student{
        char num[SIZE];      //学生的学号
        char name[SIZE];     //学生的姓名
        int  grade;          //学生的成绩
}Item;
typedef struct node{
        Item item;           //数据域
        struct node * next;  //指针域，指向链表中的下一个结构
}Node;
typedef Node * List;

该定义中通过typedef为某一类型自定义名称。用Item作为struct student的别名（这样做更加通用），如果以后需要其他数据形式的链表，可以重新定义Item类型。用Node作为struct node的别名，单链表的结点类型名是Node。用List作为Node *的别名，List作为该类型(Node)的指针名，若有List L;则表示创建了一个链表（L表示指向单链表的头指针，即表示单链表），而不是一个指向结点的指针或一个结构，因为单链表相当于一个指针，我们只关注于他的头指针。

4.单链表的初始化：

void InitList(List * plist)  //形参:指向List类型的指针
{
     *plist=(Node *)malloc(sizeof(Node));   //建立头结点
     (*plist)->next=NULL;                   //头结点的指针域设置为NULL
}
带头结点的单链表初始化 
void InitList(List * plist)  //形参:指向List类型的指针
{
     *plist=NULL;     //链表的头指针指向NULL
}
不带头结点的单链表初始化

带头结点的单链表初始化前/后：（初始化后头指针保存头结点的地址）

在这里插入图片描述
在这里插入图片描述
头指针：使用头指针来标识一个链表，因为我们得知道链表的存储地址才能使用他，而头指针则保存着链表的头结点地址或者链表的首元结点地址，通过头指针可遍历整个链表。（头指针不可缺少）
头结点：在单链表的首元结点前附加一个结点，称为头结点。头结点的数据域可以不设任何信息，也可以记录表长等相关信息。他的存在是为了方便操作(如在首元结点前插入和删除结点等)，其可有可无。
首元结点：第一个元素的结点，他是头结点后边的第一个结点。

5.单链表的创建
①：头插法创建单链表：
算法描述：初始为一个空单链表，不断在头结点后面插入新结点，得到非空单链表。

bool CreateFromHead(List * plist,Item item)  //形参:1.指向List类型的指针 2.装载数据域的结构变量item
{
     Node * pnew;           //定义一个结构指针pnew
     Node * pend=*plist;    //定义一个结构指针pend，并赋予其头结点的地址
     pnew=(Node *)malloc(sizeof(Node));   //申请一个结点的空间，并将其地址赋给结构指针pnew
     if(pnew==NULL)   //若申请失败，则返回false
        return false;
     Copy(item,pnew);    //Copy()用于处理数据域，可以根据程序自定义处理数据域的方式
     pnew->next=pend->next;   //将头结点指针域的值赋给新结点的指针域
     pend->next=pnew;         //将头结点的指针域更新为新结点地址
     return true;           //若操作成功，则返回true
}

在这里插入图片描述
②：尾插法创建单链表：
算法描述：初始为一个空单链表，不断在链表最后插入新结点，得到一个非空单链表。

bool CreateFromTail(List * plist,Item item)  //形参:1.指向List类型的指针 2.装载数据域的结构变量item
{
     Node * pnew;            //定义一个结构指针pnew
     Node * pend=*plist;     //定义一个结构指针pend，并赋予其头结点的地址
     pnew=(Node *)malloc(sizeof(Node));  //申请一个结点的空间，并将其地址赋给结构指针pnew
     if(pnew==NULL)    //若申请失败，则返回false
        return false;
     Copy(item,pnew);  //Copy()用于处理数据域，可以根据程序自定义处理数据域的方式
     pnew->next=NULL;  //新结点的指针域指向NULL
     while(pend->next!=NULL)  //遍历链表，找到链表的表尾
          pend=pend->next;
     pend->next=pnew;         //把新结点的地址赋予表尾结点的指针域
     return true;             //若操作成功，则返回true
}

在这里插入图片描述
注意：由图可知：①头插法相对简便，但插入的数据与插入的顺序相反；
②尾插法操作相对复杂，但插入的数据与插入顺序相同。

6.单链表的查找
①：按值查找：
算法描述：按值查找是指在单链表中查找是否有结点值等于待查找值的结点，若有的话，则返回保存该值的结点地址，否则返回NULL。查找过程从单链表的头指针指向的头结点出发，顺着链表逐个将结点的值和给定值作比较。

Node * Locate(List * plist,const char number[])   //形参:1.指向List类型的指针 2.待查找的值(形式自定义)
{
       Node * temp;          //定义一个结构指针temp
       temp=(*plist)->next;  //从链表的首元结点开始比较
       while(temp!=NULL&&strcmp(temp->item.num,number)!=0)   //遍历链表，未找到待查找的值的结点
          temp=temp->next;   //temp指针后移
       return temp;          //返回结点地址
}

②：按序号查找：要查找表中第i个结点，则需要从单链表的头指针指向的头结点出发，顺着链域(temp->next)扫描，用指针temp指向当前扫描到的结点, 初值指向头结点，用j做计数器，累计当前扫描过的结点数（初值为0），当j==i时，指针temp所指的结点就是要找的第i个结点。

Node * Get(List * plist,int i)     //形参:1.指向List类型的指针 2.链表的第i个结点
{
       Node * temp=*plist;     //定义一个结构指针temp，并赋予其头结点的地址
       int j=0;                //定义一个计数器j
       if(i<=0)                //若i为无效值，则返回NULL
        return NULL; 
       while(temp!=NULL&&j<i)  //若当前结点存在且序号不到i     
       {
           temp=temp->next;    //temp指针后移，移向下一个结点
           j++;                //下一个结点的序号
       }
       return temp;            //返回结点地址
}

7.单链表的删除：
算法描述：删除带头结点的单链表中第i个元素，并将删除的元素通过参数带回。
注意：①：删除第i个元素时要查找第i-1个结点。
②：若找不到第i-1个，则参数i不合法
③：若找到第i-1个，但其后继即第i个不存在，则参数i不合法
④：若找到第i-1个，且其后继存在，则作删除操作。

bool DelList(List * plist,int i,Item * item)  //形参:1.指向List类型的指针 2.链表的第i个结点 3.指向Item类型的指针，带出被删结点的数据域
{
     Node * temp=*plist;  //定义一个结构指针temp，并赋予其头结点的地址
     Node * dele;         //定义一个结构指针dele，用于指向待删结点
     int j=0;             //定义一个计数器j
     if(i<=0)             //若i为无效值，则输出提示语句并返回false
     {
        printf("Remove location illegal!");
        return false;
     }
     while(temp!=NULL&&j<i-1)  //遍历链表，找到第i-1个结点, 使temp指向他 
     {
         temp=temp->next;
         j++;
     }
     if(temp==NULL||temp->next==NULL)  //若第i-1个或第i个结点不存在，则输出提示语句并返回false
     {
         printf("Remove location illegal!");
         return false;
     }
     dele=temp->next;                  //将第i个结点的地址赋予结构指针dele
     temp->next=dele->next;            //将第i+1个结点(i结点的后继)的地址赋予第i-1个结点(i结点的前驱)的指针域
     *item=dele->item;                 //将待删结点的数据域通过指针带出
     free(dele);                       //释放待删结点所占的内存空间 
     return true;                      //若操作成功，则返回true
}

在这里插入图片描述

8.单链表的插入：
算法描述：在单链表第i个位置插入元素。
①：先在单链表中找到第i-1个结点，并将其地址赋予结构指针temp。
②：再建立新结点并将其地址赋予结构指针pnew，其数据域的值为item_。
③：修改第i-1个结点的指针使其指向pnew，然后使pnew结点的指针域指向原第i个结点。

bool InsList(List * plist,int i,Item item_)  //形参:1.指向List类型的指针 2.链表的第i个结点 3.Item类型的变量item，用于为新结点的数据域赋值
{
     Node * temp=*plist;  //定义一个结构指针temp，并赋予其头结点的地址
     Node * pnew;         //定义一个结构指针pnew,用于储存新结点的地址
     int j=0;             //定义一个计数器j
     if(i<=0)             //若i为无效值，则输出提示语句并返回false
     {
        printf("Insert position illegally!");
        return false;
     }
     while(temp!=NULL&&j<i-1)  //遍历链表，找到第i-1个结点, 使temp指向他 
     {
         temp=temp->next;
         j++;
     }
     if(temp==NULL)            //若第i-1个不存在，则输出提示语句并返回false
     {
         printf("Insert position illegally!");
         return false;
     }
     pnew=(Node *)malloc(sizeof(Node));  //申请一个结点的空间，并将其地址赋给结构指针pnew
     pnew->item=item_;                   //为新结点的数据域赋值
     pnew->next=temp->next;              //将原第i个结点的地址赋予新结点的指针域
     temp->next=pnew;                    //将新结点的地址赋予第i-1个结点的指针域
     return true;
}

9.单链表的长度：
算法描述：求带头结点单链表的长度。从单链表的第一个结点开始计数，直到链表尾。
注意：若temp从头结点开始,temp为空时,计数器比实际长度大1。

int ListLength(const List * plist)  //形参:指向List类型的指针，由于该函数不修改单链表，使用const修饰符对指针所指向的内容进行保护
{
    Node * temp=(*plist)->next;  //定义一个结构指针temp，并赋予首元结点的地址
    int i=0;                     //定义一个计数器i
    while(temp!=NULL)            //遍历单链表
    {
        i++;
        temp=temp->next;
    }
    return i;                    //返回单链表的长度
}

10.单链表的输出
算法描述：通过遍历单链表，输出每个结点的数据域。(输出形式由数据域的类型决定)

void output(const List * plist)  //形参:指向List类型的指针，由于该函数不修改单链表，使用const修饰符对指针所指向的内容进行保护
{
     Node * temp;          //定义一个结构指针temp
	 temp=(*plist)->next;  //赋予temp首元结点的地址
	 while(temp!=NULL)     //遍历单链表
	 {
	     printf("%-10s %-10s %-10d\n",temp->item.num,temp->item.name,temp->item.grade);  //输出形式由数据域的类型决定
	     temp=temp->next;
	 }
}

11.单链表的清除：
算法描述：释放了为链表分配的所有内存，单链表设置为空表。

void EmptyTheList(List * plist)    //形参:指向List类型的指针
{
     Node * psave;                 //定义一个结构指针psave
     psave=(*plist)->next;         //将首元结点的地址赋予结构指针psave
     while((*plist)->next!=NULL)   //头结点的指针域不为NULL(空)做循环
     {
         psave=psave->next;        //更新结构指针psave的指向，第一次:赋予第二结点地址,第二次:赋予第三结点地址...以此类推
         free((*plist)->next);     //释放结点所占的内存空间 
         (*plist)->next=psave;     //更新头结点的指针域，第一次:指向第二节点，第二次:指向第三节点...以此类推
     }
}

在这里插入图片描述

12.总结：
①：链表的大小取决于可用内存量。若尝试为新项分配空间失败，则说明链表已满。
②：函数的参数*plist是一个指向链表的指针，而不是一个链表。
③：遍历链表时，不直接使用头指针。需要重新创建一个新指针。因为如果使用头指针会改变他的指向。程序就找不到链表的开始处了。
④：带头结点的单链表查找（两种）操作、插入操作、删除操作的时间复杂度都是O(n)。这里的前提是想要查找、插入、删除的结点地址未知。因为在做这些操作时，都需要遍历单链表，即做循环。while循环体中的语句频度与被查、插、删的结点在表中的位置有关，若1<=i<=n,则频度为i-1,否则频度为n，即时间复杂度为O(n)。

13.样例：

#include<stdio.h>
#include<stdlib.h>   //包含malloc()函数
#include<string.h>   //包含strcmp()等字符串函数
#include<stdbool.h>  //包含bool类型的头文件

#define SIZE 20

typedef struct student{
        char num[SIZE];      //学生的学号
        char name[SIZE];     //学生的姓名
        int  grade;          //学生的成绩
}Item;
typedef struct node{
        Item item;           //数据域
        struct node * next;  //指针域，指向链表中的下一个结构
}Node;
typedef Node * List;

int ListLength(const List * plist);
void output(List * plist);
void InitList(List * plist);
void EmptyTheList(List * plist);
void Copy(Item item,Node * pnode);
bool CreateFromTail(List * plist,Item item);
bool InsList(List * plist,int i,Item item_);
bool DelList(List * plist,int i,Item * item);
Node * Get(List * plist,int i);
Node * Locate(List * plist,const char number[]);

int main()
{
	List student;    //创建一个头指针
	Item temp;       //用于暂时保存数据域
	Item temp3;      //用于插入结点的数据域
	Node * temp1;    //用于按值查找
	Node * temp2;    //用于按序号查找
	int i,j,k;       //i用于按序号查找   j用于删除操作   k用于插入操作
	char number[SIZE];   //用于按值查找,保存学号

	InitList(&student);
    puts("Enter first student num:");
    while(gets(temp.num)&&temp.num[0]!='#')   //循环输入,直到学号为#
    {
        puts("Enter student name:");
        gets(temp.name);
        puts("Enter student grade:");
        scanf("%d",&temp.grade);
        if(CreateFromTail(&student,temp)==false)  //尾插法创建单链表
        {
            printf("Application memory error!");
            break;
        }
        while(getchar()!='\n')  //处理scanf()遗留在缓冲区的换行符
            continue;
        puts("Enter next student num:");
    }

    printf("Here is the student list:\n");
    output(&student);

    printf("The length of the list is:%d\n",ListLength(&student));

    puts("Please enter student num to find:");
    gets(number);
    temp1=Locate(&student,number);
    printf("Information for students num %s:%s     %s      %d\n"
           ,number,temp1->item.num,temp1->item.name,temp1->item.grade);

    puts("Please enter a serial number to find:");
    scanf("%d",&i);
    temp2=Get(&student,i);
    printf("Information for the serial number is %d:%s     %s      %d\n"
           ,i,temp2->item.num,temp2->item.name,temp2->item.grade);

    puts("Please enter the need to delete the node number:");
    scanf("%d",&j);
    DelList(&student,j,&temp3);
    output(&student);

    puts("Please enter the want to insert into position:");
    scanf("%d",&k);
    InsList(&student,k,temp3);
    output(&student);

    EmptyTheList(&student);
    printf("Bye!");

	return 0;
}

void InitList(List * plist)  //初始化
{
     *plist=(Node *)malloc(sizeof(Node));
     (*plist)->next=NULL;
}

void Copy(Item item,Node * pnode)  //尾插法时处理新结点的数据域
{
     pnode->item=item;
}

bool CreateFromTail(List * plist,Item item)  //尾插法创建单链表
{
     Node * pnew;
     Node * pend=*plist;
     pnew=(Node *)malloc(sizeof(Node));
     if(pnew==NULL)
        return false;
     Copy(item,pnew);
     pnew->next=NULL;
     while(pend->next!=NULL)
          pend=pend->next;
     pend->next=pnew;
     return true;
}

void output(List * plist)   //单链表输出
{
     Node * temp;
	 temp=(*plist)->next;
	 while(temp!=NULL)
	 {
	     printf("%-10s %-10s %-10d\n",temp->item.num,temp->item.name,temp->item.grade);
	     temp=temp->next;
	 }
}

Node * Locate(List * plist,const char number[])   //按值查找
{
       Node * temp;
       temp=(*plist)->next;
       while(temp!=NULL&&strcmp(temp->item.num,number)!=0)
          temp=temp->next;
       return temp;
}

Node * Get(List * plist,int i)   //按序号查找
{
       int j=0;
       Node * temp;
       temp=*plist;
       if(i<=0)
        return NULL;
       while(temp!=NULL&&j<i)
       {
           temp=temp->next;
           j++;
       }
       return temp;
}

bool DelList(List * plist,int i,Item * item)  //单链表删除
{
     Node * temp=*plist;
     Node * dele;
     int j=0;
     if(i<=0)
     {
        printf("Remove location illegal!");
        return false;
     }
     while(temp!=NULL&&j<i-1)
     {
         temp=temp->next;
         j++;
     }
     if(temp==NULL||temp->next==NULL)
     {
         printf("Remove location illegal!");
         return false;
     }
     dele=temp->next;
     temp->next=dele->next;
     *item=dele->item;
     free(dele);
     return true;
}

int ListLength(const List * plist)  //单链表的长度
{
    Node * temp=(*plist)->next;
    int i=0;
    while(temp!=NULL)
    {
        i++;
        temp=temp->next;
    }
    return i;
}

bool InsList(List * plist,int i,Item item_)  //单链表的插入
{
     Node * temp=*plist;
     Node * pnew;
     int j=0;
     if(i<=0)
     {
        printf("Insert position illegally!");
        return false;
     }
     while(temp!=NULL&&j<i-1)
     {
         temp=temp->next;
         j++;
     }
     if(temp==NULL)
     {
         printf("Insert position illegally!");
         return false;
     }
     pnew=(Node *)malloc(sizeof(Node));
     pnew->item=item_;
     pnew->next=temp->next;
     temp->next=pnew;
     return true;
}

void EmptyTheList(List * plist)   //单链表的清空
{
     Node * psave;
     psave=(*plist)->next;
     while((*plist)->next!=NULL)
     {
         psave=psave->next;
         free((*plist)->next);
         (*plist)->next=psave;
     }
}

输出结果：
在这里插入图片描述

No Pain No Gain-
关注
专栏目录
C语言实现顺序表和单链表的基本操作
palepale
09-29 836
在黑框输入数据时出现 “0xC0000005: 写入位置 0xCDCDCDC 时发生访问冲突” 异常，先贴在这咯 #include <stdio.h> #include <stdlib.h> #pragma warning(disable : 4996) #define ListSize 10 #define ListIncrement 3 typedef int LEle...
C语言——线性表及其应用（单链表和顺序表）
悦悦的狗子
12-11 6238
程序要求 1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。 3.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 输入和输出的格式 1.顺序线性表的建立、插入及删除 顺序表 #include<stdio.h&gt...
数据结构【完整代码】之（C语言实现【顺序存储表、单链表】创建、插入、删除、查找、输出、求长度、合并的实现与测试）
Zhou_LC的博客
09-26 1101
本文包含两个文件的代码和一张测试效果图： List.h文件：存储信息：存放函数、结构体、链表、变量名等 achieve.cpp文件：用于测试 效果图：最下方 List.h文件： #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 20 typedef int ElemType; typedef int Stat
单链表（c语言）
qq_52284035的博客
04-16 1120
1、单链表的创建 typedef int DataType; //定义节点 typedef struct LNode { struct LNode *next; DataType data; }LNode,*LinkList; 结构体后面的LNode为定义节点的指针，而*LinkList是定义表头的指针，所以，创建新节点就用LNode来申请空间节点，而创建表头用LinkList（格式为 LinkList L，L为一张表的表头），但LNode也可以定义表头，两种方法都行。 2.初始化链..
【数据结构】顺序表和单链表(C语言版)
weixin_62007227的博客
02-24 1701
一篇文章让你搞懂单链表的基本操作[通过图画轻松掌握] 前言 提示：本篇记录自学《大话数据结构》的链表章节 主要是代码的理解，不会出现很多概念定义 一、顺序存储之顺序表 定义 顺序表也叫(顺序存储结构) ，是一种用一段地址连续的存储单元依次存储线性表的数据元素。 顺序表的示意图 二、线性表的顺序存储结构 #define Max_sz 20 /代表数组最大容量 ty.
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构 单链表 C语言实现
Baron_wu的博客
03-05 930
单链表 单链表 顺序存储线性表 分配方式 分散存储 集中存储 时间性能 查找O(n) 插入删除O(1) 查找O(1) 插入删除O(n) 空间性能 无需分配空间，元素可以无限扩充 分配空间，元素个数有限 c语言代码实现（单链表） // // main.c // 线性表链式存储结构 // // Created by Kinble Wu on 2020/3/2. /...
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
单链表（数据结构C语言版）
07-05
单链表（数据结构C语言版） 链表的创建，插入，删除，排序等操作并建立有菜单，可以选择操作
单链表(C语言版）
最新发布
weixin_74999790的博客
03-17 583
单链表的英文是：Single Linked List（简称：SL,区别于顺序表的 SeqList 或 SQL)//int data;//为结构体指针，是指针，不是结构体，结构体里面不可嵌套结构体 };
使用C语言模拟顺序表和链表
weixin_44788162的博客
10-18 244
顺序表和链表 1.线性表 2.顺序表 3.链表 4.顺序表和链表的区别和联系 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 2....
C语言实现顺序表的创建及基本操作
weixin_43954729的博客
03-21 2万+
今天主要是分享一下我在学习数据结构的顺序表时实现的一些基本操作，以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候，除了要掌握基本操作方法的编写，还要学会对方法进行**实例化**。由于课本上这一部分的内容比较少，我也是查阅了CSDN上的许多文章才明白的。
【数据结构】C语言实现单链表基本操作
weixin_43716338的博客
02-05 3342
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; //单链表的存储结构 typedef struct LNode { ElemType data; struct LNode *next; //next指向自身类型struct LNode *的指
C语言实现单链表的创建及基本操作
weixin_43954729的博客
03-22 4万+
C语言实现单链表的创建及基本操作 往期文章：C语言实现顺序表的创建及基本操作 这次主要是分享一下数据结构中单链表的创建及基本操作，这一部分也是属于比较基础的内容。但是越基础的东西我们越要投入精力去学习，不能眼高手低。我在编写这一部分的内容时就出现了许多错误，这也算是一次查漏补缺的博客吧，下面我们正式开始。 单链表的结构定义 首先我们先来看一下常规定义的单链表，一般情况下会包含数据域和指针域。例...
数据结构与算法--用C语言建立单链表以及其相关操作
m0_70659080的博客
05-17 1193
单链表的建立，增添数据，查找数据，插入数据，删除数据的操作及其C语言代码
数据结构_单链表_c实现(整型数为例)
xuchaoxin1375的博客
09-18 1871
/*实验二 单链表及其应用 线性表及其所有操作也可以使用单链表来实现。单链表由一系列不必在内存中连续的结点组成，每一个结点均含有一个表元素和指向包含该元素后继元的结点的指针链。本实验实现单链表和它的一些相关应用。 （1）实验目的 （1）掌握单链表的组织结构； （2）掌握单链表的基本操作：插入、删除、读取、查找等； （3）掌握上机调试单链表的基本方法。 （2）实验内容 （1）单链表的实现 目标：定义一个可存放整型数据的单链表，并实现其常用算法。 （1）算法填空：根据功能提示，完善下划线处的代码。 （1）单链表
实验2-单链表的建立及操作-数据结构（C语言）
qq_45773423的博客
03-27 8668
实验2 单链表的建立及操作 实验要求 1.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 2.设计一个函数在链表中查找元素x的位置，如果x不在链表中则返回-1。 3.设计一个函数将元素x插入第i个元素的后面。如果i大于链表的长度，则将x插入链表的末尾，如果i小于或等于0，则将x直接插入表头之后。 实验过程及结果 1.基本思路： 定义一个结点的...
数据结构初阶——第三节-- 单链表
蓝天it（让亿万孩子在蓝天下共享优质教育）
04-26 1176
链表
5-数据结构-单链表的初始化（头结点和无头结点）
奔心小韩的博客
01-19 840
单链表的初始化
C语言实现数据结构单链表操作
数据结构中的单链表是一种线性数据结构，它由一系列元素（节点）组成，每个节点包含数据和一个指向下一个节点的指针。在C语言中，我们可以通过定义一个结构体来表示这种数据结构。以下是对单链表的C语言实现的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值