数据结构线性表，链表，堆栈，队列，树，图等基本结构的代码

最新推荐文章于 2021-12-01 20:56:50 发布
最新推荐文章于 2021-12-01 20:56:50 发布
阅读量507 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构基本代码 文章标签： 数据结构基本代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41184508/article/details/88977990
这篇博客介绍了数据结构中的一些基础元素，包括单链表、循环单链表和双向链表的概念及其实现代码。通过对这些基本数据结构的理解，读者可以更好地掌握数据组织和操作的原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

链表
单链表

//单链表基本运算算法
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode  
{
	ElemType data;
	struct LNode *next;		//指向后继结点
} LinkNode;					//声明单链表结点类型
void CreateListF(LinkNode *&L,ElemType a[],int n)
//头插法建立单链表
{
	LinkNode *s;
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
	L->next=NULL;
	for (int i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点s
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		L->next=s;
	}
}
void CreateListR(LinkNode *&L,ElemType a[],int n)
//尾插法建立单链表
{
	LinkNode *s,*r;
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
	L->next=NULL;
	r=L;					//r始终指向终端结点,开始时指向头结点
	for (int i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点s
		s->data=a[i];
		r->next=s;			//将结点s插入结点r之后
		r=s;
	}
	r->next=NULL;			//终端结点next域置为NULL
}
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
	L->next=NULL;
}
void DestroyList(LinkNode *&L)
{
	LinkNode *pre=L,*p=pre->next;
	while (p!=NULL)
	{	free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);	//此时p为NULL,pre指向尾结点,释放它
}
bool ListEmpty(LinkNode *L)
{
	return(L->next==NULL);
}
int ListLength(LinkNode *L)
{
	LinkNode *p=L;int i=0;
	while (p->next!=NULL)
	{	i++;
		p=p->next;
	}
	return(i);
}
void DispList(LinkNode *L)
{
	LinkNode *p=L->next;
	while (p!=NULL)
	{	printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
bool GetElem(LinkNode *L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L;
	if (i<=0) return false;		//i错误返回假
	while (j<i && p!=NULL)
	{	j++;
		p=p->next;
	}
	if (p==NULL)				//不存在第i个数据结点
		return false;
	else						//存在第i个数据结点
	{	e=p->data;
		return true;
	}
}
int LocateElem(LinkNode *L,ElemType e)
{
	LinkNode *p=L->next;
	int n=1;
	while (p!=NULL && p->data!=e)
	{	p=p->next;
		n++;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*s;
	if (i<=0) return false;			//i错误返回假
	while (j<i-1 && p!=NULL)		//查找第i-1个结点p
	{	j++;
		p=p->next;
	}
	if (p==NULL)					//未找到位序为i-1的结点
		return false;
	else							//找到位序为i-1的结点*p
	{	s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点*s
		s->data=e;
		s->next=p->next;			//将s结点插入到结点p之后
		p->next=s;
		return true;
	}
}
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L,*q;
	if (i<=0) return false;		//i错误返回假
	while (j<i-1 && p!=NULL)	//查找第i-1个结点
	{	j++;
		p=p->next;
	}
	if (p==NULL)				//未找到位序为i-1的结点
		return false;
	else						//找到位序为i-1的结点p
	{	q=p->next;				//q指向要删除的结点
		if (q==NULL) 
			return false;		//若不存在第i个结点,返回false
		e=q->data;
		p->next=q->next;		//从单链表中删除q结点
		free(q);				//释放q结点
		return true;
	}
}

循环单链表

//循环单链表基本运算算法
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode		//定义单链表结点类型
{
	ElemType data;
    struct LNode *next;
} LinkNode;
void CreateListF(LinkNode *&L,ElemType a[],int n)
//头插法建立循环单链表
{
	LinkNode *s;int i;
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
	L->next=NULL;
	for (i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		L->next=s;
	}
	s=L->next;	
	while (s->next!=NULL)			//查找尾结点,由s指向它
		s=s->next;
	s->next=L;						//尾结点next域指向头结点

}
void CreateListR(LinkNode *&L,ElemType a[],int n)
//尾插法建立循环单链表
{
	LinkNode *s,*r;int i;
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
	L->next=NULL;
	r=L;					//r始终指向终端结点,开始时指向头结点
	for (i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点
		s->data=a[i];
		r->next=s;			//将结点s插入结点r之后
		r=s;
	}
	r->next=L;				//尾结点next域指向头结点
}
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));	//创建头结点
	L->next=L;
}
void DestroyList(LinkNode *&L)
{
	LinkNode *p=L,*q=p->next;
	while (q!=L)
	{
		free(p);
		p=q;
		q=p->next;
	}
	free(p);
}
bool ListEmpty(LinkNode *L)
{
	return(L->next==L);
}
int ListLength(LinkNode *L)
{
	LinkNode *p=L;int i=0;
	while (p->next!=L)
	{
		i++;
		p=p->next;
	}
	return(i);
}
void DispList(LinkNode *L)
{
	LinkNode *p=L->next;
	while (p!=L)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
bool GetElem(LinkNode *L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p;
	if (L->next!=L)		//单链表不为空表时
	{
		if (i==1)
		{
			e=L->next->data;
			return true;
		}
		else			//i不为1时
		{
			p=L->next;
			while (j<i-1 && p!=L)
			{
				j++;
				p=p->next;
			}
			if (p==L)
				return false;
			else
			{
				e=p->data;
				return true;
			}
		}
	}
	else				//单链表为空表时
		return false;
}
int LocateElem(LinkNode *L,ElemType e)
{
	LinkNode *p=L->next;
	int n=1;
	while (p!=L && p->data!=e)
	{
		p=p->next;
		n++;
	}
	if (p==L)
		return(0);
	else
		return(n);
}
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
	int j=0;
	LinkNode *p=L,*s;
	if (p->next==L || i==1)		//原单链表为空表或i==1时
	{
		s=(LinkNode *)malloc(sizeof(LinkNode));	//创建新结点s
		s->data=e;								
		s->next=p->next;		//将结点s插入到结点p之后
		p->next=s;
		return true;
	}
	else
	{
		p=L->next;
		while (j<i-2 && p!=L)
		{
			j++;
			p=p->next;
		}
		if (p==L)				//未找到第i-1个结点
			return false;
		else					//找到第i-1个结点p
		{
			s=(LinkNode *)malloc(sizeof(LinkNode));	//创建新结点s
			s->data=e;								
			s->next=p->next;						//将结点s插入到结点p之后
			p->next=s;
			return true;
		}
	}
}
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
	int j=0;
	LinkNode *p=L,*q;
	if (p->next!=L)					//原单链表不为空表时
	{
		if (i==1)					//i==1时
		{
			q=L->next;				//删除第1个结点
			e=q->data;
			L->next=q->next;
			free(q);
			return true;
		}
		else						//i不为1时
		{
			p=L->next;
			while (j<i-2 && p!=L)
			{
				j++;
				p=p->next;
			}
			if (p==L)				//未找到第i-1个结点
				return false;
			else					//找到第i-1个结点p
			{
				q=p->next;			//q指向要删除的结点
				e=q->data;
				p->next=q->next;	//从单链表中删除q结点
				free(q);			//释放q结点
				return true;
			}
		}
	}
	else return false;
}

双向链表

//双链表基本运算算法
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct DNode		//定义双链表结点类型
{
	ElemType data;
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DLinkNode;
void CreateListF(DLinkNode *&L,ElemType a[],int n)
//头插法建双链表
{
	DLinkNode *s;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL) L->next->prior=s;
		L->next=s;s->prior=L;
	}
}
void CreateListR(DLinkNode *&L,ElemType a[],int n)
//尾插法建双链表
{
	DLinkNode *s,*r;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
	r=L;					//r始终指向终端结点,开始时指向头结点
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=NULL;				//尾结点next域置为NULL
}
void InitList(DLinkNode *&L)
{
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
}
void DestroyList(DLinkNode *&L)
{
	DLinkNode *pre=L,*p=pre->next;
	while (p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}
bool ListEmpty(DLinkNode *L)
{
	return(L->next==NULL);
}
int ListLength(DLinkNode *L)
{
	DLinkNode *p=L;
	int i=0;
	while (p->next!=NULL)
	{
		i++;
		p=p->next;
	}
	return(i);
}
void DispList(DLinkNode *L)
{
	DLinkNode *p=L->next;
	while (p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
bool GetElem(DLinkNode *L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L;
	if (i<=0) return false;		//i错误返回假
	while (j<i && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)
		return false;
	else
	{
		e=p->data;
		return true;
	}
}
int LocateElem(DLinkNode *L,ElemType e)
{
	int n=1;
	DLinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		n++;
		p=p->next;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (i<=0) return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;	
		s->next=p->next;		//将结点s插入到结点p之后
		if (p->next!=NULL) 
			p->next->prior=s;
		s->prior=p;
		p->next=s;
		return true;
	}
}
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L,*q;
	if (i<=0) return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		q=p->next;				//q指向要删除的结点
		if (q==NULL) 
			return false;		//不存在第i个结点
		e=q->data;
		p->next=q->next;		//从单链表中删除*q结点
		if (p->next!=NULL) p->next->prior=p;
		free(q);				//释放q结点
		return true;
	}
}
JAVA基础-数据结构一（线性表、链表、栈、队列）
2302_76949164的博客
03-10 1213
/定义一个泛型数组//数组内元素的实际数量//size代表数组里实际有效的数据数量java里面没有像C语言的结构体，但java有内部类新建一个内部类Node表示链表内的单个节点，内部类中包括1.元素2.指向下一节点的指针3.构造函数给元素赋值构造好节点类，再新建头结点和尾结点指针，并新建size表示链表的有效长度{//定义一个结点内部类E data;Node next;//指向下一结点的指针//头结点//尾结点//链表实际长度。
数据结构学习之栈队列链表
Yucohny
02-22 326
文章目录一、链表1.单向链表2.双向链表二、队列三、栈 一、链表 1.单向链表 单项链表应至少满足这样的功能： 1.O(1)O(1)O(1)添加元素 在链表末尾添加元素，移动tailtailtail指针，建立新节点，赋值。 2.O(n)O(n)O(n)插入元素 从链表头开始枚举，直到枚举到需要插入元素的位置。改变指针指向，插入元素。 3.O(n)O(n)O(n)删除元素 从链表头开始枚举，直到枚举到需要删除元素的位置。改变指针指向，删除元素。 4.枚举所有元素 从链表头开始枚举，直到末尾。 另外注意，单向链
C语言 数据结构全书源代码（表、栈、队、串、树、图等）
12-18
C语言实现的数据结构代码，主要有顺序表、链表、栈、队列、数组、串、树、图的定义、创建、基本操作、应用等 代码通俗易懂，逻辑清晰，注释 规范，适合借鉴代码，完成实验报告，研究数据结构等。
【数据结构】代码实现(线性表、栈、队列、串、树、图)
slience_me的博客
10-24 635
数据结构 一、线性表 1. 顺序表(静态分配) #include <iostream> using namespace std; #define TRUE 1 //逻辑真 #define FALSE 0 //逻辑假 #define OK 1 //正确 #define ERROR 0 //错误 #define INFEASIBLE -1 //不可能，非法操作 #define
数据结构之线性表（顺序表、链表、栈、队列）
weixin_52448922的博客
11-28 1652
目录一、线性表1.1 顺序表1.1.1 顺序表的实现1.1.2 顺序表的遍历1.1.3 顺序表的容量可变1.1.4 顺序表的时间复杂度1.1.5 java中ArrayList实现1.2 链表1.2.1 单向链表1.2.1.1 单向链表API设计1.2.1.2 单向链表代码实现1.2.2 双向链表1.2.3 链表的复杂度分析1.2.4 链表反转1.2.5 快慢指针1.2.5.1 中间值问题1.2.5.2 单向链表是否有环问题1.2.5.3 有环链表入口问题1.2.6 循环链表1.2.7 约瑟夫问题 一、线性表
数据结构-------线性表，链表，栈，队列
wenge1477的博客
08-05 426
线性表，链表，栈，队列 时间复杂度 算法：时指令的集合，时为了解决特定问题二规定的一系列操作 时间复杂度，空间复杂度时间复杂度： 时间频度：一个算法花的时间与算法中语句的执行次数成正比，一个算法中语句执行次数称为语句频度或者时间频度，表示T（n）,n表示问题的规模，时间复杂度：想知道问题的规模，而不是具体的次数，此时映入时间复杂度 T(n)=O（f(n)） 空间复杂度: 只需要分析出输入和程序之外...
数据结构之线性表、栈与队列(附Java代码)
popofzk的博客
08-27 305
1. 绪论 2. 线性表 ​ 线性表是一种最常用、最简单，也是一种最基本的数据结构，它是学习其他数据结构的基础。 线性表在计算机中可以用{顺序存储链式存储\begin{cases}顺序存储\\链式存储\end{cases}{顺序存储链式存储​两种存储结构来表示，其中，顺序存储的线性表成为顺序表，链式存储的线性表成为链表，链表又分为：{单链表双向链表循环链表\begin{cases} 单链表\\ 双向链表\\ 循环链表\end{cases}⎩⎪⎨⎪⎧​单链表双向链表循环链表​。 特点： 对于同一个线性表，
数据结构实验一源码：线性表、堆栈和队列的操作与实现
最新发布
11-26
1、线性表的链表实现：遍历、查找、插入、删除、翻转 2、栈的链式存储结构实现：入栈、出栈 3、队列的链式存储结构的实现：入队、出队 4、线性表、栈和队列的应用实现 二、使用仪器、器材 微机一台，操作系统：Win10...
C语言版数据结构实验代码集：队列、链表、线性表、堆栈实现
主要的数据结构包括线性结构、树形结构、图结构和非线性结构等。本实验代码集主要涵盖了线性结构的实现和操作，具体如下： 1. 线性表（Linear List）： 线性表是最基本、最简单的一种数据结构。在内存中，它表现为...
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
数组、链表、堆栈和队列是最基本的数据结构，任何程序都会涉及到其中的一种或多种。数据结构是指数据之间的相互关系，即组织形式，有逻辑结构和物理结构之分。逻辑结构有线性和非线性之分，而物理结构则是描述数据在...
数据结构课件：第2章 线性表、堆栈和队列.ppt
06-16
线性表、堆栈和队列是计算机科学中基础且重要的数据结构，它们在各种算法和程序设计中扮演着核心角色。线性表是一种抽象的数据结构，它包含一个有限序列的元素，这些元素通常是同类型的数据。在本章中，我们将深入...
数据结构：线性表、链表、队列、栈、串
11-24
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
数据结构基础（线性表+栈+队列+树+图）
weixin_43321444的博客
03-29 1714
根据数据元素之间分为4类基本结构： （1）集合（2）线性结构（3）树形结构（4）图状结构或网状结构 typedef int Status; 双向链表中插入一个结点时指针的变化情况： s -> prior = p -> prior; p -> proir -> next = s; s -> next = p; p -> proir = s; ...
数据结构-----单链表，栈与队
qq_40140790的博客
05-20 234
总结单链表，链栈和环形队列的创建和使用 1.单链表： typedef struct list { int m; struct list *next; //struct list *rihgt } mylist; class List { public: List() : plist(new mylist) { if (plist == nullptr) { ...
Java数据结构 遍历 排序 查找 算法实现
zhanghao_Hulk的专栏
06-27 5243
1. 遍历算法（遍历二叉树6种方法） 排序算法 查找算法
数据结构（线性表，队列，栈，树，图）
weixin_30682415的博客
01-10 158
1.线性链表的顺序存储构建（SeqList.h） 顺序表构建 1 //顺序表构建 2 #include <stdio.h> 3 #define MaxSize 100 4 typedef int DataType; 5 6 typedef struct 7 { 8 DataType list[MaxSize]; 9 ...
数据结构与算法_线性表、栈、队列习题
MengHen_0_0的博客
09-13 438
线性表、栈、队列习题
常用的数据结构-数组、堆栈、队列、链表、树、哈希表
qq_26430717的博客
12-01 3017
常用的数据结构与算法 数组 堆栈 队列 链表 树 图 哈希表 一. 数组 数组(Array)是最简单，也是最常用的数据结构了。其他一些数据结构，比如栈和队列都是由数组衍 生出来的。 每一个数组元素的位置称为下标或者索引(index)标识的。大多数编程语言的数组第一个元素 的下标是 0。 根据维度区分，数组是分为一维数组和多维数组(数组的元素为数组) 一维数组【int[] arr =new int[4];】： 二维数组【int[][] arr =new int[3][4];】： ...
数据结构-线性表数据结构(数组、队列、栈、链表)
weixin_43879206的博客
02-05 890
一:数组 数组:是一种线性表数据结构。它用一组连续的内存空间来存储一组具有相同类型的数据。 ​ 从数组的定义中我们可以找到2个关键点:1:线性表 2:连续的内存和相同的数据类型 。 线性表:数据排列成像一条线一样的结构,数据最多只有前后2个方向。类型的还有链表、队列等 数组的这俩个关键字也正好决定了数组的特性:随机访问 带来的弊端也很容易知道 为了保证其‘’连续的内存‘’删除和插入需要进行大量的数据搬移工作。 二:链表 ​ 链表:是一种线性表数据结构。它可以是不连续的内存空间。 ​ 链
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值