数据结构-栈和队列的实现

最新推荐文章于 2024-10-14 21:35:38 发布

永恒，怎么可能

最新推荐文章于 2024-10-14 21:35:38 发布

阅读量41

点赞数

分类专栏：数据结构（c语言实现）文章标签：数据结构

本文链接：https://blog.csdn.net/aa884561001/article/details/134500517

版权

数据结构（c语言实现）专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、栈的概念

栈相当于一个存放数据的工具，最主要的特点就是先进后出，最先放入的数据最后再输出，这里可以理解为小时候玩过的弹夹，一颗一颗的塞子弹，最先塞入的子弹肯定是最后才出膛。这里栈是可以一边出数据一边入数据的，先入123，输出3，2，再入4，5，输出5，4，最后再输出1，这是可以实现的。

二、栈的实现

这里栈可以用数组实现也可以用链表实现，因为数组实现起来更优雅，所以我这里用的是数组实现，阿里嘎多。

1、定义栈结构

除了使用存放数据的数组，我们还需要一个指向最后一个数据的变量，方便我们栈顶数据输出，还需要一个变量判断数组是否还有空间插入数据，实现动态增容的效果。

2、初始化栈

3、入栈（插入数据）

因为我们这里只有一个插入数据的函数，所以就不额外写一个申请内存的函数了。

4、出栈（删除数据）

5、获取栈顶元素

我这里写了很多函数，里面可能只有一两条语句，为什么还要专门写个函数呢，注意，我们在实际工作中，基本都是调用别人写的代码，使用函数封装，出问题的时候可以快速找到源头，这就是安全，阿里嘎多。

6、获取栈中有效元素个数

7、判断栈是否为空

8、销毁栈

三、栈的源码分享

#define _CRT_SECURE_NO_WARNINGS 

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* array;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);


#define _CRT_SECURE_NO_WARNINGS 

#include"Stack.h"

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->array == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(StackEmpty(ps));
	/*printf("%d\n", ps->array[ps->top-1]);*/ //返回栈顶元素
	/*printf("%d\n", ps->top);*/ //返回栈顶下标，不是下标元素
	/*return ps->top - 1;*/ //返回的是栈顶下标的前一个，此时top是10，返回的是九。
	return ps->array[ps->top -1];
}
int StackSize(Stack* ps)
{
	assert(ps);
	assert(ps->top);
	printf("%d\n", ps->top);
	return ps->top;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return !ps;
}
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	ps->array[ps->top] = data;
	ps->top++;
	/*printf("%d\n", ps->array[ps->top]);*/
	//检查栈满了需要扩容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->array, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(-1);
		}
		ps->array = tmp;
		ps->capacity *= 2;
	}

}
void StackPop(Stack* ps)
{
	assert(ps);
	/*assert(ps->top);*/
	/*assert(StackEmpty(ps));*/
	ps->top--;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->array);
	ps->array = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

四、队列的概念

队列的概念和栈的概念刚好是相反的，队列是先进先出，就好比一个走廊，第一个走过去的人第一个通过这条走廊，也可以理解为食堂打饭，第一个到的第一个吃上饭，阿里嘎多。

五、队列的实现

和栈一样，两个存储方式都可以用数组和链表进行实现，因为在这里，队列使用链表实现更优，所以我们下面是用链表实现的队列。

1，创建链表结构

我们用一个结构表示一个一个的节点，用一个结构表示头尾指针和有效元素的个数，方便我们后续访问。

2，初始化队列

3，队尾入数据

4，对头出数据

5，获取对头元素

6，获取队尾元素

7，查看队列有效元素个数

8，判断队列是否为空

9，销毁队列

六、队列的源码分享

#define _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;//头指针
	QNode* _rear;//尾指针
	QDataType size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);




#define _CRT_SECURE_NO_WARNINGS 

#include"Qnode.h"

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	/*assert(QueueEmpty(q));*/
	q->_front = NULL;
	q->_rear = NULL;
	q->size = 0;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	if (q->_front == NULL)
	{
		q->_front = q->_rear = newnode;
		q->size++;
	}
	else
	{
		q->_rear->next = newnode;//将尾指针的后一个赋值
		q->_rear = newnode;//将尾指针移到新赋值的位置方便下一个赋值
		q->size++;
	}
	/*printf("%d\n", q->_rear->data);*/ //打印出来检查一下
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(QueueEmpty(q));
	if (q->_front->next == NULL)
	{
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	else
	{
		QNode* next = q->_front->next;
		free(q->_front);
		q->_front = next;
	}
	/*printf("%d\n", q->_front->data);*/
	q->size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	printf("%d\n", q->_front->data);
	return q->_front->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	printf("%d\n", q->_rear->data);
	return q->_rear->data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	printf("%d\n", q->size);
	return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return !q->size == 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->size = 0;
}

七、总结

栈的概念是先进后出，类似弹夹的原理；队列是先进先出，类似于食堂打饭；有一些细微的功能之所以用函数去封装，是因为在实际工作中同一条语句会有多处使用，而封装相对来说也会更加安全，阿里嘎多。在实现栈亦或是队列中，可以考虑它们的特性选择数组亦或是链表的去实现，后续两者还会与哈希表一类的表一起使用，简而言之，基本功打好，一切知识都会水到渠成。写的不好的地方欢迎批评改进，共勉！