用链表、顺序表模拟实现栈和队列

最新推荐文章于 2023-02-23 21:09:05 发布
最新推荐文章于 2023-02-23 21:09:05 发布
阅读量989 收藏 4
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZWE7616175/article/details/78493649
版权 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
/*1.编写函数,采用链式存储实现栈的初始化、入栈、出栈操作
2.编写函数,采用顺序存储实现栈的初始化、入栈、出栈操作
3.编写函数,采用链式存储实现队列的初始化、入队、出队操作
4.编写函数,采用顺序存储实现队列的初始化、入队、出队操作*/

/链式存储实现栈的初始化、入栈、出栈///
typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node* next;
}LinkStackNode, *LinkStack;

//链式存储实现栈的初始化
void InitStack_Link(LinkStack* top)
{
	LinkStackNode *tmp = (LinkStackNode *)malloc(sizeof(LinkStackNode));//头结点
	if (tmp == NULL)
		return;
	tmp->data = 0;
	tmp->next = NULL;
	*top = tmp;
}

//链式存储实现栈的入栈
void Push_Link(LinkStack top, DataType x)
{
	LinkStackNode* tmp;
	tmp = (LinkStackNode*)malloc(sizeof(LinkStackNode));//申请空间
	if (tmp == NULL)
		return;
	tmp->data = x;
	tmp->next = top->next;
	top->next = tmp;//修改栈顶指针
}

//链式存储实现栈的出栈
void Pop_Link(LinkStack top,DataType* x)
{
	LinkStackNode* tmp;
	tmp = top->next;
	if (tmp == NULL)//空栈
	{
		return;
	}
	*x = tmp->data;
	top->next = tmp->next;
	free(tmp);
}

void Print(LinkStack top)
{
	LinkStackNode* ss=top->next;
	if (top == NULL)
		return;
	else
	{
		while (ss != NULL)
		{
			printf("%d ", ss->data);
			ss = ss->next;
		}
		printf("\n");
	}
}

顺序存储实现栈的初始化、入栈、出栈操作/
#define Size 20
typedef struct
{
	DataType arr[Size];
	int top;
}SeqStack;

//顺序存储实现栈的初始化
void InitStack_Seq(SeqStack* s)
{
	s->top = -1;//空栈
}

//顺序存储实现栈的入栈
int Push_Seq(SeqStack* s, DataType x)
{
	if (s->top == Size - 1)//栈满
		return 0;
	s->top++;
	s->arr[s->top] = x;
	return 1;
}

//顺序存储实现栈的出栈
int Pop_Seq(SeqStack* s, DataType* x)
{
	if (s->top == -1)//栈空
		return 0;
	else
	{
		*x = s->arr[s->top];
		s->top--;
		return 1;
	}
}

void Print_Seq_Stack(SeqStack s)
{
	int i = 0;
	for (i = 0; i <= s.top; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

//采用链式存储实现队列的初始化、入队、出队操作
typedef struct qNode
{
	DataType data;
	struct qNode* next;
}LinkQueueNode;

typedef struct
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
}LinkQueue;

//链式存储实现队列的初始化
void InitQue(LinkQueue* q)
{
	q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (q->front == NULL)
	{
		return;
	}
	else
	{
		q->rear = q->front;
		q->front->next = NULL;
	}
}

//链式存储实现队列的入队
void EnterQueue(LinkQueue* q, DataType x)
{
	LinkQueueNode* NewNode;
	NewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (NewNode != NULL)
	{
		NewNode->data = x;
		NewNode->next = NULL;
		q->rear->next = NewNode;
		q->rear = NewNode;
	}
	else
		return;
}

//链式存储实现队列的出队
void OutQueue(LinkQueue* q, DataType* x)
{
	LinkQueueNode* first = q->front->next;
	if (first == NULL)//队列为空
		return;
	if (first->next == NULL)//队列中只有一个元素
	{
		*x = first->data;
		q->rear = q->front;
		q->front->next = NULL;
	}
	else
	{
		*x = first->data;
		q->front->next = first->next;
	}
	free(first);
	first = NULL;
}

void Print_Link_Queue(LinkQueue* q)
{
	LinkQueueNode* cur = q->front;
	if (q->front == q->rear)
		return;
	while (cur != q->rear)
	{
		cur = cur->next;
		printf("%d ", cur->data);
	}
	printf("\n");
}


顺序存储实现队列的初始化、入栈、出栈操作/
#define Size 20
typedef struct
{
	DataType arr[Size];
	int front;
	int rear;
}SeqQueue;

//顺序存储实现循环队列的初始化
void SInitQueue(SeqQueue* q)
{
	q->front = q->rear = 0;
}

//顺序存储实现循环队列的入队
int SEnterQueue(SeqQueue* q, DataType data)
{
	if ((q->rear + 1)%Size==q->front)//队列满
		return 0;
	
	q->arr[q->rear] = data;
	q->rear = (q->rear+1) % Size;
	return 1;
}

//顺序存储实现循环队列的出队
int SOutQueue(SeqQueue* q, DataType* x)
{
	if (q->front==q->rear)//队列空
		return 0;
	*x = q->arr[q->front];
	q->front = (q->front + 1)%Size;
	return 1;
}

void Print_SQueue(SeqQueue* q)
{
	int i = q->front;
	if (q->front == q->rear)
	{
		printf("此时队列为空！\n");
	}
	while (i != q->rear)
	{
		printf("%d ", q->arr[i]);
		i++;
		i = i % Size;
	}
	printf("\n");
}
void menu()
{
	printf("******************菜  单******************\n");
	printf("**1.链栈入栈*************2.链栈出栈*******\n");
	printf("**3.顺序栈入栈***********4.顺序栈出栈*****\n");
	printf("**5.链队入队*************6.链队出队*******\n");
	printf("**7.顺序队列入队*********8.顺序队列出队***\n");
	printf("******************************************\n");
}


int main()
{
	DataType a;
	LinkQueue q;
	SeqQueue q1;
	SeqStack s;
	LinkStackNode* head = NULL;

	menu();
	int n = 0;
	while (1)
	{
		printf("请选择：>");
		scanf("%d", &n);
		switch (n)
		{
		case 1:
			printf("链栈压栈过程：\n");
			InitStack_Link(&head);
			Push_Link(head, 1);
			Print(head);
			Push_Link(head, 2);
			Print(head);
			Push_Link(head, 3);
			Print(head);
			Push_Link(head, 4);
			Print(head);
			Push_Link(head, 5);
			Print(head);
			Push_Link(head, 6);
			Print(head);
			
			break;
		case 2:
			printf("链栈出栈过程：\n");
			InitStack_Link(&head);
			Push_Link(head, 1);
			Push_Link(head, 2);
			Push_Link(head, 3);
			Push_Link(head, 4);
			Push_Link(head, 5);
			Push_Link(head, 6);
			Print(head);

			Pop_Link(head, &a);
			Print(head);
			Pop_Link(head, &a);
			Print(head);
			Pop_Link(head, &a);
			Print(head);
			Pop_Link(head, &a);
			Print(head);
			Pop_Link(head, &a);
			Print(head);
			Pop_Link(head, &a);
			Print(head);
			break;
		case 3:
			printf("顺序栈压栈过程：\n");
			InitStack_Seq(&s);
			Push_Seq(&s, 1);
			Print_Seq_Stack(s);
			Push_Seq(&s, 2);
			Print_Seq_Stack(s);
			Push_Seq(&s, 3);
			Print_Seq_Stack(s);
			Push_Seq(&s, 4);
			Print_Seq_Stack(s);
			Push_Seq(&s, 5);
			Print_Seq_Stack(s);
			Push_Seq(&s, 6);
			Print_Seq_Stack(s);
			break;
		case 4:
			printf("顺序栈出栈过程：\n");
			InitStack_Seq(&s);
			Push_Seq(&s, 1);
			Push_Seq(&s, 2);
			Push_Seq(&s, 3);
			Push_Seq(&s, 4);
			Push_Seq(&s, 5);
			Push_Seq(&s, 6);
			Print_Seq_Stack(s);

			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			Pop_Seq(&s, &a);
			Print_Seq_Stack(s);
			break;
		case 5:
			printf("链队列压栈过程：\n");
			InitQue(&q);
			EnterQueue(&q, 1);
			Print_Link_Queue(&q);
			EnterQueue(&q, 2);
			Print_Link_Queue(&q);
			EnterQueue(&q, 3);
			Print_Link_Queue(&q);
			EnterQueue(&q, 4);
			Print_Link_Queue(&q);
			EnterQueue(&q, 5);
			Print_Link_Queue(&q);
			EnterQueue(&q, 6);
			Print_Link_Queue(&q);
			break;
		case 6:
			printf("链队列出栈过程：\n");
			InitQue(&q);
			EnterQueue(&q, 1);
			EnterQueue(&q, 2);
			EnterQueue(&q, 3);
			EnterQueue(&q, 4);
			EnterQueue(&q, 5);
			EnterQueue(&q, 6);
			Print_Link_Queue(&q);

			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			OutQueue(&q, &a);
			Print_Link_Queue(&q);
			break;
		case 7:
			printf("循环队列压栈过程：\n");
			SInitQueue(&q1);
			SEnterQueue(&q1, 1);
			Print_SQueue(&q1);
			SEnterQueue(&q1, 2);
			Print_SQueue(&q1);
			SEnterQueue(&q1, 3);
			Print_SQueue(&q1);
			SEnterQueue(&q1, 4);
			Print_SQueue(&q1);
			SEnterQueue(&q1, 5);
			Print_SQueue(&q1);
			break;
		case 8:
			printf("循环队列出栈过程：\n");
			SInitQueue(&q1);
			SEnterQueue(&q1, 1);
			SEnterQueue(&q1, 2);
			SEnterQueue(&q1, 3);
			SEnterQueue(&q1, 4);
			SEnterQueue(&q1, 5);
			Print_SQueue(&q1);

			SOutQueue(&q1, &a);
			Print_SQueue(&q1);
			SOutQueue(&q1, &a);
			Print_SQueue(&q1);
			SOutQueue(&q1, &a);
			Print_SQueue(&q1);
			SOutQueue(&q1, &a);
			Print_SQueue(&q1);
			break;
		default:
			printf("选择错误，请重新选择！\n");
		}
	}
	system("pause:");
	return 0;
}

用数组实现链表、栈和队列
⚡
01-26 1277
详解用数组实现单链表、双链表、栈和队列
用链表模拟实现队列（FIFO）
m0_64770095的博客
05-30 3732
你还不会循环队列吗.赶快来看看吧
链表，顺序表，队列，栈的实现
09-19
这里有顺序变，链表，栈，队列的实现的完整程序，程序附加有大量说明，链表中还包含循环链表，双向链表，同时又串，图的程序。
使用顺序表和链表实现栈和队列
DengLange的博客
03-09 300
一、栈 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈，出数据在栈顶。 栈的核心操作： 入栈：把元素放到栈里 出栈：把最后进来的元素删掉 取栈顶元素：获取到最后一个进来的元素的结果 使用顺序表实现栈： 使用尾插操作表示入栈；使用尾删操作表示出栈；使用根据下表获取元素的操作表示取栈顶元素 publi..
链式队列—用链表来实现队列 （思路与实现）
weixin_45894950的博客
12-10 916
链式队列（先进先出） 用链表来实现队列 class Node { public int data; public Node next; //每次new一个节点 就要调用它的构造方法 public Node(int data) { this.data = data; } } public class MyQueue { public int usedSize; public Node front;//队列的头 public N
队列的模拟实现（单链链表模拟）
qq_58724706的博客
11-02 601
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出，后进后出特特点。 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 。 出队列：进行删除操作的一端称为队头。 目录 队列的结构体创建 队列的函数接口 void QueueInit(Queue* q) void QueuePush(Qu..
链表，顺序表的基本操作及其实现的栈与队列
Flanz_Hawk的博客
12-23 579
1，顺序表 在c里面，这一部分也就是静态表和动态表的实现，插入，删除有丁点意思。 静态表靠数组和长度实现（注意长度这一点，因为它反映了当前表内容长度，十分重要） 动态表依靠申请连续空间实现（结构体内部包括首地址，当前规模以及长度） 插入： int *p; p=&(w.a[k-1]); int *q; for(q=&(w.a[w.length-1]);q>=p;--q) {
链表-使用Python基于链表实现的多种队列数据结构比较.zip
最新发布
03-13
本资料包“链表-使用Python基于链表实现的多种队列数据结构比较”着重探讨了如何利用Python语言来实现不同类型的队列数据结构，其中队列是一种先进先出（FIFO）的数据结构，常用于任务调度、缓冲区管理和多线程通信...
数据结构之表（顺序表、链表、栈、队列）（一对一关系）
Glanic的博客
08-17 812
顺序表和链式表的实现 顺序表： 数据项： 存储元素的内存首地址 表的容量 元素的数量 运算： 创建、销毁、清空、插入、删除、访问、查询、修改、排序、遍历 注意点： 1、不要越界 2、时刻保持元素的连续性 优点：支持随机访问，修改、访问、排序的效率比较高，大块的连续的内存不容易产生内存碎片 缺点：对内存的要求比较高(内存连续)，插入、删除元素时很不方便、效
用链表实现队列（数据结构复习笔记一）
蜂蜂的博客
02-23 821
用链表实现队列
采用顺序存储实现栈的初始化、入栈、出栈操作
01-05
nt main(int argc, char *argv[]) { int e; SqStack l1; Linkst l2; Queue l3; LinkQueue l4; cout<<"请输入数列的个数"<>le; cout<<"请输入数字选择您要的线性存储结构："<<endl<<"0、顺序栈结构，1、链式栈结构，2.顺序队列，3、链式队列" <>a; cout<<"请输入数列"<<endl; switch(a) { case 0:InitStack(l1); for(int i=0;i>e;Push(l1,e);} while(le--){Pop(l1,e);cout<<e<<" ";} break; case 1:Initlink(l2); for(int i=0;i>e;push(l2,e);} while(le--){pop(l2,e);cout<<e<<" ";} break; case 2:InitQueue(l3); for(int i=0;i>e;Push1(l3,e);} while(le--){Pop1(l3,e);cout<<e<<" ";} break; case 3:InitQue(l4); for(int i=0;i>e;push1(l4,e);} while(le--){pop1(l4,e);cout<<e<<" ";} break; } system("PAUSE"); return 0; }
顺序栈的表示和实现
asddoa的博客
10-12 211
准备工作 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<windows.h> //函数结果状态字符 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 顺序栈的表示（用指针来操作数组中的元素）
【数据结构】顺序队列（链表实现）
Begin
06-27 407
队列介绍 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。 进行插入操作的一端称为队尾，通常称为入队列；进行删除操作的一端称为队头，通常称为出队列。队列具有先进先出的特性(FIFO)。 队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而异，将其称为链队列。 实现代码： //队列必须一端进行插入（队头）一端进行删除（队尾） #if
顺序栈&链栈&循环队列&链队基本操作的实现
如无必要勿增实体
02-24 3312
实验三 顺序栈和队列基本操作的实现 一、实验学时： 2学时 二、实验目的 实现顺序栈和队列的基本操作 三、实验内容 顺序栈的建立、取栈顶元素、入栈、出栈 队列的建立、取队中元素、入队、出队、循环队列中入队、出队操作 四、主要仪器设备及耗材 硬件：计算机一台 软件：VC++ 6.0，MSDN2003或者以上版本 五、实验步骤 分析问题 写出算法 编制程序 上机调试 分析结果 六、程序...
利用顺序表实现栈 利用单链表实现队列
lxb18821659801的博客
07-03 193
利用顺序表实现栈#define _CRT_SECURE_NO_WARNINGS 1#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#include&lt;stack&gt;#define stack_max_num 10struct SeqStack{ int MAXNUM; int t;//始终指向栈顶 int *s;};typedef struct...
数据结构——顺序栈的实现（初始化，进栈，出栈，获取栈顶元素，判空，判满）C/C++实现
m0_63339166的博客
10-04 1421
【代码】数据结构——顺序栈的实现（初始化，进栈，出栈，获取栈顶元素，判空，判满）
栈的顺序表和链表实现代码
zmm0628的博客
04-27 750
第三章代码 不知不觉已经第三章了。坚持更新，虽然可能看到的人比较少。人气也不高。但是知道自己懂了进步了就可以了。 栈（用顺序表实现栈） #include<stdio.h> #define Maxsize 10 //定义栈结构 typedef struct{ int data[Maxsize];//数组 int top;//逻辑上充当栈指针 }SqStack; //初始化栈 void Initstack(SqStack &S){ S.top=-1; } //判空 bool Emp
栈以及队列的实现与基本操作
一个计算机爱好者学习历程
12-02 1778
目录 一、栈 1.栈的基本概念 2.如何实现一个栈 1.>用数组实现一个可以动态增长的栈（建议） 2.>栈的链式存储 3.栈的基本操作 1.>栈的创建 2.>栈的初始化 3.>入栈操作 4.>出栈操作 5.>获取栈顶元素 6.>栈空的判断 7.>栈的销毁 二、队列 1.队列的基本概念 2.如何实现一个基本队列 1.>顺序队的实现 2.>链队的实现 3.>循环队列的实现 3.队列的基本操作（..
Python 列表，for循环，元组的使用【修改、添加、删除、排序、切片】w
weixin_41920179的博客
09-13 2934
Python内置的数据结构有： 列表(list) 元组(tuple) 字典(dict) 集合(set) 在Python语言中，以上4种数据结构和基础数据类型（整数、浮点数等）统称为“内置类型”（Built-in Types）。 一、什么是列表 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。 Python有6个序列的内置类型，但最常见的是列表和元组。 序列都可以进行的操作包括索引，切片，加，乘，检查成员。 此外，Pytho
数据结构基础：数组、链表、栈、队列简易实现
"本文将介绍常见数据结构的简单实现，包括数组、链表、栈和队列，并提供相应的Python代码示例。数据结构是编程中不可或缺的基础，它们用于有效地存储和管理数据，优化算法的效率。了解并掌握各种数据结构的特点和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值