数据结构——栈与队列

于 2022-08-07 16:39:21 发布
阅读量141 收藏
点赞数 1
分类专栏： C语言 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sweet_0115/article/details/126212126
版权

本文将简单介绍两种数据结构并实现。

目录

（一）栈

（1）概念

（2）代码实现（含测试用例）

（二）队列

（1）概念

 （2）代码实现（含测试用例）

（3）拓展

（一）栈

（1）概念

        栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

        压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
        出栈：栈的删除操作叫做出栈。出数据也在栈顶。

 

 

（2）代码实现（含测试用例）

#pragma once
// 支持动态增长的栈
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	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);

 // 输出栈内元素
void StackPrint(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

//输出栈内元素
void StackPrint(Stack* ps)
{
	assert(ps);
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		ps->capacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
		return 1;
	else
		return 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->top = ps->capacity = 0;
}

void Test1()
{
	Stack ST;
	StackInit(&ST);

	//入栈
	StackPush(&ST, 1);
	StackPush(&ST, 2);
	StackPush(&ST, 3);
	StackPush(&ST, 4);
	StackPush(&ST, 5);
	StackPush(&ST, 6);
	StackPush(&ST, 7);
	StackPush(&ST, 8);
	StackPush(&ST, 9);
	StackPush(&ST, 0);
	StackPrint(&ST);

	//出栈
	StackPop(&ST);
	StackPop(&ST);
	StackPrint(&ST);
	//出栈
	StackPop(&ST);
	StackPop(&ST);
	StackPrint(&ST);
	//销毁栈
	StackDestroy(&ST);
}

void Test2()
{
	Stack ST;
	StackInit(&ST);

	//入栈
	StackPush(&ST, 1);
	StackPush(&ST, 2);
	StackPush(&ST, 3);
	StackPush(&ST, 4);
	StackPush(&ST, 5);
	StackPush(&ST, 6);
	StackPush(&ST, 7);
	StackPush(&ST, 8);
	StackPush(&ST, 9);
	StackPush(&ST, 0);
	StackPrint(&ST);

	printf("栈顶元素为%d\n", StackTop(&ST));
	printf("元素个数为%d\n", StackSize(&ST));
	//销毁栈
	StackDestroy(&ST);
}

int main()
{
	Test1();
	Test2();
	return 0;
}

（二）队列

（1）概念

        队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。

 （2）代码实现（含测试用例）

#pragma once
#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;
}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);

// 输出队列元素
void QueuePrint(Queue* q);


// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->rear = NULL;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("mallloc fail");
		return;
	}
	tmp->data = data;
	tmp->next = NULL;

	if (q->front == NULL)
	{
		q->front = q->rear = tmp;
	}
	else
	{
		q->rear->next = tmp;
		q->rear = tmp;
	}
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->front->next == NULL)
	{
		free(q->front);
		q->front = q->rear = NULL;
	}
	else
	{
		QNode* tmp = q->front->next;
		free(q->front);
		q->front = tmp;
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->front->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->rear->data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	int count = 0;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;	
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	if (q->front == NULL && q->rear == NULL)
		return 1;
	else
		return 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	q->front = q->rear = NULL;
}

// 输出队列元素
void QueuePrint(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void Test1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePrint(&q);

	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePrint(&q);

	QueueDestroy(&q);
}
void Test2()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePrint(&q);

	printf("队头元素为%d\n", QueueFront(&q));
	printf("队尾元素为%d\n", QueueBack(&q));
	printf("队内元素有%d\n", QueueSize(&q));

	QueueDestroy(&q);
}
int main()
{
	Test1();
	Test2();
	return 0;
}

（3）拓展

        存在一种特殊的队列——循环队列。

        为了区分队满与队空，我们认为队空：front = rear;队满：rear + 1 = front。

        下面是代码实现：

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

typedef struct {
    int* a;
    int front;
    int rear;
    int size;
} MyCircularQueue;

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->front == obj->rear;
}

判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    return obj->front == (obj->rear + 1) % obj->size;
}

//队列创建
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* tmp = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(tmp == NULL)
    {
        return NULL;
    }

    MyCircularQueue* obj = tmp;
    obj->a = (int*)malloc(sizeof(int) * (k + 1));
    obj->front = obj->rear = 0;
    obj->size = k + 1;
    return obj;
}

//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->rear] = value;
    obj->rear = (obj->rear + 1) % obj->size;
    return true;
}

//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front = (obj->front + 1 ) % (obj->size);
    return true;
}

//返回队头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->front];
}

//返回队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[(obj->rear - 1 + obj->size) % obj->size];
}

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->a);
    free(obj);
}

菜菜小蒙
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
栈和队列-笔记
#7的博客
03-08 178
1.栈是限定仅在表尾进行插入或删除操作的线性表。表尾端称为栈顶，表头端称为栈底。（栈又成为后进先出的线性表）2.非空栈中的栈顶指针始终在栈顶元素的下一个位置上。栈顶指针=栈底指针可作为栈空的标记。3.队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾，允许删除的一端则称为队头。...
栈和队列(笔记)
申小远的博客
08-20 242
栈先进后出的特性，也就是对于的插入和删除操作都是在栈顶进行的 队列先进先出，从队尾插入，对头弹出 一般情况下栈用顺序表来实现，因为栈的操作需要栈顶进行弹出操作，此时需要将栈顶指针指向上一个元素，如果用链表来做，则需要从头开始查找(单链表),使用循环链表也需要将指针循环一圈，此时的时间复杂度都是O(n)，也可以采用双向链表，但是双向链表实现起来并不简单(和顺序表相比)，而使用线性表来进行弹出操作...
栈和队列（笔记）
liuxiaojing20134422的专栏
10-31 460
栈和队列是操作受限的线性表，也是两种重要的抽象数据类型。 栈：  1、栈的逻辑结构：栈 是限定仅在表尾插入和删除操作的线性表。允许插入和删除的一端成为栈顶，另一端为栈底，不含任何数据元素的栈称为空栈。（后进先出） 2、栈的顺序存储结构及实现    （1）栈的初始化：初始化一个空栈只需将栈顶指针top置为-1.      （2）入栈操作：在栈中插入一个元素X只需将栈顶指针top加1，然后
栈和队列笔记
qq_43627355的博客
11-28 222
一、特殊的线性表——栈 1.栈：限定仅在表尾进行插入和删除操作的线性表。 栈的特性：先进后出（first in last out）；允许删除和插入的一端称为栈顶，另一端称为栈底；插入包括入栈、进栈、压栈，删除包括出栈、弹栈。 注：栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 2.栈的抽象数据类型定义： DestroyStack 前置条件：栈...
数据结构期末通关——栈与队列PPT
08-16
bilibili账号642257246，视频教程配套课件
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
C++实现的任意进制转换（数据结构——栈和队列）
08-10
C++语言实现带小数的任意进制转换，使用了数据结构中的栈和队列，在VC++6.0上编译运行通过。对于学习C++和数据结构有一定的参考意义！
数据结构——栈和队列
09-03
数据结构之栈和队列的PPT，想学习的可以下载看看。
栈和队列--学习笔记
puffx2的博客
12-05 223
栈 栈的相关概念 常用、重要的数据结构 定义：限定插入和删除只能在表的端点（通常是表尾，称作栈顶）进行的线性表 逻辑结构：一对一关系，与普通线性表相同 存储结构：顺序栈或链栈均可，顺序栈更常见 运算规则：只能在栈顶运算 且访问结点依照后进先出（LIFO结构）原则 实现方式：编写入栈出栈函数 表尾a[n]端称为栈顶Top，表头a[1]端称为栈底Base 插入元素到栈顶（表尾）称为入栈（Push） 从栈顶删除最后一个元素称为出栈（Pop） 栈的抽象数据类型的类型定义 ADT Stack {
栈和队列学习笔记
weixin_43499594的博客
03-24 133
栈和队列学习笔记 本文参考以及引用内容来自——数据结构(C语言版)—清华大学出版社—严蔚敏，吴伟民) 纯学习用，如有侵权请私信我告知！ 一、栈的定义 栈，是限定仅在表尾进行插入或删除操作的线性表，即单向进出, 先进后出。 栈的抽象数据类型： ADT Stack<T> { 数据:D={di | di 属于 T , i = 0,1,..,n, n≥0} 关系:R={<di-1, di> | di-1, di 属于 D, i = 1,2,…,n} 对数据的操作: 构造,析构;
栈与队列的学习笔记
anseccsx的博客
01-29 328
程序来源：《大话数据结构》 栈（stack）定义： 限定仅在表尾进行插入和删除的线性表，允许插入和删除的一端为栈顶，另一端为栈底。 栈注意点：先进后出，后进先出。 栈元素具有线性关系（前驱后继关系），插入叫做入栈，删除叫做出栈。 栈的结构：顺序结构和链式结构。 顺序结构 栈的结构定义 typedef int SElemType;/*SElemType类型根据实际情况而定
栈和队列——算法笔记
文剑木然的专栏
06-02 174
本文首发在我的个人博客：https://jlice.top/p/7d4wx/。欢迎大家前去参观，么么哒~ 链表 链表可以方便地实现以下操作： 从表头添加元素 Node tmp = front; front = new Node(); front.value = item; // item为添加的元素 front.next = tmp; 考虑边界情况，当链表为空添加元素时的情况，需调整...
数据结构----栈和队列阅读笔记
weixin_44932552的博客
06-08 271
认识数据结构 什么是数据结构？下面是维基百科的解释 数据结构是计算机存储、组织数据的方式 数据结构意味着接口或封装：一个数据结构可被视为两个函数之间的接口，或者是由数据类型联合组成的存储内容的访问方法封装 数组是最简单的内存数据结构，下面是常见的数据结构： 数组（Array） 栈（Stack） 队列（Queue） 链表（Linked List） 树（Tree） 图（Graph） 堆（Heap） 散列表（Hash） 下面来学习学习栈和队列… 1.栈数据结构 栈是一种线性数据结构，一个栈可以对数据按照顺序进行组
数据结构学习笔记：表、栈和队列
Breadcrumb Trails
06-12 938
表、栈和队列 抽象数据类型 概念 抽象数据类型（ Abstract Data Type，ADT）是带有一组操作的一些对象的集合，是数学的抽象。 实例 表、图、集合以及他们各自的操作（添加、删除等）一起形成的对象。 表 ADT 数组实现 连续存储、固定容量 线性时间操作 打印 插入与删除 常数时间操作 查找 链表实现 不连续存储 线性时间操作 查找 打印 常数时间操作 插入...
Java算法与数据结构测试——二叉树
最新发布
04-06
非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值