顺序表与链表实现双端队列与栈的增删

已于 2022-05-15 11:51:40 修改
阅读量240 收藏
点赞数
分类专栏： 数据结构与算法的复习 文章标签： 链表 数据结构 c语言
于 2022-05-14 21:04:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42847269/article/details/124774036
版权

本文的队列没有建立尾节点而是每次遍历到最后一个节点，在队列的相关操作中不太规范。

1.栈的增删与测试

#include <malloc.h>
#include <stdio.h>

#define Maxsize  10

/*顺序栈的数据结构定义*/
typedef struct {
	int data[Maxsize];
	int top;
}Stack;

/*链表栈的数据结构*/
typedef struct Stacknode {
	int data;
	Stacknode* next;
}Stacklist, Stacknode;


/*初始化栈*/
void Initial(Stack &S) {
	S.top = -1;
}

/*栈判空*/
int StackEmpty(Stack S) {
	if (S.top == -1) {
		return 1;
	}
	return 0;
}

/*栈判满*/
int StackFull(Stack S) {
	if (S.top == Maxsize - 1) {
		return 1;
	}
	return 0;
}

/*栈的push操作*/
int push(Stack& S, int val) {
	if (StackFull(S)) {
		return 1;
	}
	S.data[++S.top] = val;
	return 0;
}

/*栈的pop操作*/
int pop(Stack &S, int &val) {
	if (StackEmpty(S)) {
		return 1;
	}
	val = S.data[S.top--];
	return 0;
}

Stacklist* initStacklist(Stacklist* head) {
	head->next = NULL;
	head->data = 0;
	return head;
}

int listStackempty(Stacklist* head) {
	if (head->data == 0) {
		return 1;
	}
	return 0;
}

int listStackfull(Stacklist* head) {
	if (head->data == Maxsize) {
		return 1;
	}
	return 0;
}

Stacklist* listpush(Stacklist* head, int val) {
	Stacknode* node;
	node = (Stacknode*)malloc(sizeof(Stacknode));
	if (node == NULL || listStackfull(head)) {
		return NULL;
	}
	node->next = head->next;
	head->next = node;
	node->data = val;
	head->data++;
	return head;
}

Stacklist* listpop(Stacklist* head) {
	if (listStackempty(head)) {
		return NULL;
	}
	head->data--;
	head->next = head->next->next;
	return head;
}


int main() {
	Stacklist* S;
	int val;
	int count = Maxsize;
	Stacklist* rc;
	S = (Stacklist*)malloc(sizeof(Stacklist));
	if (S == NULL) {
		return 1;
	}
	S = initStacklist(S);
	while(count) {
		printf("plead enter the num to push:\n");
		scanf_s("%d", &val);
		S = listpush(S, val);
		count--;
	}
	/*链表栈的测试*/
	printf("\n");
	//while (count != 5) {
	//	S = listpop(S);
	//	count++;
	//}
	while (S->next) {
		printf("%d\n", S->next->data);
		S = S->next;
	}
	return 0;
	/*
	* 顺序栈的测试
	int rc;
	int value = 10;
	int rec;
	int count = 10;
	Stack S;
	Initial(S); //初始化栈
	while (count) {
		scanf_s("%d", &rec);
		push(S, rec);
		count--;
	}
	//push(S, value);
	count = 10;
	while (count) {
		pop(S, rec);
		count--;
	}
	//pop(S, rec);
	rc = StackEmpty(S);
	if (rc) {
		printf("Stack is empty\n");
	}
	rc = StackFull(S);
	if (rc) {
		printf("Stack is full\n");
	}
	printf("%d",rec);
	return 0;
	*/
}

2.顺序表实现队列增删

#include <stdio.h>
#define	Maxsize 10

//顺序表实现队列
typedef struct Queue {
	int data[Maxsize];
	int size;
}Queue;

//初始化队列
int initQueue(Queue& Q) {
	int i;
	for (i = 0; i < Maxsize; i++) {
		Q.data[i] = 0;
	}
	Q.size = 0;
	return 1;
}

//头部入队
int headEnqueue(Queue& Q, int num) {
	int i;
	if (Q.size == 0) {
		Q.data[0] = num;
	}
	else if(Q.size  == Maxsize){
		printf("\nQueue is full!\n");
		return 0;
	}
	else {
		for (i = Q.size - 1; i >= 0; i--) {
			Q.data[i + 1] = Q.data[i];
		}
		Q.data[0] = num;
	}
	Q.size++;
	return 1;
}

//头部出队
int headDequeue(Queue& Q) {
	int i;
	if (Q.size == 0) {
		return 0;
	}
	else{
		for (i = 0; i < Q.size - 1; i++) {
			Q.data[i] = Q.data[i + 1];
		}
		Q.data[Q.size - 1] = 0;
	}
	Q.size--;
	return 1;
}

//尾部入队
int tailEnqueue(Queue& Q, int num) {
	if (Q.size == Maxsize) {
		printf("\nQueue is full!\n");
		return 0;
	}
	Q.data[Q.size] = num;
	Q.size++;
	return 1;
}

//尾部出队
int tailDequeue(Queue& Q) {
	if (Q.size == 0) {
		return 0;
	}
	Q.size--;
	return 1;
}

int main() {
	Queue Q;
	int num, seq;
	int i;
	initQueue(Q);
	while (true) {
		printf("1.head enqueue\n2.head dequeue\n3.tail enqueue\n4.tail dequeue\n");
		printf("Please select your operation:");
		scanf_s("%d", &seq);
		switch (seq){
			case(1):{
				printf("please enter the num to headEnqueue: ");
				scanf_s("%d", &num);
				headEnqueue(Q, num);
				break;
			}
			case(2):{
				headDequeue(Q);
				break;
			}
			case(3): {
				printf("please enter the num to tailEnqueue: ");
				scanf_s("%d", &num);
				tailEnqueue(Q, num);
				break;
			}
			case(4): {
				tailDequeue(Q);
				break;
			}
			default:{
				printf("\nplease enter the num between 1 and 4");
				break;
			}
		}
		printf("\nThe present data int queue are:");
		for (i = 0; i <= Q.size-1; i++) {
			printf("%d ", Q.data[i]);
		}
		printf("\n");
	}
	return 0;
}

3.带头节点链表实现队列增删

#include <stdio.h>
#include <malloc.h>

typedef struct Queue {
	int value;
	Queue* next;
}Queue,Qnode;

Queue *initQueue(Queue* Q) {
	Q->value = 0;
	Q->next = NULL;
	return Q;
}

Queue* headDequeue(Queue* Q) {
	if (Q->value == 0) {
		return NULL;
	}
	Q->next = Q->next->next;
	Q->value--;
	return Q;
}

Queue* tailDequeue(Queue* Q) {
	if (Q->value == 0) {
		return NULL;
	}
	Qnode* current;
	current = Q;
	while (current->next->next) {
		current = current->next;
	}
	free(current->next);
	current->next = NULL;
	Q->value--;
	return Q;
}

Queue* headEnqueue(Queue* Q,int num) {
	Qnode* newnode;
	newnode = (Queue*)malloc(sizeof(Qnode));
	if (newnode == NULL) {
		return NULL;
	}
	newnode->value = num;
	newnode->next = NULL;
	newnode->next = Q->next;
	Q->next = newnode;
	Q->value++;
	return Q;
}

Queue* tailEnqueue(Queue* Q, int num) {
	Qnode* current;
	Qnode* newnode;
	newnode = (Qnode*)malloc(sizeof(Qnode));
	if (newnode == NULL) {
		return NULL;
	}
	current = Q;
	while (current->next) {
		current = current->next;
	}
	newnode->value = num;
	newnode->next = NULL;
	current->next = newnode;
	Q->value++;
	return Q;
}

int main() {
	Queue *Q;
	int seq, num;
	Q = (Queue*)malloc(sizeof(Queue));
	if (Q == NULL) {
		return 0;
	}
	Q = initQueue(Q);
	Qnode* current;
	current = (Qnode*)malloc(sizeof(Qnode));
	if (current == NULL) {
		return 0;
	}
	current = initQueue(current);
	while (true) {
		printf("1.head enqueue\n2.head dequeue\n3.tail enqueue\n4.tail dequeue\n");
		printf("Please select your operation:");
		scanf_s("%d", &seq);
		switch (seq){
			case(1):{
				printf("please enter the num to headEnqueue: ");
				scanf_s("%d", &num);
				Q = headEnqueue(Q, num);
				break;
			}
			case(2):{
				Q = headDequeue(Q);
				break;
			}
			case(3): {
				printf("please enter the num to tailEnqueue: ");
				scanf_s("%d", &num);
				Q = tailEnqueue(Q, num);
				break;
			}
			case(4): {
				Q = tailDequeue(Q);
				break;
			}
			default:{
				printf("\nplease enter the num between 1 and 4");
				break;
			}
		}
		printf("\nThe present data int queue are:");
		if (Q == NULL) {
			Q = (Queue*)malloc(sizeof(Queue));
			if (Q == NULL) {
				return 0;
			}
			Q = initQueue(Q);
			printf("\n");
		}
		else {
			current = Q->next;
			while (current) {
				printf("%d ", current->value);
				current = current->next;
			}
			printf("\n");
		}	
	}
	return 0;
}

4.不带头结点实现队列的增删（注意引用类型）

#include <stdio.h>
#include <malloc.h>

static int size = 0;
typedef struct Queue {
	int value;
	Queue* next;
}Queue,Qnode;

void initQueue(Queue*& Q) {
	Q->value = 0;
	Q->next = NULL;
}

int tailDequeue(Queue*& Q) {
	if (size == 0) {
		return 0;
	}
	else if(size == 1){
	} 
	else{
		Qnode* current;
		current = Q;
		while (current->next->next) {
			current = current->next;
		}
		free(current->next);
		current->next = NULL;
	}
	size--;
	return 1;
}

int headDequeue(Queue*& Q) {
	if (size == 0) {
		return 0;
	}
	if (size == 1) {
	}
	else {
		Q = Q->next;
	}
	size--;
	return 1;
}

int tailEnqueue(Queue*& Q, int num) {
	if (size == 0) {
		Q->value = num;
	}
	else {
		Qnode* current;
		current = Q;
		while (current->next) {
			current = current->next;
		}
		Qnode* newnode;
		newnode = (Qnode*)malloc(sizeof(Qnode));
		if (newnode == NULL) {
			return 0;
		}
		newnode->value = num;
		newnode->next = NULL;
		current->next = newnode;
	}
	size++;
	return 1;
}

int headEnqueue(Queue*& Q,int num) {
	if (size == 0) {
		Q->value = num;
	}
	else {
		Qnode* newnode;
		newnode = (Qnode*)malloc(sizeof(Qnode));
		if (newnode == NULL) {
			return 0;
		}
		newnode->value = num;
		newnode->next = Q;
		Q = newnode;
	}
	size++;
	return 1;
}

int main() {
	Queue *Q;
	int seq,num;
	Q = (Queue*)malloc(sizeof(Queue));
	if (Q == NULL) {
		return 0;
	}
	initQueue(Q);
	Qnode* current;
	current = (Qnode*)malloc(sizeof(Qnode));
	if (current == NULL) {
		return 0;
	}
	initQueue(current);
	while (true) {
		printf("1.head enqueue\n2.head dequeue\n3.tail enqueue\n4.tail dequeue\n");
		printf("Please select your operation:");
		scanf_s("%d", &seq);
		switch (seq) {
		case(1): {
			printf("please enter the num to headEnqueue: ");
			scanf_s("%d", &num);
			headEnqueue(Q, num);
			break;
		}
		case(2): {
			headDequeue(Q);
			break;
		}
		case(3): {
			printf("please enter the num to tailEnqueue: ");
			scanf_s("%d", &num);
			tailEnqueue(Q, num);
			break;
		}
		case(4): {
			tailDequeue(Q);
			break;
		}
		default: {
			printf("\nplease enter the num between 1 and 4");
			break;
		}
		}
		printf("\nThe present data int queue are:");
		if (size == 0) {
			printf("\n");
		}
		else {
			current = Q;
			while (current) {
				printf("%d ", current->value);
				current = current->next;
			}
			printf("\n");
		}
	}
	return 0;
}

5.总结

注意定义的size全局变量的++与--

可以用头节点的value计数或定义大小

引用类型与普通指针类型的区分

边界值的界定

isonu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言：用双向链表实现双端队列（队列两端都可以进行入队出队操作）
在路上
04-08 1万+
//双端队列的实现：队列左为端口1，队列右为端口2 #include #include #include #define LEN sizeof(struct DQueuelist) using namespace std; typedef struct DQueuelist //定义结构体结点 { int data; //结构体数据域 struct DQue
Python实现双端队列
12-22
双端队列的数据存储结构可以是顺序表，也可以是链表，本篇文章使用 Python 来分别实现顺序双端队列和链双端队列。 一、实现顺序双端队列 顺序双端队列是使用顺序表存储数据的双端队列，Python 中的列表元组都属于...
双端队列的物理实现（顺序双端队列+链式双端队列）
悲伤无声地涌出来
11-04 1022
说明 基于顺序表实现的顺序双端队列 基于链表实现的链式双端队列 一、说明 思路大致与队列相同，增添了从头部入队、尾部出队等操作。 再次感叹delete的耗时 二、基于顺序表实现的顺序双端队列 1、Deque.h #include&lt;iostream&gt; using namespace std; #ifndef _Deque #define _Deque namespace ...
队列--先进先出的线性表
Yangchenju的博客
07-29 6963
前面的文章介绍了线性表，后进先出的线性表–栈。本文介绍另一种特殊的链表–队列以及队列的增删查。 1.队列的定义 与栈相似，队列也是一种特殊的线性表，与线性表的不同之处也是体现在对数据的增和删的操作上。 队列的特点是先进先出： 先进，表示队列的数据新增操作只能在末端进行，不允许在队列的中间某个结点后新增数据; 先出，队列的数据删除操作只能在始端进行，不允许在队列的中间某个结点后删除数据。也就是说队列的增和删的操作只能分别在这个队列的队尾和队头进行。 与线性表、栈一样，队列也存在这两种存储方式，即顺序队列和
【经典算法题】用链表实现栈队列和双端队列
ai15013602354的博客
02-24 991
链表作为重要的数据结构，可以实现很多其它的数据结构，本文介绍几种可以用链表来实现的数据结构。
C#实现双端队列
qq_42696107的博客
08-26 1562
C#实现双端链表
共享栈和双端队列
＃两个西柚
08-03 1180
共享栈和双端队列 一、共享栈 相比于普通的顺序栈，共享栈主要是为了提高内存的利用率和减少溢出的可能性而设计的。 为了增加内存空间的利用率和减少溢出的可能性，当两个栈共享一篇连续的内存空间时，应将两栈的栈底分别设在这片内存空间的两端，这样当两个栈的栈顶在栈空间的某一位置相遇时，才产生上溢。 二、双端队列 双端队列是一种插入和删除操作在两端均可进行的线性表，可以把双端队列看成栈底连在一起的两个栈。他们与两个栈共享存储空间的共享栈的不同指出是，两个栈的栈顶指针式向两端延伸的。由于双端队列允许在两端插入和删除元素，
Java单链表和双链表的反转及实现队列、栈和双端队列
DreamsArchitects的博客
02-05 1540
算法与数据结构基础：介绍单链表和双链表结构、链表反转及实现队列、栈和双端队列
循环队列与双端队列
MJ6666666的博客
01-14 593
ArrayQueue 队列的顺序存储结构本身是由ArrayList实现的 在数据元素入队的时候，相对于在ArrayList表尾添加元素 在数据元素出队的时候，相当于在ArrayList表头删除元素 很明显，入队的时间复杂度O(1)，出队的时间复杂度为O(n) 线性表增删数据元素时间复杂符都是O(n)，但是这个是按平均算的 队列的出队时间复杂度O(n)，可不是按平均算的，因为每次出队都是O(n） 循环队列ArrayLoopQueue 该循环队列的实现思想也是动态数组 但是由于操作元素的特殊性，并不能直接由Ar
数据结构与算法（八）——双端队列
shsbsns的博客
09-05 1943
双端队列（Double-ended Queue，简称Deque）是一种具有队列和栈特性的数据结构，可以在队列的两端进行插入和删除操作。双端队列允许从前端和后端同时进行插入和删除操作，因此可以称为“两端都可以进出的队列”。双端队列有以下几个特点：1、可以在队列的头部和尾部进行插入和删除的操作。2、元素的插入和删除操作可以分别称作入队和出队操作。3、可以进行先进先出（FIFO）和先进后出（LIFO）两种操作方式。4、可以实现栈和队列以及其他需要在两端进行插入和删除操作的场景。
python链表实现栈_day24.顺序表＆链表＆栈＆队列Python教程
weixin_39665762的博客
11-23 75
day24.顺序表&链表&栈&队列【Python教程】一、顺序表在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关...
人工智能-项目实践-python-顺序表、链表、栈、队列、树、Hashmap等数据结构；排序、二分法查找、树遍历等常见算法实现
12-28
人工智能-项目实践-python-顺序表、链表、栈、队列、树、Hashmap等数据结构；排序、二分法查找、树遍历等常见算法实现 顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术 链表 单向链表 双向链表 单向...
python数据结构与算法，python入门、竞赛必备
04-27
2.2. 顺序表的结构与实现 2.3. 顺序表的操作 2.4. Python中的顺序表 3. 链表 3.1. 单向链表 3.2. 单项循环链表 3.3. 双向链表 4. 栈 4.1. 栈结构实现 5. 队列 5.1. 队列的实现 5.2. 双端队列 6. 排序与搜索 6.1. ...
数据结构与算法总结(上)
11-27
曾经学了一学期数据结构，不少内容上来分享下，包括：HASH表，栈，双端循环链表，顺序表，顺序栈类，线性链表，循环队列，循环链表等。。。还有图，树，邻接表，矩阵那些有时间到整理下吧，共享无敌！
数据与结构--二叉树
weixin_66905164的博客
05-10 949
树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成的一个具有层次关系的集合。树的特点：有一个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)互不相交的集合T1,T2…Tm，其中每一个集合Ti(1<=i<=m)又是一颗结构与树类似的子树。每棵子树的根结点有且仅有一个前驱，可以有0个或多个后继。因此，树是递归定义的。节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6叶节点或终端节点：度为0的节点称为叶节点；
C++的数据结构(一）
winterling的博客
05-11 425
C++的数据结构(一）：链表，栈，二叉搜索树
数据结构：栈和队列
2302_81342533的博客
05-11 652
本文将详细介绍栈和队列的数据结构，并给出编译举例方便读者理解。 队列和栈，是数据结构中继顺序表链表以来又一个大章，是链表、顺序表的具体应用方式。他们是相互关联的，不同之处在于队列和栈离实际的应用更近一步。
数据结构——队列
最新发布
babilunlaobanjiu的博客
05-11 197
原来 1 2 3 4 入队 出队两次， 变成 3 4 .
5/11后面部分：+顺序排序+元素交换+计算每门课程的各种成绩+存放规律的数据 注意：一味的复制肯定要出问题，第2个的最后一部分有修改，注意观察
2201_75637762的博客
05-11 632
i++)j < i;j++)printf("排序完成的数组为：");i < 10;int main()printf("请输入值:\n");i < m;j < m;i < m;j < m;
优先队列和双端队列的异同
06-08
双端队列可以使用数组或链表来实现，它的主要操作包括在队列的两端插入和删除元素，这些操作的时间复杂度为 O(1)。 因此，虽然优先队列和双端队列都是队列的一种，但它们的目的和操作方式不同。优先队列注重元素的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值