数据结构与算法之——线性表的链式存储结构

最新推荐文章于 2022-11-17 11:10:24 发布
最新推荐文章于 2022-11-17 11:10:24 发布
阅读量1k 收藏 3
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mylovepan/article/details/19019313
版权

LinkedList.h

/* 线性表的链式存储结构 */
typedef int ElemType ;      //ElemType类型根据实际情况而定，这里假设为int
typedef struct Node
{
    ElemType data;  
    struct Node * next;
/* 线性表的链式存储结构 */
/* 线性表的链式存储结构 */
/* 线性表的链式存储结构 */
/* 线性表的链式存储结构 */
/* 线性表的链式存储结构 */
typedef int ElemType ;      //ElemType类型根据实际情况而定，这里假设为int
typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,*LinkedList;

#define OK 1
#define ERROR 0
typedef int Status;
/* 线性表通用操作  */
Status InitList(LinkedList *L);     //建立一个空的线性表L
Status ListEmpty(LinkedList L);     //若线性表为空返回true，否则返回false
Status ClearList(LinkedList *L);    //将线性表清空
Status GetElem(LinkedList L,int i,ElemType *e);     //将线性表L中第i个位置元素值返回给e
int LocateElem(LinkedList L,ElemType e);    //在线性表L中查找与给定值e相等的元素，如果查找>成功，返回该元素在表中序号表示成功；否则，返回0表示失败。
Status ListInsert(LinkedList *L,int i,ElemType e);      //在线性表L中的第i个位置插入新元素e
Status ListDelete(LinkedList *L,int i,ElemType *e);     //删除线性表L中第i个位置元素，并用e返回值值
int ListLength(LinkedList L);   //返回线性表L的元素个数

LinkedList.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkedList.h"

int main(void)
{
	LinkedList L;
	InitList(&L);

	if(ListEmpty(L))
	{
		printf("是空的\n");
		ListInsert(&L,0,3);
		ListInsert(&L,1,13);
		ListInsert(&L,2,23);
		ListInsert(&L,2,33);
		ListInsert(&L,4,43);
		ListInsert(&L,5,53);
		ListInsert(&L,6,63);
		ListInsert(&L,7,73);
		ListInsert(&L,8,83);
		ListInsert(&L,9,93);
		ListInsert(&L,10,103);
		ListInsert(&L,11,113);
		ListInsert(&L,12,123);
	}
	printf("遍历所有元素:\n");
	int len = ListLength(L);
	LinkedList h;int j=0;
	h = L;
	while(h->next)
	{
		h = h->next;
		printf("[%d]%d,",j,h->data);
		j++;
	}
	printf("\n长度为%d\n",len);
	ElemType e;
	GetElem(L,2,&e);
	printf("索引2位置的元素是:%d\n",e);
	printf("查找53的索引位置是:%d\n",LocateElem(L,53));

	printf("删除第6位后\n");
	ElemType ee;
	ListDelete(&L,6,&ee);	
	len = ListLength(L);
	j = 0;
	h = L;
	while(h->next)
	{
		h = h->next;
		printf("[%d]%d,",j,h->data);
		j++;
	}

	printf("\n");


	return 0;
}

//建立一个空的线性表L
Status InitList(LinkedList *L)				
{
	*L = (LinkedList)malloc(sizeof(LinkedList));
	(*L)->next = NULL;
	(*L)->data = 0;
	return OK;		
}
//若线性表为空返回true，否则返回false
Status ListEmpty(LinkedList L)				
{
	return L->next == NULL;		
}
//将线性表清空
Status ClearList(LinkedList *L)			
{
	LinkedList p = (*L)->next,q;
	while(p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;	//头结点的指针域置空
	(*L)->data = 0;		//头结点的数据域表示长度变为0
	return OK;		
}
//将线性表L中第i个位置元素值返回给e
Status GetElem(LinkedList L,int i,ElemType *e)			
{
	int j=0;
	LinkedList p = L->next;//第一个结点
	while(p && j<i)
	{
		p = p->next;
		j++;
	}
	if(!p || j>i)
	{
		printf("第%d个结点不存在\n",i);
		return ERROR;
	}
	*e = p->data;
	return OK;		
}
//在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表中序号表示成功；否则，返回0表示失败。
int LocateElem(LinkedList L,ElemType e)			
{
	int j =0;
	LinkedList p = L->next;
	while(p)
	{
		if(p->data == e)
		{
			return j;
		}
		p = p->next;
		j++;
	}
	return ERROR;		
}
//在线性表L中的第i个位置插入新元素e
Status ListInsert(LinkedList *L,int i,ElemType e)		
{	
	int j=0;
	LinkedList p,s;		//s为新建的结点的指针
	p = *L;				//p指向表头结点
	while(p && j<i)
	{
		p = p->next;	//往后找
		j++;
	}
	if(!p || j>i)
	{
		printf("第%d个结点不存在!\n",i);
		return ERROR;
	}
	s = (LinkedList )malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	(*L)->data ++;
	return OK;		
}
//删除线性表L中第i个位置元素，并用e返回值值
Status ListDelete(LinkedList *L,int i,ElemType *e)		
{
	LinkedList p = (*L)->next,q;
	int j = 0;
	while(p && j<i-1)
	{
		p = p->next;
		j++;
	}
	if(!(p->next) || j>i)
	{
		printf("第%d个结点不存在\n",i);
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free(q);
	return OK;		
}
//返回线性表L的元素个数
int ListLength(LinkedList L)			
{
	return L->data;		
}

总结：

线性表的查找、插入与删除时间复杂度都为O(n)

如果在不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构没有太大优势。但如果希望从第i个位置，插入10个元素，对于顺序存储结构意味着，每一次插入都需要移动n-1个元素，每次都是O(n)。则单链表只需在第一次时，找个第i个指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。显然对于插入或删除数据越频繁的操作，单链表的效率优势就越明显。

单链表的整表创建与删除

LinkedList2.c

/* 单链表的整表创建与删除 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "LinkedList.h"

/* 随机产生n个元素的值，建立带头结点的单链表L(头插法) */
Status CreateListHead(LinkedList *L,int n);

/* 随机产生n个元素的值，建立带头结点的单链表L(尾插法) */
Status CreateListTail(LinkedList *L,int n);

void printList(LinkedList L);

/* 初始条件：链表已存在，操作结果：将L重置为空表 */
Status ClearList(LinkedList *L);

int main(void)
{
	LinkedList L;
	printf("头插法创建单链表:\n");
	CreateListHead(&L,10);
	printList(L);
	printf("清空后:\n");
	ClearList(&L);
	printList(L);
	
	printf("尾插法创建单链表:\n");
	CreateListTail(&L,10);
	printList(L);
	printf("清空后:\n");
	ClearList(&L);
	printList(L);

	return 0;
}

/* 随机产生n个元素的值，建立带头结点的单链表L(头插法) */
Status CreateListHead(LinkedList *L,int n)
{
	LinkedList p;
	int i;
	srand(time(0));		//初始化随机种子数
	*L = (LinkedList)malloc(sizeof(Node));
	(*L)->next = NULL;	//建立一个带头结点的单链表
	for(i=0;i<n;i++)
	{
		p = (LinkedList)malloc(sizeof(Node));	//生成新结点
		p->data = rand()%100+1;
		p->next = (*L)->next;
		(*L)->next = p;				//插入到表头
	
	}
	return OK;
}

/* 随机产生n个元素的值，建立带头结点的单链表L(尾插法) */
Status CreateListTail(LinkedList *L,int n)
{
	LinkedList p,r;
	int i;
	srand(time(0));		//初始化随机种子数
	*L = (LinkedList)malloc(sizeof(Node));
	(*L)->next = NULL;	//建立一个带头结点的单链表
	r = (*L);			//r指向尾部的结点
	for(i=0;i<n;i++)
	{
		p = (LinkedList)malloc(sizeof(Node));	//生成新结点
		p->data = rand()%100+1;
		r->next = p;							//插入到尾部
		r = p;									//重新指向尾部
	}
	r->next = NULL;								//表示当前链表结束
	return OK;
}

void printList(LinkedList L)
{
	LinkedList p = L->next;
	while(p)
	{
		printf("%d,",p->data);
		p = p->next;
	}
	printf("\n");
}



/* 初始条件：链表已存在，操作结果：将L重置为空表 */
Status ClearList(LinkedList *L)
{
	LinkedList p = (*L)->next,q;	//定义一个指向头结点的指针
	while(p)
	{
		q = p->next;				//找到下一个结点
		free(q);					//释放该结点
		p = q;						//指向下一下结点
	}
	(*L)->next = NULL;				//头结点指向为空
	return OK;
}

链式存储结构与顺序存储结构的优缺点

存储分配方式

时间性能

空间性能

·顺序存储结构用一段连续的存储单元依次存储线性表的数据元素

·单链表采用链式存储结构，用一组任意的存储单元存放线性表的无数

·查找

         ·顺序存储结构O(1)

         ·单链表O(n)

·插入和删除

·顺序存储结构需要平均移动表长一半的元素时间为O(n)

·单链表在找到某位置的指针后，插入和删除时仅为O(1)

·顺序存储结构需要分配存储空间。分大了浪费，分小了易发生上溢

·单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制

 

通过上面的对比，得出一些结论

·若线性表需要频繁查找，很少进行插入和删除时，宜采用顺序存储结构。若需要频繁插入和删除时，宜采用单链表结构。

·当线性表中的元素个数变化较大或根本不知道有多大时，最好采用单链表结构，这样可以不需要考虑存储空间的大小问题。而如果事先知道线性表的大致长度，这种用顺序存储结构效率会高很多。


无意摘花
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构实验一线性表的基本操作.docx
03-28
线性表可以分为两种类型：顺序存储结构和链式存储结构。 二、顺序存储结构 顺序存储结构是指用一组地址连续的存储单元依次存储顺序表的数据元素。顺序表的基本操作包括： * 求长度：返回线性表的长度 * 插入：...
查找链表中最小值的点
shouwang666666的博客
10-27 3114
//查找链表中最小值的点 LinkList Select_Min(LinkList &L) { LNode *q,*p; p=L; q=L->next; int dd; if(q) dd=q->data; while(q->next!=NULL) { if(dd>q->next->data) { dd=q->data; p=q->next;.
链表的相关操作-数据结构与算法（北航991数据结构）
dbbigdata的博客
06-08 1222
//1.已知长度为n的线性表A采用顺序存储结构。请写一算法,找出该线性表中值最小的数据元素,给出该元素在表中的位置。 //1.已知长度为n的线性表A采用顺序存储结构。请写一算法,找出该线性表中值最小的数据元素,给出该元素在表中的位置。 int LOCAL(ElemType arr[],int n){ ElemType a; a=arr[0]; int l = 0; for (int i = 1; i < n; ++i) { if(arr[i]<a)
L=(Linklist)malloc(sizeof(Node))含义
weixin_41845265的博客
08-16 1万+
sizeof函数计算数据（包bai括数组、变量、du类型、结构体等）所占内存空间，用zhi字节数表示。 malloc函数用于在内存开辟了一段地址，而这段地址的首地址存在返回的那个指针变量里，由于不知道到底这段地址有多长，可以存什么变量，所以它的类型是空的，你可以强制类型转换，使其变成确定长度，固定存放一种数据类型的地址，而不管它是哪种类型，其首地址还是原来那个，还是存在一个指针变量中，指针变量就是放指针的嘛，指针是一个地址，指针变量是一个我们定义的，用来放那个地址的变量。 那么代码的意思就是说 获取Node
02_线性表-2
最新发布
qq_35231482的博客
11-17 602
数据结构
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——线性表的链式储存结构
xzt12138的博客
07-23 2287
链式储存结构：n个结点链组成一个链表，即为线性表的链式存储结构。因为此链表的每个结点中只包含一个指针域，所以叫做单链表。我们把链表中第一个结点的存储位置叫做头指针。在单链表中第一个结点前附设一个结点，称为头结点。（头结点的数据域可以不储存任何信息）...
数据结构与算法——线性表 定义线性表节点的结构.pdf
04-18
【线性表】是数据结构中的基础概念，它是由n（n≥0）个相同类型元素构成的有限序列。在序列中，每个元素都有一个前驱元素和后继元素，除非是第一个元素（没有前驱）和最后一个元素（没有后继）。线性表的这种一对一...
c语言实现线性表的算法-数据结构算法代码实现——线性表的定义（一） 定义线性表节点的结构.pdf
04-18
在计算机中，线性表的实现方式有顺序存储结构和链式存储结构两种。顺序存储结构是将数据元素存储在连续的存储单元中，而链式存储结构是将数据元素存储在不连续的存储单元中，并使用指针来连接各个元素。 在C语言中...
数据结构实验——线性表的插入、删除.docx
06-13
数据结构实验报告——线性表的插入、删除 在计算机科学领域中，数据结构是一种组织和存储数据的方式，以便更高效地使用计算机资源。线性表是一种基本的数据结构，广泛应用于各种计算机应用程序中。线性表的插入和...
数据结构-线性表的链式存储（包含代码实现）
qq_46338854的博客
05-05 7964
线性表的链式表示和实现 链式存储结构 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻 线性表的链式存储结构又称为非顺序映像或链式映像。 用一组物理位置任意的存储单元来存放线性表的数据元素 这组存储单元既可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。 链表中元素的逻辑次序和物理次序不一定相同 与链式存储结构相关的术语 1、结点：数据元素的存储映像。由数据域和指针域两部分组成 数据域：存放元素数值数据 指针域：存放直接后继结点的存储位置 2、链表：n个结点
6-5 找出顺序表中的最小值 (10 分)
weixin_52326703的博客
02-16 3994
6-5 找出顺序表中的最小值 (10 分) 已知长度为n的线性表采用顺序存储结构，请设计一个算法，找出该线性表中值最小的数据元素。 顺序表的存储结构如下： #define MAXSIZE 100 typedef int ElemType; typedef struct { ElemType elem[MAXSIZE]; int length; }SeqList; 函数接口定义： int FindMin(SeqList *q ); 其中 q 是用户传入的参数，为指向顺序表的指针。函数返回
数据结构与算法之——两栈共享存储空间
无意摘花
02-12 6920
其实栈的顺序存储很方便，因为它只在表尾进行操作，不存在普通线性表插入与删除还需要移动元素的情况。同样它也有普通线性表的缺陷，即必须确定数量。然而对于两个相同类型的栈，却可以做到最大限度地利用其开辟的存储空间来进行操作。          数组有两个端点，两个栈使用这一个数组的存储区域，两个栈有两个栈底，分别为数组的始端和末端。 这样在压栈的时候，是栈顶指针往中间靠拢，当两指针相遇时，则栈满。栈
数据结构与算法之——高斯算法
无意摘花
02-08 3177
在高斯想出1+...+100那个算法之前，他老师是一遍遍循环把1到100的和计算出来的。以下是比较的普通算法与高斯算法的不同，其中gettime()是获取当前的毫秒数。 #include #include "mytime.h" long normal(int max); //普通算法 从1加到100 long gaosi(int max); //高斯算法 从1加到100
数据结构与算法——栈的作用及应用
无意摘花
02-15 2306
作用： 栈的引入简化了程序设计的问题，划分了不同的关注层次，使得思考范围缩小，更加聚焦于要解决的问题核心。反之，像数组等，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。 应用一：递归，斐波那契数列 /* 斐波那契序列的两种表示 */ #include /* 迭代表示法 */ /* 斐波那契序列的两种表示 */ #include /* 迭代表示法 */ voi
数据结构与算法之——线性表的顺序存储结构
无意摘花
02-08 951
ArrayList.h /* 线性表的顺序存储结构 */ #define MAXSIZE 10 //存储空间初始分配量 typedef int ElemType ; //ElemType类型根据实际情况而定，这里假设为int typedef struct { ElemType data[MAXSIZE]; //数组存储数据元素，最大值为MAXSIZE
数据结构与算法之——顺序栈
无意摘花
02-12 880
栈：栈是限定仅能在表尾进行插入和删除操作的线性表。 栈是一种特殊的线性表，它具有线性表的属性即有前驱和后继，但不同于线性表可以在任意位置插入和删除元素，它只能在表尾进行，因此先入的元素会被压入栈底，而后入的元素却会首先被弹出来。因此它是 Last In First Out即后进先出的。 栈的抽象数据类型表示： ADT 栈(stack)    Data     同线性表，元素具有相同的
广东东软学院：数据结构与算法实验一——线性表顺序存储与栈队列应用
实验课程名称为“数据结构与算法”，聚焦于数据结构中的核心概念——线性表。实验一的具体主题是线性表的顺序存储与链式存储，以及与之相关的栈和队列。实验旨在让学生深刻理解这些数据结构的基础知识，并将其应用到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值