＜栈和队列及模拟实现＞——《Data Structure in C Train》

已于 2022-08-30 18:25:11 修改
阅读量443 收藏
点赞数 2
分类专栏： 《数据结构》（C语言版） 文章标签： 数据结构 c语言
于 2022-08-30 17:58:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57859086/article/details/126595683
版权

目录

详细实现链接：

＜栈（动态版）＞《数据结构(C语言版)》

＜队列（链式）＞《数据结构(C语言版)》

1.分析实现功能、感受栈和队列的实现结构：

1.1栈的实现结构方式：​

1.2 队列的实现方式：

2.完整源码：

2.1栈的模拟实现： 

Stack.h:

Stack.c:

Test.c:

2.2 队列的模拟实现：

Queue.h：

Queue.c:

Test.c:

 3.判断括号匹配程序：

后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                       ——By 作者：新晓·故知

详细实现链接：

＜栈（动态版）＞《数据结构(C语言版)》

＜队列（链式）＞《数据结构(C语言版)》

1.分析实现功能、感受栈和队列的实现结构：

1.1栈的实现结构方式：

数组实现栈的结构：

相当于顺序表的尾插、尾删，用尾作栈顶，非常合适！从CPU预加载命中角度分析，数组实现的性能更好一些！

缺点：空间不够时需要增容。

单向链表实现栈的结构：

用头结点作栈底，这样使得入栈和出栈效率都是O(1)。

双向链表实现栈的结构：

用尾作栈顶。

1.2 队列的实现方式：

数组实现队列的结构：

不适合，队头出数据需要挪动数据

单链表实现队列的结构：

无需使用带头结点的单链表即可完成，带头结点是为了减少二级指针的使用。

tail是移动的，方便尾部操作直接找到。head方便头部操作直接找到。

 

数据结构的设计比较灵活，正所谓：“树挪死，人挪活”。在学习中，不要一味地“守死”，而要学会“变活。”

2.完整源码：

2.1栈的模拟实现： 

Stack.h:

#pragma once

#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;   //通过数组实现栈的结构
	int top;
	int capacity;
}ST;
//初始化
void StackInit(ST* ps);
//释放内存、销毁空间
void StackDestory(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType x);
// 出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈的大小
int StackSize(ST* ps);
//判空
bool StackEmpty(ST* ps);

Stack.c:

#include"Stack.h"
//初始化
void StackInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}

	ps->capacity = 4;
	ps->top = 0; //这使得top最终指向的是栈顶的后一个位置。若top=-1,则最终指向的是栈顶。
}
//释放内存、销毁空间
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
// 入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了->增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Pop，就会直接中止程序报错
	assert(ps->top > 0);

	//ps->a[ps->top - 1] = 0; //置为0只考虑了int型等，若为char、double等就不适用了。
	ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	// 栈空了，再调用Top，就会直接中止程序报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}
//求栈大小
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}
//判空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//判断括号是否匹配算法
bool isValid(char* s) {
	ST st;
	StackInit(&st);
	while (*s != '\0')
	{
		switch (*s)
		{
		case '{':
		case '[':
		case '(':
		{
			StackPush(&st, *s);
			++s;
			break;
		}
		case '}':
		case ']':
		case ')':
		{
			if (StackEmpty(&st))
			{
				StackDestory(&st);
				return false;
			}

			char top = StackTop(&st);
			StackPop(&st);

			// 不匹配
			if ((*s == '}' && top != '{')
				|| (*s == ']' && top != '[')
				|| (*s == ')' && top != '('))
			{
				StackDestory(&st);
				return false;
			}
			else // 匹配
			{
				++s;
			}
			break;
		}
		default:
			break;
		}
	}
	bool ret = StackEmpty(&st);
	StackDestory(&st);
	return ret;
}

Test.c:

#include"Stack.h"

int main()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 9);
	StackPush(&st, 5);
	StackPush(&st, 2);
	StackPush(&st, 7);

	printf("%d \n", StackEmpty(&st));
	printf("%d \n", StackSize(&st));
	while (!StackEmpty(&st))
	{
	
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");
	
	StackDestory(&st);
	return 0;
}

2.2 队列的模拟实现：

Queue.h：

#pragma once

#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestory(Queue* pq);
// 队尾入
void QueuePush(Queue* pq, QDataType x);
// 队头出
void QueuePop(Queue* pq);
//取队列头元素
QDataType QueueFront(Queue* pq);
//取队列尾元素
QDataType QueueBack(Queue* pq);
//队列大小
int QueueSize(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);

Queue.c:

#include"Queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}
// 队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
// 队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	// 1、一个
	// 2、多个
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->tail->data;
}
//队列大小
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		++size;
		cur = cur->next;
	}

	return size;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

Test.c:

#include"Queue.h"

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);

	QueuePush(&q, 3);
	QueuePush(&q, 4);

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");

	QueueDestory(&q);
}

int main()
{
	
	TestQueue();

	return 0;
}

 3.判断括号匹配程序：

#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>

///
//声明
typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//
//定义
//初始化
void StackInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	ps->capacity = 4;
	ps->top = 0;
}
//销毁
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

// 入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了-》增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(ST* ps)
{
	assert(ps);
	// 栈空了，调用Pop，直接中止程序报错
	assert(ps->top > 0);

	//ps->a[ps->top - 1] = 0;
	ps->top--;
}
//去栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	// 栈空了，调用Top，直接中止程序报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}
//求栈的的大小
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}
//判空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}
//判断括号是否匹配
bool isValid(char* s) {
	ST st;
	StackInit(&st);
	while (*s != '\0')
	{
		switch (*s)
		{
		case '{':
		case '[':
		case '(':
		{
			StackPush(&st, *s);
			++s;
			break;
		}
		case '}':
		case ']':
		case ')':
		{
			if (StackEmpty(&st))
			{
				StackDestory(&st);
				return false;
			}

			char top = StackTop(&st);
			StackPop(&st);

			// 不匹配
			if ((*s == '}' && top != '{')
				|| (*s == ']' && top != '[')
				|| (*s == ')' && top != '('))
			{
				StackDestory(&st);
				return false;
			}
			else // 匹配
			{
				++s;
			}
			break;
		}
		default:
			break;
		}
	}

	bool ret = StackEmpty(&st);
	StackDestory(&st);
	return ret;
}

int main()
{
	//int ret = isValid("[[[");
	//int ret = isValid("[][");
	int ret = isValid("[]");
	if (ret == 0)
	{
		printf("不匹配！\n" );
	}
	else
	{
		printf("匹配！\n");
	}
	return 0;
}

后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                       ——By 作者：新晓·故知

新晓·故知
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
＜顺序表及模拟实现＞——《Data Structure in C Train》
m0_57859086的博客
08-29 185
＜顺序表及模拟实现＞——《Data Structure in C Train》
＜二叉树及模拟实现＞——《Data Structure in C Train》
m0_57859086的博客
08-31 188
＜二叉树及模拟实现＞——《Data Structure in C Train》
数据结构与算法—顺序表、链接表、顺序栈、链接栈、顺序队列、链接队列的C++代码实现
weixin_43978744的博客
04-04 2170
顺序表、链接表、顺序栈、链接栈、顺序队列、链接队列的C++代码实现(基于C++模板)
HDU 1020 Train Problem I 栈和队列的应用
小do在努力
04-04 954
/* ---------------------------------------- stratege ：stack && queue &&　simulation Theam : 给你一系列数，一次进栈，问出栈的 顺序是否符合 Author： Johnsondu Time: 2012-04-04 type: data structure
数据结构笔记--栈与队列，堆
guozhengdong的专栏
10-20 230
基本定义： 先进后出为栈；先进先出为队列 栈的构造 #include<stdio.h> #include<stack> int main() { std::stack<int> S; if(S.empty()) //判断栈是否为空 { printf("S is empty!\n"); } S.push(1);//压栈 S.push(6); S.push(10); printf("S
leetcode 刷题视频(2) - 栈、队列和堆
一个幽灵
10-05 287
栈、队列和堆 问题1 使用队列实现栈 Implement the following operations of a stack using queues. push(x) – Push element x onto stack. pop() – Removes the element on top of the stack. top() – Get the top element. empty() – Return whether the stack is empty. Example: MyStac
Leetcode 栈&队列
YurYur的博客
03-05 132
Pre 栈 先进后出（FILO） 线性表 push & pop //栈的基本操作 stack.push() stack.pop() stack.size() stack.empty() stack.top() //EXAMPLE #include <iostream> #include <stack> using namespace std; int main(){ stack<int> S; if(S.empty()){
一起来用tf.data API！（2）——创建迭代器读取数据
Friedrich Yuan的博客
11-10 2069
一起来用tf.data API！（2）——创建迭代器读取数据（一）前 言（二）单次迭代器（三）可初始化迭代器（四）可重新初始化迭代器（五）可馈送迭代器（六）消耗迭代器中的值（七）保存迭代器的状态（八）总 结 （一）前 言 在第一节中我们介绍了tf.data API的组件结构，我们使用Database方法来创建数据集，然后使用Iterator来读取数据集中的元素，本节我们就来介绍如何用Iter...
tensorflow的Data Pipeline系列教程（一）——Dataset类的属性即常用方法
MIss-Y的博客
06-13 5391
前言：在tensorflow中，训练数据常常需要经过随机打乱、分成一个一个的batch来进行训练，当然有很多的方式可以完成，比如我们可以通过传统的python方法构建迭代器，我们也可以使用其它的一些方法，但是tensorflow本身提供了强大的data pipeline处理机制，本文就来详细说明一下。本文的核心是：从Dataset到Iterator的“四步走”过程。 ...
AI人工智能大模型中——数据集就是一切 The dataset is everything
程序员光剑
04-25 295
我认为对计算乘数的搜索比任何不严格遵守缩放定律的人想象的要普遍得多：实际上，机器学习领域的每一位不研究现有技术的新应用的科学家都应该执行计算效率扫描以确保他们的发现确实相关。不过，随着训练的进行，这些机制会“上线”：当您需要提高学习更复杂的数据分布层的能力时，它们就会提供有意义的价值。更重要的是，认识到像 GPT-4 或 DALL-E 3 这样的巨大模型仍然存在根本性缺陷，这表明试图从 Llama 2 或 Stable Diffusion 等相对较小的模型中获得真正智能的行为是没有希望的。
tf.data
Meiko记录
03-08 575
注意，在TensorFlow 1.3中，Dataset API是放在contrib包中的： tf.contrib.data.Dataset 而在TensorFlow 1.4中，Dataset API已经从contrib包中移除，变成了核心API的一员： tf.data.Dataset 此前，在TensorFlow中读取数据一般有两种方法： 使用placeholder读内...
TensorFlow tf.data 导入数据（tf.data官方教程） * * * * *
热门推荐
黑暗星球
06-19 3万+
上一篇介绍了
tensorflow学习笔记(3)：使用tf.data API导入数据
樛木
06-12 2739
详细教程：https://www.tensorflow.org/programmers_guide/datasets 通过 tf.data API，您可以根据简单的可重用片段构建复杂的输入管道。例如， 图片模型的管道可能会汇聚分布式文件系统中的文件中的数据、对每个图片应用随机扰动，并将随机选择的图片合并成用于训练的批次。 文本模型的管道可能包括从原始文本数据中提取符号、根据对照表将其转换为嵌...
TensorFlow, Mxnet, PyTorch: 要点总结及常见神经网络代码实现
luv_dusk 的博客
07-09 5120
目录一、深度学习框架MxnetTensorFlow二、多层感知机 (MLP) (Mxnet+TensorFlow实现)三、卷积神经网络 (LeNet/AlexNet/VGG/NiN/GoogLeNet/ResNet) (Mxnet实现)四、循环神经网络 (RNN/GRU/LSTM) (Mxnet+TensorFlow实现)五、对抗式生成网络 (DCGAN) (Mxnet实现)六、区域卷积神经网络 ...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 918
详解了推有关的两个面试题：堆排序，TopK问题
栈的内容..
最新发布
2301_79724394的博客
09-09 104
持续更新，小手动一动，点个关注，谢谢！
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 589
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构之“双向链表”
2402_83250773的博客
09-06 892
双向链表，顺序表与链表的比较
栈和队列的数据结构详解——清华大学版
通过理解和掌握栈和队列的原理及其操作，开发者能够有效地设计和实现各种复杂的数据处理算法，提高程序的效率和可维护性。在学习数据结构时，对这些基础概念的深入理解至关重要，因为它们是许多高级数据结构和算法的...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值