线性表链式存储结构——单链表C语言实现

最新推荐文章于 2021-06-13 21:12:01 发布
最新推荐文章于 2021-06-13 21:12:01 发布
阅读量1.8k 收藏 40
点赞数 16
分类专栏： C语言学习之路 文章标签： 单向链表 C语言实现链表 线性表链式存储结构 链表的插入、删除
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ylzmm/article/details/100328505
版权

记录学习数据结构书籍<<大话数据结构>>的学习笔记，C语言实现单链表

顺序存储结构的最大的缺点就是，插入和删除数据的时候需要进行移动大量的元素。

对于插入或者删除数据约频繁的操作,单链表的效率优势更加的明显。

 

先介绍一些比较基本的概念:

1. 单链表是由一个一个结点组成，所谓结点(包含了一个数据域，一个指针域)。

2. 数据域是存储数据的，而指针域是存储下一个结点的地址的。也就说，在访问下一个结点时，必须通过上一个结点的指针域来获取下一个结点的地址。所以由此我们可以知道，链表的存储实际并不是顺序存储的。

3.通常为了方便，我们会在单链表的第一个结点前附加一个结点，我们称为头结点。头结点的数据域可以存储表的长度信息或者不使用，指针域存储着指向第一个结点的指针。

 

函数实现代码如下:

#include "stdio.h"    
#include "string.h"
#include "ctype.h"      
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */


//链表结构体的定义 
typedef struct Node
{
    ElemType data;          //数据域 
    struct Node *next;      //指针域   结构体指针类型 
}Node;
typedef struct Node *LinkList; /* 定义LinkList 宏替换结构体指针类型*/

//打印输出传入参数 
Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

/* 初始化顺序线性表 */
Status InitList(LinkList *L)      //LinkList *L 这里应该理解为结构体指针的指针了 
{ 
    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 malloc返回一个空类型的指针*/
    if(!(*L)) /* 地址为空时 存储分配失败 */
    { 
        return ERROR;
    } 
    (*L)->next=NULL; /* 指针域为空 */
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)  //传入参数结构体指针 
{ 
    if(L->next)
    { 
        return FALSE;
    } 
    else
    { 
        return TRUE;
    } 
}

/* ************************ 
将单链表整表删除的算法思路: 
1.声明了一个结构体指针p q ,将第一个结点赋值给p 
2.循环操作 (直到最后一个结点的指针域为空为止) 
将下一个结点赋值给q
释放内存p
再将q赋值给p 
************************** */

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)  //传入参数结构体指针的指针 
{ 
	LinkList p,q;           // 定义结构体指针类型 
	p=(*L)->next;           /*  p指向第一个结点 */
	while(p)                /*  没到表尾 表尾为NULL*/
	{
		q=p->next;         //记录下一个结点的地址 
		free(p);           //释放内存 
		p=q;
	}
	(*L)->next=NULL;        /* 头结点指针域为空 */
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}
/* ************************ 
获取链表第i个数据的算法思路
1.声明了一个结构体指针p 来指向链表的第一个结点,初始化j从1开始 
2.当j<i时,遍历链表,p的指针向后继续移动,指向下一个结点
3.若都移动到了链表尾部(为空),都没找到第i个数据,说明第i个结点不存在
4.否则查找成功,返回结点p指向的数据域的数据 
************************** */
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 声明一结点p */
	p = L->next;		/* 让p指向链表L的第一个结点 */
	j = 1;		/*  j为计数器 */
	while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
	{   
		p = p->next;  /* 让p指向下一个结点 */
		++j;
	}
	if ( !p || j>i )
	{ 
		return ERROR;  /*  第i个元素不存在 */
	} 
	*e = p->data;   /*  取第i个元素的数据 */
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到这样的数据元素 */
        { 
                return i;
        } 
        p=p->next;
    }

    return 0;
}

/* ************************ 
单链表第i个数据插入结点的算法思路 
1.声明了一个结构体指针p 来指向链表的第一个结点,初始化j从1开始 
2.当j<i时,遍历链表,p的指针向后继续移动,指向下一个结点
3.若都移动到了链表尾部(为空),都没找到第i个数据,说明第i个结点不存在
4.否则查找成功,生成一个空的结点s
5.将数据元素e复制给s->data;
6.单链表的插入标准语句: s->next=p->next; p->next=s; 
************************** */
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;   
	j = 1;
	while (p && j < i)     /* 寻找第i个结点 */
	{
		p = p->next;
		++j;
	} 
	if (!p || j > i) 
	{
		return ERROR;   /* 第i个元素不存在 */
	}
	s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
	s->data = e;  
	s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
	p->next = s;          /* 将s赋值给p的后继 */
	return OK;
}

/* ************************ 
单链表第i个数据删除结点的算法思路 
1.声明了一个结构体指针p 来指向链表的第一个结点,初始化j从1开始 
2.当j<i时,遍历链表,p的指针向后继续移动,指向下一个结点,不断向后累加 
3.若都移动到了链表尾部(为空),都没找到第i个数据,说明第i个结点不存在
4.否则查找成功,将准备删除的结点p->next赋值给q 
5.将q结点中的数据域中的值赋值给e,作为返回值 
6.释放q结点的内存空间 
************************** */
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i) 
	    return ERROR;           /* 第i个元素不存在 */
	q = p->next;
	p->next = q->next;			/* 将q的后继赋值给p的后继 */
	*e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/* ************************ 
单链表整表创建的算法思路   (通用于头插法和尾插法) 
1.声明了一个结构体指针p 和计数变量i 
2.初始化一个空链表L 
3.让L的头结点的指针指向NULL,创建一个带头结点的单链表 
4.进行循环生成结点 
生成一个新的结点赋给p
随机生成一个数字赋值给p的数据域p->data
将p插入头结点和前一个新节点之间(头插法)
将p插入终端结点的后面(尾插法)
************************** */
/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n) 
{
	LinkList p;
	int i;
	srand(time(0));                         /* 初始化随机数种子 */
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;                      /*  先建立一个带头结点的单链表 */
	for (i=0; i<n; i++) 
	{
		p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */
		p->data = rand()%100+1;             /*  随机生成100以内的数字 */
		p->next = (*L)->next;    
		(*L)->next = p;						/*  插入到表头 */
	}
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                      /* 初始化随机数种子 */
	*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
	r=*L;                                /* r为指向尾部的结点 */
	for (i=0; i<n; i++) 
	{
		p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
		p->data = rand()%100+1;           /*  随机生成100以内的数字 */
		r->next=p;                        /* 将表尾终端结点的指针指向新结点 */
		r = p;                            /* 将当前的新结点定义为表尾终端结点 */
	}
	r->next = NULL;                       /* 表示当前链表结束 */
}

测试代码:

void main(void)
{        
    LinkList L;       //定义一个结构体变量 
    ElemType e;       //定义一个数据域的变量 
    Status i;
    int j,k;
    i=InitList(&L);   //初始化线性表
    printf("初始化L后：ListLength(L)=%d\n",ListLength(L));   //返回线性表中的个数 
    for(j=1;j<=5;j++)
    { 
        i=ListInsert(&L,1,j);   //向线性表中插入元素 
    } 
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L);           //依次输出线性表L中的每个元素 

    printf("ListLength(L)=%d \n",ListLength(L));   //返回线性表中的个数 
    i=ListEmpty(L);      //判断链表是否为空 
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);     //将链表置为空表 
    printf("清空L后：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
    { 
    	ListInsert(&L,j,j);  //向链表中插入数据 
    } 
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L);     //依次输出线性表L中的每个元素 

    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);  //在链表头插入数据 0 
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L);      
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);    //获取链表中第5个元素的值,并将值用e进行返回 
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);    //返回L中第1个与e满足关系的数据元素的位序
        if(k)
        { 
            printf("第%d个元素的值为%d\n",k,j);
        } 
		else   //如果链表中不存在这样的值,就返回为0 
		{ 
            printf("没有值为%d的元素\n",j);
        } 
    }
    
    k=ListLength(L);    /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e); /* 删除第j个数据 */
        if(i==ERROR)
        { 
            printf("删除第%d个数据失败\n",j);
        } 
        else
        { 
            printf("删除第%d个的元素值为：%d\n",j,e);
        } 
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

    i=ClearList(&L);       //清空链表中的数据 
    printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20); //随机产生20个值 建立带表头结点链表 
    printf("整体创建L的元素(头插法)：");
    ListTraverse(L);       //输出链表中的所有元素 
    
    i=ClearList(&L);
    printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20); //随机产生20个值 建立带表头结点链表 
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 
}

测试运行的输出结果如下:

 

 

yl浪迹天涯
关注
专栏目录
数据结构——线性表链式存储
weixin_51785373的博客
10-14 2034
线性表的存储方式分为顺序存储和链式存储。其中链式存储是指将线性表中的元素按照一定的次序链接起来，每个元素包含两个部分：数据域和指针域。其中，数据域用于存储元素的值，指针域用于指向下一个元素的地址。通过指针域之间的链接，可以将线性表中的元素连接成一条链式结构。结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找到一个结点和最后一个结点所花费的时间不等。1、链表分为单链表、循环链表、双向链表。
数据结构与算法——线性表链式存储（单循环链表）
CreativeBoy的专栏
05-07 3278
今天总结循环单链表 什么是单循环链表？ 单链表终端结点的指针域是指向空的，如果将其指向头结点，这样就形成了一个环，那么这种首尾相接的环就够成了单循环链表. 单链表中我们都是用头指针来表示的，但是在单循环链表里，用尾指针（指向最后一个节点）。为什么要这样，因为如果用头指针，那么当查找最后一个元素的时候，就要循环遍历，时间复杂度为O(n)，如果用尾指针，时间复杂度为O(1)，而因为是循环的，所以
线性表链式存储结构C语言实现
10-04
线性表 链式存储结构 C语言实现 VC6.0
C语言 线性表的链式存储结构（链表实现）
寒泉
02-09 696
描述 主题：链表 功能：分别实链表的插入、删除、查找操作 提示：如果需要进入下一步操作，输入3个ctrl z即可 代码 //主题：链表 //功能：分别实链表的插入、删除、查找操作 //提示：如果需要进入下一步操作，输入3个ctrl z即可 #define _CRT_SECURE_NO_WARNINGS #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt...
数据结构之线性表的链式存储结构（C语言）
xiangjunyes的博客
05-25 1856
引言 线性表的顺序存储结构，它是有缺点的，最大的缺点就是插入和删除时需要移动大量的数据元素，这显然需要耗费时间。 线性表链式存储结构定义 特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的。也可以是不连续的。这就意味着这些数据元素可以存在内存内存未被占用的任意位置。 在顺序存储结构中，每个数据元素只需要存储数据元素信息就可以了。现在链式结构中，除了要存储数据元素信息之外，还要存储它的后继元素的存储地址。 为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对元素ai来说
数据结构C语言实现系列——线性表（线性表链接存储（单链表））
weixin_34315189的博客
07-06 200
#include <stdio.h>#include <stdlib.h>#define NN 12#define MM 20typedef int elemType ;/*******************************************************//* 以下是关于线性表链接存储（单链表）操作的16种算法...
线性表的链式存储结构（C语言版）
weixin_34257076的博客
04-21 243
上一篇博文我对数据结构中线性表的顺序存储结构顺序表（http://12172969.blog.51cto.com/12162969/1916336）按照我的理解做了总结，今天我继续对顺序表的另一种存储结构，链表谈一下我看法。 链表为什么会出现？按照我的理解，有需就有求，我们都知道，当顺序表存储的元素较多时，插入删除，就要耗费大量时间，这是不能满足当下的需求的，而链表就解决...
数据结构算法代码实现——线性表的链式表示与实现(单链表)(三 )
编程侯的专栏
06-02 9922
线性表的链式表示 使用一组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续也可以是不连续的）。 常见的链式表：单链表、静态链表、循环链表、双向链表。 链表的存储方式和特点我们修改一下上一篇文章的例子：假如现在是新生入校，按照新生的先来后到编号1-6，先到的同学可以随意选择床铺，但是需要记住下一位同学的床铺号（1舍友记住2舍友床铺号，2舍友记住3舍友床铺号，依次类推）。此时无形
线性表链表表相关习题及详解（选择题） ——数据结构
Amour
10-12 5122
本文章主要结合习题来回顾一下线性表中链表的相关知识，这方面还可以看我另一篇文章线性表——Data Structure（C语言描述）单链表typedef struct LNode{ //定义单链表结点类型 ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*LinkList;双链表typed
嵌入式C语言入门——数据结构之单链表（带头结点的单链表）
qq_35599308的博客
12-08 754
单链表链表单链表的创建1. 首先定义头结点和链表结点的结构体2. 创建一个空链表单链表的操作数据插入头插尾插任意位置插数据删除删除指定位置元素删除指定内容链表逆序打印链表销毁链表 链表 包括一个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放一个地址，该地址指向一个元素，头结点一般不存放具体数据，只是存放第一个结点的地址。 链表中每一个元素称为“结点”，每个结点都由两部分组成：存放...
C语言实现线性表的链式存储结构
豆破苍琼
10-05 1181
线性表的链式存储结构
线性表-链式存储结构-C语言
weixin_46708000的博客
05-17 846
链表-链式存储结构-C语言实现设计与实现优点和缺点 设计与实现 优点和缺点 优点： 无需一次性定制链表的容量 插入和删除操作无需移动数据元素 缺点： 数据元素必须保存后继元素的位置信息 获取指定数据的元素操作需要顺序访问之前的元素 //linklist.h #ifndef _MYLINKLIST_H_ #define _MYLINKLIST_H_ typedef void LinkList; /* typedef struct _tag_LinkListNode LinkListNode; st
线性表的链式存储结构（C语言实现）
qq_32262155的博客
10-29 2577
由于线性表的顺序存储结构在进行插入与删除是要移动大量的元素，会耗费大量的时间，线性表的链式存储结构就完美的解决了这个问题。 首先是单链表的创建，有头插法和尾插法。 头插法： /* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */ void CreateListHead(LinkList *L, int n) { LinkList p; int i;
数据结构（C语言版）——线性表的链式存储结构（静态链表）
Lindsay_jie的博客
08-22 524
一、静态链表特征 1、静态链表是一种用数组来存储的链表，由两个数据域组成。data域放数据元素，cur域放后继元素的下标。 2、优点：在插入和删除操作时只需要修改游标，不需要移动元素。 3、缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了顺序存储结构随机存取的特性。 二、静态链表相关算法 1.1静态链表的初始化 在这里插入代码片 1.2静态链表的插入 在这里插入代码片 1.3静态链表的删除 在这里插入代码片 ...
c语言数据结构 - 线性表的链式存储
fengxuewei123的博客
04-03 179
概述 NULL code #include "LinkList.h" // 自定义数据类型 typedef struct PERSON{ char name[64]; int age; int score; }Person; // test 函数 void test02(); void test03(); void test04(); // 用户自定义 打印函数 void myPrint(void*); int main(int argc, char **argv){
数据结构（C语言）——1线性表：单链表的存储和操作
<Hunter>
06-13 253
线性表的链式存储和基本操作（C语言） ...
数据结构线性表的链式存储结构c语言版
qq_46482117的博客
06-30 391
数据结构线性表的链式存储结构c语言版 链表的头插法创建，尾插法创建，输入，输出，插入，删除，按值查找，按位查找，删除，销毁操作 C代码 #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ //定义单链表结点类型 ElemType data; struct LNode *next; }LNode, *LinkList; ListHeadInsert
线性表-单链表（c语言）
simply
06-03 313
线性表–单链表的代码实现（完整）： #include <stdio.h> #include <stdlib.h> #include<time.h> #define ERROR 0 #define OK 1 #define FALSE 0 #define TRUE 1 typedef int Status; typedef int ElemType; //...
（C语言）线性表的链式存储的实现
vipchen1997的博客
06-18 1235
//带头结点单链表的实现 #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef struct LinkListNode { int data; struct LinkListNode *next; }Node,*pNode; pNode Create(void); //初始化，创建头结点 int Isempty(pNode...
C++实现线性表链式存储-单链表详解
C++实现线性表链式存储（单链），通过定义节点类和链表类，提供了链表的基本操作，包括构造、增、删、查、输出等功能。 在C++编程中，线性表是一种基本的数据结构，通常有顺序存储和链式存储两种方式。这里讨论的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值