数据结构（栈、顺序表、队列、链式表）

最新推荐文章于 2022-09-06 16:50:52 发布
最新推荐文章于 2022-09-06 16:50:52 发布
阅读量233 收藏
点赞数
文章标签： 数据结构 队列 链表 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51420051/article/details/109605994
版权

什么是数据结构

​ 是一门研究数据之间关系的一门学科，主要有两类需要研究的关系：逻辑关系、物理关系

​ 物理关系：数据在内存中的实际关系。

​ 顺序结构：根据数据之间的相对位置确定关系

​ 链式结构：在数据当中再添加一个指针域，用于指向跟它有关系的数据。

​ 逻辑关系：无视物理关系，人为添加的一种关系。

​ 集合：数据之间同属一个集体，除此之外没有任何关系。

​ 表：数据之间存在一对一关系，如：数组（顺序表），链表（链式表）。

​ 树：数据之间存在一对多关系。

​ 图：数据之间存在多对多关系。

​ 注意：我们常说的数据结构指的是逻辑关系，而数据结构在内存中的储存方式，指的是物理关系。

​ 每种逻辑关系采用什么样的物理结构储存并没有明确规定，通常以代码实现的验证、以及时间、空间复杂度的要求，选择最合适的物理结构储存，也有可能是链式和顺序混合存储。

算法

​ 广义：解决特定问题的方法

​ 狭义：数据结构的运算

学习数据结构的三个关键点

​ 1、物理结构

​ 2、逻辑结构：所有的逻辑结构既可以是顺序结构存在，也可以是链式结构存在。

​ 3、结构的运算

数据结构常有的运算：

​ 1、创建数据结构：create

​ 2、销毁数据结构：destroy

​ 3、清除所有元素：clear

​ 4、遍历数据结构：show、print

​ 5、从数据结构中删除一个元素：delete

​ 6、把一个元素插入到数据结构：install

​ 7、修改数据结构中的某个元素：modify

​ 8、查询数据结构中的元素：query、find

​ 9、访问其中一个元素：access

顺序表

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#define TYPE int

//设计顺序表结构:元素之间是连续的
typedef struct Order
{
	TYPE* ptr;
	int cal;
	int cnt;
}Order;

//创建顺序表
Order* create_order(int cal)
{
	//给表结构分配内存
	Order* order = malloc(sizeof(Order));
	//给元素分配内存
	order->ptr = malloc(sizeof(TYPE)*cal);
	//记录表的容量
	order->cal = cal;
	//初始化元素的数量
	order->cnt = 0;
	return order;
}

//销毁顺序表
void destroy_order(Order* order)
{
	free(order->ptr);
	order->ptr=NULL;
	free(order);
	order = NULL;
}

//清除表元素
void clear_order(Order* order)
{
	order->cnt = 0;
}

//插入元素
bool insert_order(Order* order,int index,TYPE val)
{
	if(order->cnt >= order->cal || index >= order->cnt)
	{
		return false;
	}
	for(int i=order->cnt; i>index; i--)
	{
		order->ptr[i] = order->ptr[i-1];
	}
	order->ptr[index] = val;
	order->cnt++;
	return true;
}

//删除元素
bool delete_order(Order* order,int index)
{
	if(index >= order->cnt)
	{
		return false;
	}
	for(int i=0; i<order->cnt-1; i++)
	{
		order->ptr[i] = order->ptr[i+1];
	}
	order->cnt--;
	return true;
}

//添加元素
bool add_order(Order* order,TYPE val)
{
	//判断表是否满
	if(order->cnt >= order->cal)
	{
		return false;
	}
	//在末尾添加元素
	order->ptr[order->cnt++] = val;
	return true;
}

//访问元素
bool access_order(Order* order,int index,TYPE* p)
{
	if(index >= order->cnt)
	{
		return false;
	}
	*p = order->ptr[index];
	return true;
}

//修改元素
bool modify_order(Order* order,TYPE old,TYPE new)
{
	for(int i=0; i<order->cnt; i++)
	{
		if(order->ptr[i] == old)
		{
			order->ptr[i] = new;
			return true;
		}
	}
	return false;
}

//查询元素
int query_order(Order* order,TYPE key)
{
	for(int i=0; i<order->cnt; i++)
	{
		if(key == order->ptr[i])
		{
			return i;
		}
	}
	return -1;
}
//遍历顺序表
void show_order(Order* order)
{
	for(int i=0; i<order->cnt; i++)
	{
		printf("%d ",order->ptr[i]);
	}
	printf("\n");
}
//排序顺序表
void sort_order(Order* order)
{
	for(int i=0; i<order->cnt-1; i++)
	{
		for(int j=i+1; j<order->cnt; j++)
		{
			if(order->ptr[j] > order->ptr[i])
			{
				TYPE temp = order->ptr[i];
				order->ptr[i] = order->ptr[j];
				order->ptr[j] = temp;
			}
		}
	}
}
int main(int argc,const char* argv[])
{
	Order* order = create_order(15);
	for(int i=0; i<10; i++)
	{
		add_order(order,rand()%100);
	}
	show_order(order);
	insert_order(order,1,10001);
	show_order(order);
	delete_order(order,1);
	show_order(order);
	int num=0;
	access_order(order,0,&num) && printf("access:%d",num);
	sort_order(order);
	show_order(order);
}

功能被限制的表

栈

​ 只有一个端口进入，元素先进后出FILO

​ 而栈内存正是使用了这种结构管理内存，所以才叫栈内存

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define TYPE int


typedef struct StackOrder
{
	TYPE* ptr;
	int cal;
	int top;
}StackOrder;

//创建桟
StackOrder* create_stack(int cal)
{
	StackOrder* stack = malloc(sizeof(StackOrder));
	stack->ptr = malloc(sizeof(TYPE)*cal);
	stack->cal = cal;
	stack->top = -1; //cal|cal-1|0|-1
	/*
		cal:满减桟
		cal-1:空减桟
		-1：满增桟
		0：空增桟
	*/
	return stack;
}
//销毁桟
void destroy_stack(StackOrder* stack)
{
	free(stack->ptr);
	free(stack);
}
//桟空
bool empty_stack(StackOrder* stack)
{
	return -1 == stack->top;
}
//桟满
bool full_stack(StackOrder* stack)
{
	return stack->top >= stack->cal-1;
}
//入桟
bool push_stack(StackOrder* stack,TYPE val)
{
	if(full_stack(stack))
		return false;
	stack->ptr[++stack->top] = val;
	return true;
}
//出桟
bool pop_stack(StackOrder* stack)
{
	if(empty_stack(stack))
		return false;
	stack->top--;
	return true;
}
//获取栈顶元素
TYPE top_stack(StackOrder* stack)
{
	return stack->ptr[stack->top];
}
int main(int argc,const char* argv[])
{
	StackOrder* stack = create_stack(10);
	for(int i=0; i<11; i++)
	{
		bool flag = push_stack(stack,i);
		printf("push:%d %s\n",i,flag?"成功":"失败");
	}
	while(!empty_stack(stack))
	{
		printf("top:%d ",top_stack(stack));
		printf("%s\n",pop_stack(stack)?"成功":"失败");
	}
}

队列

把一个表结构限制成有两个端口，一个端口只能进，另一个端口只能出，先进先出FIFO

​ 队头 0

​ 队尾 0

​ 队空 队头==队尾

​ 队满 队尾+1==队头

​ 出队 front = (front+1)%cal

​ 入队 rear = (rear+1)%cal

​ 队头元素 ptr[front]

​ 队尾元素 (cal+rear-1)%cal

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define TYPE int

typedef struct QueueOrder
{
	TYPE* ptr;
	int cal;
	int front;
	int rear;
}QueueOrder;


//创建队列
QueueOrder* create_queue(int cal)
{
	QueueOrder* queue = malloc(sizeof(QueueOrder));
	queue->ptr = malloc(sizeof(TYPE)*cal);
	queue->cal = cal;
	queue->front = 0;
	queue->rear = 0;
	return queue;
}

//销毁队列
void destroy_queue(QueueOrder* queue)
{
	free(queue->ptr);
	free(queue);
}

//队空
bool empty_queue(QueueOrder* queue)
{
	return queue->front == queue->rear;
}

//队满
bool full_queue(QueueOrder* queue)
{
	return (queue->rear+1)%queue->cal == queue->front;
}

//入队
bool push_queue(QueueOrder* queue,TYPE val)
{
	if(full_queue(queue))
		return false;
	queue->ptr[queue->rear] = val;
	queue->rear = (queue->rear+1)%queue->cal;
	return true;
}

//出队
bool pop_queue(QueueOrder* queue)
{
	if(empty_queue(queue))
		return false;
	queue->front = (queue->front+1)%queue->cal;
	return true;
}

//队头
TYPE front_queue(QueueOrder* queue)
{
	return queue->ptr[queue->front];
}

//队尾
TYPE rear_queue(QueueOrder* queue)
{
	if(queue->rear)
		return queue->ptr[queue->rear-1];
	else
		return queue->ptr[queue->cal-1];
	//return queue->ptr[(queue->rear+queue->cal-1)%queue->cal];
}

int main(int argc,const char* argv[])
{
	QueueOrder* queue = create_queue(10);
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("rear:%d\n",rear_queue(queue));
	}
	while(!empty_queue(queue))
	{
		printf("front:%d\n",front_queue(queue));
		pop_queue(queue);
	}
}

链式表

​ 元素：由数据域，指针域组成，元素之间使用指针域链接，这种结构叫链式存储结构。

​ 如果元素中只有一个指针域，且指向下一个元素，这样元素之间就只存在一对一关系，这种结构叫链式表。

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define TYPE int

//链表的节点
typedef struct Node
{
	TYPE data;	//数据域
	struct Node* next;	//指针域，指向下一个节点
}Node;

//创建节点
Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

//链表
typedef struct List
{
	Node* head;
	Node* tail;
}List;

//创建链表
List* create_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = NULL;
	list->tail = NULL;
}

//头添加节点
void add_head_list(List* list,TYPE data)
{
	Node* node = create_node(data);
	if(NULL == list->head)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		node->next = list->head;
		list->head = node;
	}
}
//尾添加节点
void add_tail_list(List* list,TYPE data)
{
	Node* node = create_node(data);
	if(NULL == list->tail)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		list->tail = node;
	}
}

//头删除节点
void del_head_list(List* list)
{	Node* node = list->head;
	if(list->tail == list->head)
	{
		list->head = NULL;
		list->tail = NULL;
	}
	else
	{
		list->head = node->next;
	}
	free(node);
}
//尾删除节点
void del_tail_list(List* list)
{
	Node* node = list->tail;
	if(list->tail == list->head)
	{
		list->head = NULL;
		list->tail = NULL;
	}
	else
	{
		Node* prev = list->head;
		while(prev->next != list->tail)
		{
			prev = prev->next;
		}
		prev->next = NULL;
		list->tail = prev;	
	}
	free(node);
}
//修改
bool modify_list(List* list,TYPE old,TYPE new)
{
	for(Node* n=list->head; NULL!=n; n=n->next)
	{
		if(n->data == old)
		{
			n->data = new;
			return true;
		}
	}
	return false;
}
//查询
bool query_list(List* list,TYPE key)
{
	for(Node* n=list->head; NULL!=n; n=n->next)
	{
		if(key == n->data)
		{
			return true;
		}
	}
	return true;
}
//长度
size_t len_list(List* list)
{
	int len = 0;
	for(Node* n=list->head; NULL!=n; n=n->next)
	{
		len++;
	}
	return len;
}

//遍历
void show_list(List* list)
{
	for(Node* n=list->head; NULL!=n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}
//排序
void sort_list(List* list)
{
	for(Node* n1=list->head; list->tail!=n1->next; n1=n1->next)
	{
		for(Node* n2=n1->next; NULL!=n2; n2=n2->next)
		{
			if(n1->data < n2->data)
			{
				TYPE temp = n1->data;
				n1->data = n2->data;
				n2->data = temp;
			}
		}
	}
}

int main(int argc,const char* argv[])
{
	List* list = create_list();
	for(int i=0; i<15; i++)
	
	{
		add_tail_list(list,i);
	}
	show_list(list);
	del_tail_list(list);
	show_list(list);
	modify_list(list,7,100);
	show_list(list);
	printf("len:---%d---",len_list(list));
	sort_list(list);
	show_list(list);
}
Mikoto_10032
关注
顺序表与链表
m0_56931704的博客
09-06 1502
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
顺序表、链式表、顺序栈、链式栈以及顺序队列、链式队列
weixin_65012900的博客
08-06 507
数据结构 表 栈 队列
顺序表和链式表
Mormont的博客
11-26 4137
1.数据元素之间不是独立的，存在特定的关系，这些关系即结构。所以数据结构是指数据对象中数据元素之间的关系。 数据结构分为逻辑结构和物理结构。 逻辑结构分为： 集合结构：数据元素之间没有特别的关系，仅同属相同集合。 线性结构：数据元素之间是一对一的关系。 树形结构：数据元素之间存在一对多的层次关系。 图形结构：数据元素之间是多对多的关系。 物理结构分为： 顺序存储结构：将数据存储在地
顺序和链式表
Euphoria_stars的博客
09-06 372
顺序表和链式表
顺序表and链式表
avvvbhhh的博客
09-05 221
复习
顺序表与链式表
qq_64710124的博客
09-06 524
顺序表与链式表
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip
08-16
本资料包"顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip"涵盖了这四种数据结构的基本操作，包括入队、出队、入栈、出栈等核心算法。 1. **顺序栈**： - 顺序栈是一种基于数组实现的栈，其元素存储在连续...
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
这里我们讨论的是顺序表、链表以及循环队列，这些都是基本的数据结构，广泛应用于算法设计和程序实现中。 顺序表是一种线性数据结构，它在内存中按顺序连续存储元素。它的主要操作包括插入、删除和查找。在顺序表中...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
顺序表和链表
weixin_43482231的博客
03-15 325
1.顺序表 顺序表也叫线性表，是一种线性的存储结构，在C和Java里，顺序表其实就是数组。而这也是编译器已经给我们包装好的，直接拿来用就可以了。尽管如此，数组虽然随机访问比较快，但是对于增删查改等有的操作仅仅靠数组本身是不能完成的，因此，我们还需要对现有数组类型进行包装。完成以下功能： package SeqList; public class SeqList { //顺序表长度初始化为...
# 数据结构-顺序表和链式表
木南
05-23 787
第一次在CSDN上写东西，心里有点激动，希望自己可以坚持下去。 嘿嘿嘿，算是在CSDN上出道了。 文章简单的描述了一下，我在某科上机遇到的一点问题… 个人笔记使用，轻喷，附有源码，欢迎交流…附件下载地址： http://download.csdn.net/detail/qq_29747591/9529037顺序表顺序表是采用的连续的存储结构 结构为：1.表长度 2.指向的数据 3.存储
数据结构(c)——线性表：顺序表和链式表
Jali_li的博客
04-16 1000
因为已经大三下学期，准备暑假找实习，以前学得渣，这段时间恶补下基础！！数据结构和算法搞起 线性表包括顺序存储和链式存储两种形式。 1、顺序表 首先定义宏，为线性表分配初始内存空间和再分配用 定义结构体，内部定义指针作为线性表的基址，动态分配后就可以用下标访问，跟数组一样，数组a[10]，a是指向第一个元素的指针， #define LIST_INIT_SIZE 100 //首次分配的
数据结构——线性结构——顺序表和链式表
Jackey_Song的博客
11-16 1513
本篇目录线性表（Linear List）的两种存储实现线性表的操作顺序表链式表不带头节点的链式表带头节点的链式表堆栈队列 线性表（Linear List）的两种存储实现 线性表的顺序存储实现称为顺序表。 线性表的链式存储实现称为链式表。 线性表的操作 List MakeEmpty() ：初始化一个新的空线性表。 ElementType FindKth(List L, int i) ：返回L中位序为 i 的元素。 Position Find(List L, ElementType X) ：返回线性表L中第一
（数据结构）顺序表和链表
Captain_ldx的博客
08-07 987
一份详细的顺序表链表实现笔记！
链表与顺序表
kxbdys的博客
03-14 1207
一、顺序表 1、定义：用一组连续的存储单元依次存储数据元素，需要占用一整块存储空间的存储列表。 2、优点: ■存储密度大(结点本身所占存储量/结点结构所占存储量) ■可以随机存取表中任一元素 3、缺点: ■在插入、删除某一元素时，需要移动大量元素 ■浪费存储空间 ■属于静态存储形式，数据元素的个数不能自由扩充 因此为了解决上述缺点而产生了链表。 ...
数据结构之顺序表、链式表
weixin_49237256的博客
08-20 647
一、什么是数据结构 1、数据结构的起源 1968年，美国的高纳德教授开设了一门基本算法的课程，开创了数据结构的先河。 数据结构是一门研究数据之间关系和操作的学科，而非是计算方法。 数据结构+算法=程序 沃思凭借这名个论点，获得图灵奖，这句话展示出了程序的本质。 2、数据结构的基本概念 数据：所有能够输入到计算机中去描述事物的符号。 数据项：有独立含义的数据最小单位，也叫域。 数据元素：数据的基本单位也叫节点、记录。 数据结构：数据元素和数据关系的集合。 算法：数据结构所具备的功能，解决特定的问题的方法。 3
链表/栈/队列/顺序表
ruige6的博客
02-17 212
一，线性表 线性表是什么？   线性表是最基本，最简单，也是最常用的数据结构，一个线性表是n个具有相同特征的数据元素的有限排序 前驱元素是什么？   若是A元素在B元素前面，则称为A为B的前驱元素 后继元素是什么？   若B元素在A元素后面，则称B为A的后继元素 线性表的特征·：数据元素之间具有一种 ‘’一对一‘’的逻辑关系   1.第一个数据元素没有前驱，这个数据元素被称为头结点   2.最后一个元素没有后继元素，这个数据元素被称为尾结点   3.除了第一个和最后一个节点，其他的接口有且只有一个前驱和后继
《数据结构与算法》——表、栈和队列（顺序表）
weixin_50599081的博客
11-11 170
线性表： 线性表是最基本和常用的一类数据结构，它表示线性结构。 在线性结构中，数据元素之间存在着一对一的关系，其特点是数据元素之间按某种规定存在一个顺序关系。 线性表的两种存储结构：顺序表和链表。 定义： n个同类型数据元素的有限序列，记为：L=（a1,a2,a3…,ai…,an)。其中，n=0时为空表。 数据元素之间的关系： a(i-1)是ai的直接前驱，a(i+1)是ai的直接后继，除第一个元素外，均有唯一的前驱；除最后一个元素外，均有唯一的后继。 基本操作： 结构初始化、结构销毁、引用型、操作型。 初
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值