Stacks and queues

最新推荐文章于 2020-03-05 11:48:19 发布
最新推荐文章于 2020-03-05 11:48:19 发布
阅读量450 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangxt211/article/details/38876731
版权 

//============================================================
// 使用数组实现的栈 20140613
//============================================================
#include <stdio.h>
#include <stdlib.h>

typedef	int StackElem;
typedef struct stack {
	int top;  // 指向栈顶元素
	int size; // 栈大小capacity
	StackElem *arr;
} *STACK;

#ifndef ERROR
#define ERROR -1
#endif

//============================================================
// 初始化栈
//============================================================
STACK InitializeStack(STACK S, int n)
{
	S = (STACK)malloc(sizeof(struct stack));
	if (!S) {
		printf("s malloc error\n");
		return NULL;
	}
	S->arr = (StackElem *)malloc(sizeof(StackElem) * n);
	if (!S->arr) {
		free(S);
		printf("s->arr malloc error\n");
		return NULL;
	}
	S->size = n;
	S->top = -1; // careful
	return S;
}

//============================================================
// 判断栈是否为空
//============================================================
bool StackEmpty(STACK S)
{
	return S->top == -1; // careful
}

//============================================================
// 判断栈是否满
//============================================================
bool StackFull(STACK S)
{
	return S->top == S->size - 1;
}

//============================================================
// 进栈（top为最近插入元素的索引）
//============================================================
void Push(STACK S, StackElem x)
{
	if (StackFull(S)) {
		printf("overflow\n");
		return ;
	} else {
		// S->top = S->top + 1;
		// S->arr[S->top] = x;
		S->arr[++S->top] = x;
	}
}

//============================================================
// 出栈
//============================================================
StackElem Pop(STACK S)
{
	if (StackEmpty(S)) {
		printf("underflow\n");
		return ERROR;
	} else {
		// S->top = S->top - 1;
		// return S->arr[S->top + 1];
		return S->arr[S->top--];
	}
}

//============================================================
// 输出栈中元素
//============================================================
void StackPrint(STACK S)
{
	if (StackEmpty(S))
		return ;

	for (int i = 0; i <= S->top; i++)
		printf("%d\t", S->arr[i]);
	printf("\n");
}

int main()
{
	int arr[] = {45, 65, 56, 2, 542, 6, 89, 21, 97, 60};
	int len = sizeof(arr) / sizeof(arr[0]);
	STACK S = NULL;

	S = InitializeStack(S, len - 1);
	for (int i = 0; i < len; i++) {
		Push(S, arr[i]);
		printf("%d\t", arr[i]);
	}
	printf("\n");

	for (int i = 0; i < len; i++) {
		StackElem val = Pop(S);
		if (val != ERROR)
			printf("%d\t", val);
	}
	printf("\n");

	system("pause");
	return 0;
}
//============================================================
// 使用链表实现的栈 20140613
//============================================================
#include <stdio.h>
#include <stdlib.h>

typedef	int StackElem;

typedef struct snode {
	StackElem elem;
	struct snode *next;
} SNode;

typedef struct stack {
	struct snode *top;
} *STACK;

#ifndef ERROR
#define ERROR -1
#endif

//============================================================
// 初始化栈
//============================================================
STACK InitializeStack(STACK S, int n)
{
	S = (STACK)malloc(sizeof(struct stack));
	if (!S) {
		printf("s malloc error\n");
		return NULL;
	}
	S->top = NULL;

	return S;
}

//============================================================
// 判断栈是否为空
//============================================================
bool StackEmpty(STACK S)
{
	return S->top == NULL;
}


//============================================================
// 进栈
//============================================================
void Push(STACK S, StackElem x)
{
	struct snode *p = (struct snode *)malloc(sizeof(struct snode));
	if (!p) {
		printf("p malloc error\n");
		return ;
	}
	p->elem = x;
	p->next = NULL;

	p->next = S->top; // 在S->top后插入
	S->top = p;
}

//============================================================
// 出栈
//============================================================
StackElem Pop(STACK S)
{
	if (StackEmpty(S)) {
		printf("underflow\n");
		return ERROR;
	} 

	StackElem x = S->top->elem;
	struct snode *p = S->top; // 临时保存待删除的结点
	S->top = S->top->next;
	free(p);

	return x;
}

//============================================================
// 输出栈中元素
//============================================================
void StackPrint(STACK S)
{
	struct snode *p = S->top;
	while (p) {
		printf("%d\t", p->elem);
		p = p->next;
	}
	printf("\n");
}

//============================================================
// 获得栈的大小
//============================================================
int GetStackSize(STACK S)
{
	int size = 0;
	struct snode *p = S->top;
	while (p) {
		size++;
		p = p->next;
	}

	return size;
}

int main()
{
	int arr[] = {45, 65, 56, 2, 542, 6, 89, 21, 97, 60};
	int len = sizeof(arr) / sizeof(arr[0]);
	STACK S = NULL;

	S = InitializeStack(S, len - 1);
	for (int i = 0; i < len; i++) {
		Push(S, arr[i]);
		printf("size = %d\n", GetStackSize(S));
		StackPrint(S);
	}
	
	for (int i = 0; i < len; i++) {
		StackElem val = Pop(S);
		if (val != ERROR) {
			printf("size = %d\n", GetStackSize(S));
			StackPrint(S);
		}
	}

	system("pause");
	return 0;
}


//============================================================
// 使用数组实现的循环队列 20140613
//============================================================
#include <stdio.h>
#include <stdlib.h>

typedef	int QueueElem;
typedef struct queue {
	int head;  // 队列头
	int tail;  // 队列尾
	int size;  // 队列大小capacity
	QueueElem *arr;
} *QUEUE;

#ifndef ERROR
#define ERROR -1
#endif

//============================================================
// 初始化队列
//============================================================
QUEUE InitializeQueue(QUEUE Q, int n)
{
	Q = (QUEUE)malloc(sizeof(struct queue));
	if (!Q) {
		printf("Q malloc error\n");
		return NULL;
	}
	Q->arr = (QueueElem *)malloc(sizeof(QueueElem) * (n + 1));
	if (!Q->arr) {
		printf("Q->arr malloc error\n");
		return NULL;
	}
	Q->size = n;
	Q->head = Q->tail = 0;
	return Q;
}

//============================================================
// 判断队列是否为空
//============================================================
bool QueueEmpty(QUEUE Q)
{
	return Q->head == Q->tail;
}

//============================================================
// 判断对垒是否满（careful）
//============================================================
bool QueueFull(QUEUE Q)
{
	return Q->head == (Q->tail + 1) % Q->size;
}

//============================================================
// 进队列
//============================================================
void Enqueue(QUEUE Q, QueueElem x)
{
	if (QueueFull(Q)) {
		printf("overflow\n");
		return;
	}
	Q->arr[Q->tail] = x;
	if (Q->tail == Q->size) // 到数组的末端，卷绕
		Q->tail = 0;
	else
		Q->tail++;
}

//============================================================
// 出队列
//============================================================
QueueElem Dequeue(QUEUE Q)
{
	if (QueueEmpty(Q)) {
		printf("underflow\n");
		return ERROR;
	}
	int x = Q->arr[Q->head];
	if (Q->head == Q->size) // 到数组的末端，卷绕
		Q->head = 0;
	else
		Q->head++;
	return x;
}

int main()
{
	int arr[] = {45, 65, 56, 2, 542, 6, 89, 21, 97, 60};
	int len = sizeof(arr) / sizeof(arr[0]);
	QUEUE Q = NULL;

	Q = InitializeQueue(Q, len - 1);
	for (int i = 0; i < len; i++) {
		Enqueue(Q, arr[i]);
		printf("%d\t", arr[i]);
		printf("head:%d, tail:%d\n", Q->head, Q->tail);
	}

	for (int i = 0; i < len; i++) {
		QueueElem val = Dequeue(Q);
		if (val != ERROR)
			printf("%d\t", val);
		printf("head:%d, tail:%d\n", Q->head, Q->tail);
	}

	system("pause");
	return 0;
}

//============================================================
// 使用链表实现的循环队列 20140613
//============================================================
#include <stdio.h>
#include <stdlib.h>

typedef	int QueueElem;

typedef struct qnode {
	QueueElem elem;
	struct qnode *next;
} QNode;

typedef struct queue {
	struct qnode *front;
	struct qnode *rear;
} *QUEUE;

#ifndef ERROR
#define ERROR -1
#endif

//============================================================
// 初始化队列
//============================================================
QUEUE InitializeQueue(QUEUE Q)
{
	Q = (QUEUE)malloc(sizeof(struct queue));
	if (!Q) {
		printf("Q malloc error\n");
		return NULL;
	}
	Q->front = NULL;
	Q->rear = NULL;

	return Q;
}

//============================================================
// 判断队列是否为空
//============================================================
bool QueueEmpty(QUEUE Q)
{
	return Q->front == NULL;
}

//============================================================
// 进队列
//============================================================
void Enqueue(QUEUE Q, QueueElem x)
{
	struct qnode *p = (struct qnode *)malloc(sizeof(struct qnode));
	if (!p) {
		printf("q malloc error\n");
		return ;
	}
	p->elem = x;
	p->next = NULL;

	if (QueueEmpty(Q)) {
		Q->front = p;
		Q->rear = p;
	} else {
		Q->rear->next = p; // 将新元素插到链表尾部
		Q->rear = p;       // 更新Q->rear的位置
	}
}

//============================================================
// 出队列
//============================================================
QueueElem Dequeue(QUEUE Q)
{
	if (QueueEmpty(Q)) {
		printf("underflow\n");
		return ERROR;
	}

	int x = Q->front->elem;     // Q->front != NULL
	struct qnode *p = Q->front; // 临时保存待删除的结点
	Q->front = Q->front->next;  // if (Q->front == NULL) Q->rear = NULL;
	free(p);

	return x;
}

//============================================================
// 获得队列大小
//============================================================
int GetQueueSize(QUEUE Q)
{
	int size = 0;
	struct qnode *p = Q->front;
	while (p) {
		size++;
		p = p->next;
	}

	return size;
}

//============================================================
// 打印队列
//============================================================
void PrintQueue(QUEUE Q)
{
	struct qnode *p = Q->front;
	while (p) {
		printf("%d\t", p->elem);
		p = p->next;
	}
	printf("\n");
}

int main()
{
	int arr[] = {45, 12, 56, 3, 542, 6, 89, 21, 97, 60};
	int len = sizeof(arr) / sizeof(arr[0]);
	QUEUE Q = NULL;

	Q = InitializeQueue(Q);
	for (int i = 0; i < len; i++) {
		Enqueue(Q, arr[i]);
		printf("size = %d\n", GetQueueSize(Q));
		PrintQueue(Q);
	}

	for (int i = 0; i < len; i++) {
		QueueElem val = Dequeue(Q);
		if (val != ERROR) {
			printf("size = %d\n", GetQueueSize(Q));
			PrintQueue(Q);
		}
	}

	system("pause");
	return 0;
}


jiangxt211
关注
专栏目录
5.20 Stacks and Queues
weixin_33937778的博客
05-21 81
Remove K Digits 题目：给出一个非负的整数num, 用字符串表示，去掉k个digits之后得到一个最小的新数字 思路： Zuo-生成窗口最大值数组 - 239. Sliding Window Maximum 给出一个整型数组arr和一个大小为w的窗口，从左向右滑动窗口，然后每一个窗口内会有一个最大值，用一个新数组记录每一个窗口的最大值并最终输出该数组。 双向队列里面存放的数组下标...
5.26 Stacks and Queues
weixin_34221276的博客
05-27 69
Remove K Digits 题目： 给定一个Num字符串来表示一个非负的整数，移除其中k位字符，使得新生成的数字最小。 思路：将高位数字提前删除 对于leading zero需要小心处理 Largest Rectangle in Histogram Stack 里面存什么？ -> heights中的元素index Stack 什么时候 pop() 元素 -> 当前的heigh...
5.16 Stacks and Queues
weixin_33778544的博客
05-17 77
Min Stack 思路： 两种解法： 1. 两个栈，一个栈存所有的element, 另一个栈存最小的当前栈中的最小元素， ```java class MinStack { Stack stackMin; //store the min element Stack stack; //int min; //多余 不需要这个全局最小值， 用stackMin.peek() 来记录全局最小值即可 } ...
【CareerCup】Stacks and Queues—Q3.2
兰亭风雨的专栏
03-29 2686
翻译： 只用一个数组实现三个栈 思路： 用一个数组实现一个栈很容易，我们在Q3.1中也是用数组来模拟栈的。如果要用一个数组来实现三个栈，在压栈的时候，不管是哪个栈的push操作，直接将元素顺序压入到数组中，同时将本栈的栈顶索引指针指刚刚压入的元素即可，如下图所示（三种颜色分别代表三个栈，箭头指向每个栈的栈顶）：
Interview Questions: Stacks and Queues
Mapoos
07-04 319
Interview Questions: Stacks and Queues Queue with two stacks. Implement a queue with two stacks so that each queue operations takes a constant amortized number of stack operations. 利用两个栈来实现队列，具体方法为：...
数据结构英文教学课件：chapter4 Stacks and Queues.ppt
06-16
在本章"Chapter 4 Stacks and Queues"中，我们将深入探讨两种重要且基础的数据结构：栈和队列。这些数据结构在计算机科学的多个领域，如算法、编译器设计、操作系统等，都有着广泛的应用。 首先，栈（Stack）是一种...
Java Methods-Stacks and Queues.ppt
最新发布
09-05
Java中的栈（Stack）和队列（Queue）是两种重要的数据结构，它们在程序设计中扮演着关键角色，尤其在处理对象的临时存储和管理数据流时。本篇内容主要探讨了栈和队列的不同实现方式，以及它们的应用场景。...
表、栈和队列 _ Lists, Stacks and Queues1
08-04
标题和描述中提到的知识点主要涉及数据结构中的表、栈和队列，这些都是计算机科学中基本且重要的概念。下面将详细解释这些概念及其应用。 **表（List ADT）** 表是一种线性数据结构，允许在任何位置进行插入和删除...
【实验报告】 线性数据结构的实现与应用_双端队列_逆波兰式_呼叫中心_XAUAT_(原问题自杜克大学C++ Stacks and Queues and List
06-02
一. 实验目的 本次实验的主要目的是理解和掌握线性数据结构——双端队列（Double-Ended Queue，简称deque）的实现与应用。通过实际编程，加深对双端队列特性的理解，如其在头部和尾部进行插入和删除操作的灵活性。...
Chapter 10 Elementary Data Structures 10.1 Stacks and queues
Hengistchan的博客
02-03 289
Chapter 10 Elementary Data Structures 10.1 Stacks and queues Stacks and queues are dynamic sets in which the element removed from the set by the DELETE operation is prespecified. In a stack, the e...
week2——Stacks and Queues
仍歌杨柳春风
01-31 354
栈和队列 代码实现 原理详解
Stacks And Queues
dlei7655的博客
12-25 351
栈和队列 大型填坑现场，第一部分的还没写，以上。 栈和队列是很基础的数据结构，前者后进先出，后者先进先出，如下图： 下面开始将客户端和具体实现分开，这样有两个好处：一是客户端不知道实现的细节，但同时也会有很多不同实现来选择；二是实现方面也不知道客户端需求的细节，但同时很多客户端可以也重用一样的实现。接口就像把二者连接起来的桥梁。 stacks 栈的操作主要是出栈入栈，热身来一个放字符...
Day 18: Queues and Stacks（回文字符串）
追求卓越583的博客
03-27 852
题目： C++： #include <stdlib.h> #include <stdio.h> #include <vector> #include <stack> #include <queue> #include <map> #include <algorithm> #include <m...
Chapter 3 | Stacks and Queues--栈解决汉诺塔问题
wenqian 'blog
03-19 2617
3.4  In the classic problem of the Towers of Hanoi, you have 3 rods and Ndisks of different sizes which can slide onto any tower. The puzzle starts with disks sorted in ascending order of size from to
Linear Structures-stacks, queues
weixin_30344995的博客
11-28 91
线性数据结构有两端：有左右、前后、顶底等叫法。 栈（Stack）：是一个项的有序集合。添加和移除项的操作都在同一端，该端通常被称作顶（top），另一端为底（base）。 遵循后进先出（LIFO）原则，即越新的项越靠近顶，反之越靠近底。如叠起来的盘子，书，或浏览网页时（实际是指网址），打开第一个，二个，三个网页，当后退时，顺序是三，二，一。 栈的操作： Stack()creates a...
Dijkstra迪科斯彻算法
jiangxt211的专栏
08-12 1756
 主要参考《算法导论》与维基百科。 戴克斯特拉算法（英语：Dijkstra's algorithm）是由荷兰计算机科学家艾兹赫尔·戴克斯特拉提出。迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。举例来说，如果图中的顶点表示城市，而边上的权重表示著城市间开车行经的距离，该算法可以用来找到两个
不相交集合
jiangxt211的专栏
08-10 1061
不相交集合（disjoint-set） 一些应用涉及将n个不同的元素分成一组不相交的集合，常需要确定某元素所属集合及合并两集合。（例如，确定无向图的连通分量） 1、不相交集合数据结构 不相交集合数据结构（disjoint-setdatastructure）维护着一组不相交的动态集合S={S1,S2,S3,...,Sk}。我们用一个代表（representative）来标识每...
Kruskal算法
jiangxt211的专栏
08-16 938
 在Kruskal算法中，集合A是一个森林，其结点就是给定图的结点。每次加入到集合A中的安全边永远是权重最小的连接两个不同分量的边。在Prim算法中，集合A则是一棵树。每次加入到A中的安全边永远是连接A和A之外某个结点的边中权重最小的边。   Kruskal算法找到安全边的办法是，在所有连接森林中两棵不同的树的边里面，找到权重最小的边（u， v）。设C1和C2为边（u， v）所连接的两棵
图（四）：最小生成树
jiangxt211的专栏
03-05 705
最小生成树即权值最小的生成树。（无环，连接所有顶点的图，一定是树，即生成树（spanning tree）） GENERIC-MST 在算法的每一步中，确定一条边（u, v）,使得将它加入集合A后，A&{(u，v)}仍然是某一最小生成树的子集。称这样的边为A的安全边（safe edge）。 算法的关键是如何寻找安全边。 理解：cut、light edge、crosses、resp...
"易懂详细的数据结构第三章：栈和队列课件
The third chapter of the data structure courseware covers the topics of stacks and queues. These concepts are presented in a way that is more easily understandable than the information provided in the...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值