首页 > 其他分享 >数据结构：详解【栈和队列】的实现

数据结构：详解【栈和队列】的实现

时间：2024-03-23 09:30:05浏览次数：239  
标签：ps head pq 队列 assert Queue 详解 数据结构

目录

1. 栈

1.1 栈的概念及结构

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

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

在这里插入图片描述
在这里插入图片描述

1.2 栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾插和头删的实际复杂度为O(1)，是非常合适的。

在这里插入图片描述

1.3 栈的功能

  • 初始化栈
  • 销毁栈
  • 入栈
  • 出栈
  • 获取栈顶元素
  • 获取栈内有效元素的个数
  • 判断栈内是否为空，如果为空返回非0结果，不为空返回0

1.4 栈的功能的实现

（1）定义一个动态增长的栈

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	STDataType top;//定义栈顶
	size_t capacity;//栈的容量
}ST;

（2）初始化栈

void StackInit(ST* ps)
{
	//初始化空间
	 ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail!\n");
		return;
	}

	ps->top = 0;
	ps->capacity = 4;//初始化4个空间
}

（3）销毁栈

void StackDestory(ST* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

（4）入栈（相当于顺序表的尾插）

void StackPush(ST* ps, STDataType x)
{
	//插入数据之前判断是否增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * sizeof(STDataType) * 2);
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			return;
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

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

（5）出栈（相当于顺序表的头删）

void StackPop(ST* ps)
{
	assert(ps);//断言，栈内为空则终止程序

	ps->top--;
}

（6）获取栈顶元素

STDataType StackTop(ST* ps)
{
	assert(ps);//断言，栈内为空则终止程序
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

（7）获取栈内有效元素的个数

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

（8）判断栈内是否为空，如果为空返回非0结果，不为空返回0

bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

1.5 完整代码

Stack.h

#define _CRT_SECURE_NO_WARNINGS 

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

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	STDataType top;//定义栈顶
	size_t 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);

//判断栈内是否为空，如果为空返回非0结果，不为空返回0
bool StackEmpty(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 

#include "Stack.h"

void StackInit(ST* ps)
{
	//初始化空间
	 ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail!\n");
		return;
	}

	ps->top = 0;
	ps->capacity = 4;//初始化4个空间
}

void StackDestory(ST* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(ST* ps, STDataType x)
{
	//插入数据之前判断是否增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * sizeof(STDataType) * 2);
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			return;
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

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


void StackPop(ST* ps)
{
	assert(ps);//断言，栈内为空则终止程序

	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);//断言，栈内为空则终止程序
	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;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 

#include "Stack.h"

void StackTest()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);

	//打印栈内的数据，由于不能破坏栈的特性，所以不能遍历
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}

	StackDestory(&st);
}

int main()
{
	StackTest();

	return 0;
}

2. 队列

2.1 队列的概念及结构

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

2.2 队列的实现

队列也可以数组和链表的结构实现，使用单链表的结构实现更优一些。
因为如果使用数组的结构，出队列在数组头上出数据，这时需要挪动数据，时间复杂度为O(n)，效率会比较低。
而单链表的尾插和头删的时间复杂度为O（1），十分合适。
在这里插入图片描述

2.3 队列的功能

  • 初始化队列
  • 销毁队列
  • 入队列
  • 出队列
  • 获取队列头部元素
  • 获取队列尾部元素
  • 获取队列中有效元素的个数
  • 判断队列是否为空，为空返回非0，不为空返回0

2.4 队列的功能的实现

（1）定义一个队列

typedef int QTDataType;

typedef struct QNode
{
	struct QNode* next;
	QTDataType data;
}QNode;

typedef struct Queue
{
	struct QNode* tail;
	struct QNode* head;
}Queue;

（2）初始化队列

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

（3）销毁队列

void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		free(cur);
	}
	pq->head = pq->tail = NULL;
}

（4）入队列(相当于单链表的尾插）

void QueuePush(Queue* pq, QTDataType x)
{
	assert(pq);

	QNode* newnode = (QTDataType*)malloc(sizeof(QTDataType));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		return;
	}

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

	//第一个结点
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	//多个节点
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

}

（5）出队列（相当于单链表的头删）

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	//只有一个节点
	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;
	}
}

（6）获取队列头部元素

QTDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}

（7）获取队列尾部元素

QTDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->tail->data;
}

（8）获取队列中有效元素的个数

int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}

	return size;
}

（9）判断队列是否为空，为空返回非0，不为空返回0

int QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

2.5 完整代码

Queue.h

#pragma once

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

typedef int QTDataType;

typedef struct QNode
{
	struct QNode* next;
	QTDataType data;
}QNode;

typedef struct Queue
{
	struct QNode* tail;
	struct QNode* head;
}Queue;

//初始化队列
void QueueInit(Queue* pq);

//销毁队列
void QueueDestory(Queue* pq);

//队尾入队列
void QueuePush(Queue* pq, QTDataType x);

//队头出队列
void QueuePop(Queue* pq);

//获取队列头部元素
QTDataType QueueFront(Queue* pq);

//获取队列尾部元素
QTDataType QueueBack(Queue* pq);

//判断队列是否为空，为空返回非0，不为空返回0
int QueueEmpty(Queue* pq);

//获取队列中有效元素的个数
int QueueSize(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 

#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)
	{
		cur = cur->next;
		free(cur);
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QTDataType x)
{
	assert(pq);

	QNode* newnode = (QTDataType*)malloc(sizeof(QTDataType));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		return;
	}

	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);

	//只有一个节点
	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;
	}
}

int QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

QTDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}

QTDataType 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;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 

#include "Queue.h"

void QueueTest()
{
	Queue q;
	QueueInit(&q);
	
	QueuePush(&st, 1);
	QueuePush(&st, 2);
	QueuePush(&st, 3);
	QueuePush(&st, 4);
	
    //打印队列内的数据，由于不能破坏队列的特性，所以不能遍历
	while (!QueueEmpty(&st))
	{
		printf("%d ", QueueFront(&st));
		QueuePop(&st);
	}

	QueueDestory(&q);

}


int main()
{
	QueueTest();

	return 0;
}

标签：ps,head,pq,队列,assert,Queue,详解,数据结构
From： https://blog.csdn.net/2301_77900444/article/details/136949159

相关文章

  • java方法详解
    java方法详解方法是语句的集合。目的是解决一类问题。一个方法只完成一个功能，这样有利于后期的扩展。（单一职责原理）java都是值传递！有一个值copy的过程。publicclassDemo02{publicstaticvoidmain(String[]args){intmax=max(10,20);System.......
  • if、switch语句构成的选择结构详解
    前言：C语言是结构化的程序设计语言，这里的结构指的是顺序结构、选择结构、循环结构，C语言是能够实现这三种结构的，其实我们如果仔细分析，我们日常所见的事情都可以拆分为这三种结构或者这三种结构的组合，下文将讲述C语言中选择结构相关语句语法。一、if语句if语句分为单if语句、if......
  • 数据结构笔记
    数据结构数据在内存中的存储方式(存储结构)程序=数据+算法算法=操作的步骤算法的时间复杂度动态数组链表迭代器栈和队列二叉搜索树二叉平衡树哈希表1.时间复杂度考量算法的时间复杂度有一个前提就是控制变量,语句的执行时间相同,数据的样本量相同……......
  • 数据结构——单向链表（C语言版）
    在数据结构和算法中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中，我们可以使用指针来实现单向链表。下面将详细介绍如何用C语言实现单向链表。目录1.定义节点结构体2.初始化链表3.插入节点4.删除节点5.遍历链......
  • 函数的详解
    目录1.函数的概念2.库函数2.1库函数的概念2.2 标准库和头文件2.3库函数的使用方法2.4 头文件包含2.5 库函数文档的一般格式3.自定义函数3.1函数的与法形式3.2函数举例4.实参和形参4.1实参4.2形参5.return语句6.嵌套调用和链式访问6.1嵌套调用......
  • 开源计算机视觉库OpenCV详解
    OpenCV（OpenSourceComputerVisionLibrary）是一个开源的计算机视觉和机器学习软件库。OpenCV最初由Intel开发，后来支持由WillowGarage和Itseez（被Intel收购）进行的维护和更新。这个库旨在为实时的计算机视觉应用提供一个高效的、易于使用的环境，并且是用C++编写的，尽管它提供了......
  • 【C语言】结构体详解
    文章目录1、前言2、结构体变量的创建和初始3、结构体的特殊声明3、结构体的自引用5、结构体的内存对齐5.1对齐规则5.2为什么存在内存对齐?5.3修改对齐数6、结构体实现位段6.1什么是位段6.2位段的内存分配6.3位段的跨平台问题6.4位段的应用6.5位段使用的注意事项......
  • 【BFS】（代码详解）
    全面学习BFS的可以参照以下路径，本文章只附上部分代码的解释作为学习记录共勉（星星眼）原文链接：https://blog.csdn.net/m0_62881629/article/details/125072287给定一个n×mn×m的二维整数数组，用来表示一个迷宫，数组中只包含00或11，其中00表示可以走的路，11表示不可通过......
  • 异步消息队列Celery
    1.什么是Celery4.4.0|Celery中文手册(celerycn.io)1.1介绍Celery是一个简单、灵活且可靠的，处理大量消息的分布式系统，专注于实时处理的异步任务队列，同时也支持任务调度。Celery的架构由三部分组成，消息中间件（messagebroker），任务执行单元（worker）和任务执行结果存储（tas......
  • Java知识学习13（AQS详解）（转载）
    1、AQS介绍？AQS的全称为AbstractQueuedSynchronizer，翻译过来的意思就是抽象队列同步器。这个类在java.util.concurrent.locks包下面。AQS就是一个抽象类，主要用来构建锁和同步器。publicabstractclassAbstractQueuedSynchronizerextendsAbstractOwnableSynchronizer......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99