基础数据结构8：栈和队列

已于 2022-02-05 14:43:48 修改
阅读量56 收藏
点赞数
分类专栏： 基础数据结构及算法 文章标签： 数据结构
于 2021-08-07 16:59:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48580892/article/details/119427479
版权

1.栈

#pragma once

typedef int ELEM_TYPE;
#define INIT_SIZE 10

//顺序栈的定义
typedef struct Stack
{
	ELEM_TYPE* base;//数据域 用来保存malloc申请的空间
	int top;//栈顶指针，（1.其中有效数据的个数）（2.用来表示下一个插入位置的下标）
	int stacksize;//用来保存当前stack总共有多少空间（扩容就在这）
}Stack, * PStack;

//顺序栈的操作有哪些？
//增删改查 

//初始化
void Init_stack(PStack ps);

//入栈（或者叫压栈 push）
bool Push(PStack ps, ELEM_TYPE val);

//出栈（或者叫弹栈 pop（获取顶部数据，并且删除））//rtval是一个输出参数（C语言讲到）
bool Pop(PStack ps, ELEM_TYPE* rtval);

//获取顶部元素值 top（获取顶部数据）
bool Top(PStack ps, ELEM_TYPE* rtval);

//获取其有效数据个数
int Get_length(PStack ps);

//判空
bool IsEmpty(PStack ps);

//判满
bool IsFull(PStack ps);

//扩容
static void Inc(PStack ps);

//清空   一间房住了一户人  清空相当于把人赶出去
void Clear(PStack ps);

//销毁  一间房住了一户人  销毁相当于把人赶出去还把房烧了
void Destroy(PStack ps);

//打印
void Show(PStack ps);

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

/*
栈：是先进后出，或者说是后进先出（LIFO）的数据结构,仅限定在表尾进行插入和删除的线性表（受到限制的线性表），因此表尾端称作栈顶，另一端称作栈底，没有数据称作空栈
//例子：弹夹，先压入的子弹反而最后被击发
为啥在表尾：表尾的插入操作以及删除操作时间复杂度都为O（1）

队列：是一种先进先出(FIFO)的数据结构，仅在一端进行插入操作，而在另一端进行删除操作的线性表（受到限制的线性表），没有数据称作空队列
//排队：前面的先被服务，后面的人后被服务
既可以在头部插入，尾部删除，也可以在头部删除，尾部插入

分别用顺序表以及链表都实现一下。
*/

//初始化
void Init_stack(PStack ps)
{
	assert(ps != NULL);
	if (NULL == ps)
	{
		return;
	}

	//2.将成员初始化
	ps->base = (ELEM_TYPE*)malloc(sizeof(ELEM_TYPE) * INIT_SIZE);
	ps->stacksize = INIT_SIZE;
	ps->top = 0;
}

//入栈（或者叫压栈 push）
bool Push(PStack ps, ELEM_TYPE val)
{
	assert(ps != NULL);
	//2.判断栈满了没
	if (IsFull(ps))
	{
		Inc(ps);//3.如果满了 该扩容
	}
	//4.如果没满或者扩容完毕 则插入
	/*ps->base[ps->top] = val;
	ps->top++;*/
	ps->base[ps->top++] = val;

	return true;
}

//出栈（或者叫弹栈 pop（获取顶部数据，并且删除））//rtval是一个输出参数（C语言讲到）
bool Pop(PStack ps, ELEM_TYPE* rtval)
{
	assert(ps != NULL);
	//2.判断栈是否为空
	if (IsEmpty(ps))
	{
		return false;
	}
	//3.出栈
	/**rtval = ps->base[ps->top-1];
	ps->top--;*/
	*rtval = ps->base[--ps->top];

	return true;
}

//获取顶部元素值 top（获取顶部数据）
bool Top(PStack ps, ELEM_TYPE* rtval)
{
	assert(ps != NULL);
	//2.判断栈是否为空
	if (IsEmpty(ps))
	{
		return false;
	}
	//3.获取其顶部数据
	*rtval = ps->base[ps->top - 1];

	return true;
}

//获取其有效数据个数
int Get_length(PStack ps)
{
	assert(ps != NULL);
	return ps->top;
}

//判空
bool IsEmpty(PStack ps)
{
	assert(ps != NULL);
	return ps->top == 0;
}

//判满
bool IsFull(PStack ps)
{
	assert(ps != NULL);
	return ps->top == ps->stacksize;
}

//扩容
static void Inc(PStack ps)
{
	//不需要断言
	ps->base = (ELEM_TYPE*)realloc(ps->base, sizeof(ELEM_TYPE) * ps->stacksize * 2);
	assert(ps->base != NULL);

	ps->stacksize *= 2;
}

//清空   一间房住了一户人  清空相当于把人赶出去
void Clear(PStack ps)
{
	assert(ps != NULL);
	ps->top = 0;
}

//销毁  一间房住了一户人  销毁相当于把人赶出去还把房烧了
void Destroy(PStack ps)
{
	assert(ps != NULL);
	ps->top = 0;
	free(ps->base);
	ps->base = NULL;
}

//打印
void Show(PStack ps)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->base[i]);
	}
	printf("\n");
}

2.链栈


#pragma once


typedef int ELEM_TYPE;
typedef struct LStack
{
	ELEM_TYPE data;//数据域
	LStack* next;//指针域
}LStack, * PLStack;

//链栈的操作有哪些？
//增删改查 

//初始化
void Init_stack(PLStack ps);

//入栈（或者叫压栈 push）
bool Push(PLStack ps, ELEM_TYPE val);

//出栈（或者叫弹栈 pop（获取顶部数据，并且删除））//rtval是一个输出参数（C语言讲到）
bool Pop(PLStack ps, ELEM_TYPE* rtval);

//获取顶部元素值 top（获取顶部数据）
bool Top(PLStack ps, ELEM_TYPE* rtval);

//获取其有效数据个数
int Get_length(PLStack ps);

//判空
bool IsEmpty(PLStack ps);

//判满bool IsFull(PLStack ps);

//扩容static void Inc(PLStack ps);

//清空   一间房住了一户人  清空相当于把人赶出去
void Clear(PLStack ps);

//销毁  一间房住了一户人  销毁相当于把人赶出去还把房烧了
void Destroy(PLStack ps);

//打印
void Show(PLStack ps);



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

//初始化
void Init_stack(PLStack ps)
{
	assert(ps != NULL);
	//ps->data; 头结点的数据域不使用,不用初始化
	ps->next = NULL;
}

//入栈（或者叫压栈 push） 头插
bool Push(PLStack ps, ELEM_TYPE val)
{
	assert(ps != NULL && val > 0);
	//申请新节点
	LStack* pnewnode = (LStack*)malloc(sizeof(LStack) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//头插
	pnewnode->next = ps->next;
	ps->next = pnewnode;
	return true;
}

//出栈 头删（或者叫弹栈 pop（获取顶部数据，并且删除））//rtval是一个输出参数（C语言讲到）
bool Pop(PLStack ps, ELEM_TYPE* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps)) return false;
	
	*rtval = ps->next->data;

	LStack* p = ps->next;
	ps->next = p->next;
	free(p);
	p = NULL;
	return true;
}

//获取顶部元素值 top（获取顶部数据）
bool Top(PLStack ps, ELEM_TYPE* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps)) return false;

	*rtval = ps->next->data;
	return true;
}

//获取其有效数据个数
int Get_length(PLStack ps)
{
	assert(ps != NULL);
	int count = 0;
	for (LStack* p = ps->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//判空
bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

//不需要判满bool IsFull(PLStack ps)


//扩容static void Inc(PLStack ps)


//清空   一间房住了一户人  清空相当于把人赶出去
void Clear(PLStack ps)
{
	Destroy(ps);
}

//销毁  一间房住了一户人  销毁相当于把人赶出去还把房烧了
void Destroy(PLStack ps)//头删
{
	while (ps->next != NULL)
	{
		LStack* p = ps->next;
		ps->next = p->next;
		free(p);
		p = NULL;
	}
}
void Destroy(PLStack ps)//不需要头节点，需要两个指针
{
	LStack* p = ps->next;
	LStack* q;

	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
	ps->next = NULL;
}

//打印
void Show(PLStack ps)
{
	for (LStack* p = ps->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

3.队列:循环队列

#pragma once

typedef int ELEM_TYPE;

#define MAXQSIZE 100
typedef struct Queue
{
	ELEM_TYPE* base;//数据域 指向malloc申请来的动态内存
	int front;//头指针，当队列不空的时间，保存是队头，指向的第一个元素的下标
	int rear;//尾指针，当队列不空的时间，保存的是队尾，指向的下一个元素入队的下标

	//int length;//有效元素个数
}Queue, * PQueue;

//初始化
void Init_Queue(PQueue pq);

//入队 push
bool Push(PQueue pq, ELEM_TYPE val);

//出队 pop 需要删除操作
bool Pop(PQueue pq, ELEM_TYPE* rtval);

//top  获取队头元素值， 不需要删除操作
bool Top(PQueue pq, ELEM_TYPE* rtval);

//获取其有效元素个数
int Get_length(PQueue pq);

//判空
bool IsEmpty(PQueue pq);

//判满
bool IsFull(PQueue pq);

//清空
void Clear(PQueue pq);

//销毁
void Destroy(PQueue pq);

void Show(PQueue pq);

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include "queue.h"

/*
队列：一种先进先出FIFO（后进后出）的线性表，类比现实生活中的排队
//一端入，另一端出，入队的一端叫做队尾，出队的一端叫做队头。
//当队列中没有一个元素时，叫做空队。

难点：1.如何将队列的入队以及出队时间复杂度都降低为O（1）？
//火车：售货员怎么卖东西？ 推车小车，放着瓜子花生矿泉水。
//模仿一下：我们数据不需要挪动，而是是让队头指针以及队尾指针来回走动，得把它臆想成一个环状
2.怎么将判空和判满操作区分开？
//2.1：浪费一个尾部空间，当做标记位，当(rear+1)%MAXSIZE == front;  我们就认为已满
//2.2：在结构体里多申请一个变量，当做标记位，保存的是队列的有效元素个数
3.怎么获取其队列有效元素个数？求队列的有效元素个数的公式是啥？
//  (rear - front + MAXQSIZE) % MAXQSIZE

这节课讲的是循环队列:
//一共需要知道三个要点：
第一个：为了使队列的入队和出队的时间复杂度都为O（1），所以我们需要将其臆想成一个环形
第二个：判空和判满操作的判断依据出现了冲突，都是rear==front; 所以我们需要浪费一个尾部节点，
		当做标记位，当尾指针再向后跑一步就遇到了头指针，此时我们就认为队列满了
第三个：求队列有效元素个数的公式为：(rear - front + MAXQSIZE) % MAXQSIZE，
		加上一个MAXQSIZE的作用是为了防止（rear-front）出现负数，后边的%MAXQSIZE的作用是防止多加了

*/

//初始化
void Init_Queue(PQueue pq)
{
	assert(pq != NULL);
	pq->base = (ELEM_TYPE*)malloc(sizeof(ELEM_TYPE) * MAXQSIZE);
	assert(pq->base != NULL);

	pq->front = 0;
	pq->rear = 0;
	//pq->front = pq->rear = 0;
}

//入队 push
bool Push(PQueue pq, ELEM_TYPE val)
{
	assert(pq != NULL);
	//如果队列已满 则入队不进去
	if (IsFull(pq)) return false;
	pq->base[pq->rear] = val;

	//把它臆想成了一个环,所以rear向后跑的代码会有不同
	//pq->rear++;//ok? error
	pq->rear = (pq->rear + 1) % MAXQSIZE;

	return true;
}

//出队 pop 需要删除操作
bool Pop(PQueue pq, ELEM_TYPE* rtval)
{
	assert(pq != NULL);
	//如果队列为空  则不需要出队
	if (IsEmpty(pq))
		return false;

	*rtval = pq->base[pq->front];
	//把它臆想成了一个环,所以front向后跑的代码会有不同
	//pq->front++;//error
	pq->front = (pq->front + 1) % MAXQSIZE;

	return true;

}

//top  获取队头元素值， 不需要删除操作
bool Top(PQueue pq, ELEM_TYPE* rtval)
{
	//assert
	//如果队列为空  则不需要出队
	if (IsEmpty(pq))
		return false;

	*rtval = pq->base[pq->front];
	//不需要将front指针改变

	return true;
}

//获取其有效元素个数
int Get_length(PQueue pq)
{
	//assert
	int length = (pq->rear - pq->front + MAXQSIZE) % MAXQSIZE;
	return length;
}

//判空
bool IsEmpty(PQueue pq)
{
	return pq->front == pq->rear;
}

//判满
bool IsFull(PQueue pq)
{
	return (pq->rear + 1) % MAXQSIZE == pq->front;
}

//清空
void Clear(PQueue pq)
{
	//assert
	pq->front = pq->rear = 0;
}

//销毁
void Destroy(PQueue pq)
{
	//assert

	free(pq->base);
	pq->base = NULL;
	pq->front = pq->rear = 0;
}

void Show(PQueue pq)
{
	for (int i = pq->front; i != pq->rear; i = (i + 1) % MAXQSIZE)
	{
		printf("%d ", pq->base[i]);
	}
	printf("\n");
}
何小柒（qi)～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言栈和队列实验报告,数据结构与算法实验报告栈
weixin_42500616的博客
05-18 1755
数据结构与算法实验报告栈Tag内容描述：1、实验二 栈和队列实现四则运算 一、实验目的及要求： 1、掌握栈和队列的基本操作：建立、插入、删除、查找、合并 2、掌握用栈和队列的储存 3、熟悉C语言上机编程环境 4、掌握编译、调试程序的方法 二、实验内容： 采用栈进行表达式的求值，表达式求值是程序设计语言编译中的一个最基本问题。它的实现是栈应用的又一个典型例子，本报告使用的是“算符优先法”求表达式的值...
基础数据结构 循环队列
weixin_53920853的博客
08-12 209
想办法让队尾队头的时间复杂度都为O（1） 循环队列 头文件 queue.h #pragma once typedef int ELEM_TYPE; #define MAXQSIZE 100 typedef struct Queue { ELEM_TYPE *base;//数据域 指向malloc申请来的动态内存 int front;//头指针，当队列不空的时间，保存是队头，指向的第一个元素的下标 int rear;//尾指针，当队列不空的时间，保存的是队尾，指向的下一个元素入队的下标 .
数据结构 栈与队列
迁就100
07-08 281
实验项目中文名称：栈与队列 实验项目英文名称：Stack and queue 实验项目编码：2 实验学时：5 适用专业：信息与计算科学、数学与应用数学 所属课程：数据结构 开课学院：理学院 开课学期：第5学期 教材及实验指导书： 耿国华主编，《数据结构—（第三版）》，电子工业出版社，2011年 一、实验目的或任务 通过指导学生上机实践，对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌...
循环队列
GodSpeed513的专栏
05-25 990
在开发中很多时候需要用到循环队列来缓存数据，比如在串口通信中，可以将接收到的数据流先缓存到循环队列中，然后再从循环队列中取出数据做下一步的处理。这样可以有效的避免解析数据帧时繁琐的拼接处理。         为了方便使用，封装了一个循环队列类，具体代码如下：         头文件： /*********************************************
循环队列——队列的顺序表示和实现
林贻民的博客
08-14 5648
前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要区别在于:循环队列将顺序队列臆造成一个环状空间.在操作上这种异同体现在: 相同点:在顺序队列和循环队列中,进行出队、入队操作时,队首、队尾指针都要加 1 ,朝前移动。 不同点: 1. 在循环队列中当队首、队尾指针指
数据结构基础系列(3)：栈和队列
06-08
系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用...
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目 本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 ...
Python 实现数据结构中的的栈队列
09-19
栈和队列是两种基本且常用的数据结构，它们在Python中有着多种实现方式。本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循...
数据结构中的栈和队列
01-05
PPT内容是数据结构中有关栈和队列的知识，非常适合正在学习数据结构基础的同学
数据结构3栈和队列.pdf
最新发布
01-14
数据结构中的栈和队列是两种非常基础且重要的线性数据结构，它们在计算机科学中有着广泛的应用。栈，被称为“后进先出”（LIFO）的数据结构，因为元素的添加（入栈，Push）和移除（出栈，Pop）只能在栈顶进行。栈的...
数据结构与算法04：队列
浮尘笔记
05-28 1807
队列主要包含两个操作：入队（在队列尾部插入一个数据）和出队（从队列头部删除一个数据） ，队列也是一种操作受限的线性表数据结构，队列可以用数组来实现，也可以用链表来实现。队列中需要定义两个指针：一个是指向队头的head 指针，另一个是指向队尾的 tail 指针。在循环队列中，最关键是要确定好队空和队满的判定条件，循环队列的入队操作和出队操作的时间复杂度都是O(1)。阻塞队列是一个 “生产者——消费者模型”。
【C语言数据结构】循环队列
W1024201的博客
03-25 1831
目录 前言 一、循环队列 1.循环队列头文件及函数声明 2.初始化 3.入队 4.获取队头元素 5.出栈 6.清空与销毁 1.清空 2.销毁 8.循环队列源文件及整体函数实现 总结 前言 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列，实际本身是一个顺序表，但是因为顺序表进行删除非尾部...
循环队列(Circular Queue)
热门推荐
Catherine的笔记
05-28 1万+
循环队列(Circular Queue) 1. 循环队列的概念 1.1 循环队列的定义 为了能够充分地使用数组中的存储空间，克服”假溢出”现象，可以把数组的前端和后端连接起来，形成一个环形的表，即把存储队列元素的表从逻辑上看成一个环，成为循环队列(circular queue)。 1.2 循环队列中各元素的逻辑及存储关系 循环队列的首尾相接，当队头指针front和队尾指针rear进到maxSize-1后，再前
循环队列详解
qq_31186123的博客
10-07 2500
前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要区别在于:循环队列将顺序队列臆造成一个环状空间.在操作上这种异同体现在: 相同点: 在顺序队列和循环队列中,进行出队、入队操作时,队首、队尾指针都要加 1 ,朝前移动。 不同点: 1. 在循环队列中当队首、队尾指针指向向...
【数据结构】循环队列
weixin_56499830的博客
04-05 3209
文章目录1.队列2.循环队列3.循环队列头文件与函数声明4.函数4.1初始化4.2入队4.3出队4.4获取队头值4.5判空与判满4.6查找4.7获取队列有效长度4.8清空与销毁5.循环队列源文件与函数实现 1.队列 **队列：**先进先出的线性表，受到限制的，一端进行入队，一端进行出队。 入队的一端叫做队尾，出队的一端叫做队头，队列中没有元素的话，叫做空队。 2.循环队列 循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位
Linux循环链表队列,使用linux中标准的queue.h头文件插件链表，队列，循环队列
weixin_35856883的博客
05-14 314
#include#include #include int test_list(){LIST_HEAD(listhead, entry) head;struct listhead *headp; /* List head. */struct entry {char name[64];char sexy[8];int age;LIST_ENTRY(entry) ent...
数据结构之栈、队列的基本操作（附源码）
尔等同学的博客
04-10 748
栈和队列 1.栈 栈是一种只能在一段进行插入或者删除操作的线性表。 允许进行操作的的一端称为栈顶（Top）。表的另一端称为栈顶，栈顶是固定不变的。 栈的特点：后进先出 比如我们在往瓶子里装沙子时，最后被装进去的沙子会被最先倒出来。 栈可以分为顺序栈和链式栈 创建一个栈 定义栈中的节点，拥有一个数据域与一个指针域。 typedef struct Node { int data ; struct...
数据结构基础：栈与队列的概念与实现
本资源聚焦于两个基本且重要的数据结构：栈和队列，这些概念是很多算法和系统设计的基础。 栈是一种遵循“后进先出”（LIFO，Last In First Out）原则的线性数据结构。这意味着最后被插入的元素（栈顶元素）将首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值