数据结构——栈和队列

于 2023-05-23 14:54:00 发布
阅读量175 收藏 1
点赞数
文章标签： 数据结构 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/krazy_/article/details/130824358
版权

目录

栈

逻辑结构

基本操作

物理结构

顺序结构

链式存储

队列

逻辑结构

基本操作

物理结构

顺序结构

链式存储

栈和队列不是传统意义上的线性表，它们属于特殊的线性表

栈

逻辑结构

定义：栈是只有一端能够插入删除的线性表。

 特点：后进先出（LIFO）

基本操作

初始化操作InitStack(&S):创建一个新栈S。

销毁操作DestroyStack(&S)：销毁一个栈S。

进栈操作Push(&S,x)：若栈未满，压栈。

出栈操作Pop(&S,&x)：若栈不为空，弹栈。

读栈顶元素Get(S,&x)：若栈不为空，读栈顶元素并用x带回。

判空操作Empty(S)：判断栈S是否为空栈。

物理结构

顺序结构

栈的定义

#define MaxSize 10
typedef struct
{
	ElemType data[MaxSize];//栈空间
	int top;//栈顶位置
}Stack;

初始化操作InitStack(&S)

void InitStack(Stack &S)
{
	S.top=-1;	//栈顶元素加一才指向此次插入的元素
}

void InitStack(Stack &S)
{
	S.top=0;	//栈顶元素指向此次插入的元素
}

销毁操作DestroyStack(&S)

void DestroyStack(Stack &S)
{
	S.top=-1;
}

void DestroyStack(Stack &S)
{
	S.top=0;
}

判空操作Empty(S)

bool Empty(Stack S)
{
	if(S.top==-1)
		return true;
	return false;
}
bool Empty(Stack S)
{
	if(S.top==0)
		return true;
	return false;
}

进栈操作Push(&S,x)

bool Push(Stack &S,ElemType x)
{
	if(S.top==MaxSize-1)//栈满了
		return false;
	S.data[++S.top]=x;//先加一才能指到元素插入的位置
	return true;
}
bool Push(Stack &S,ElemType x)
{
	if(S.top==MaxSize)//栈满了
		return false;
	S.data[S.top++]=x;//栈顶指针指在插入元素位置，插入完元素加一
	return true;
}

出栈操作Pop(&S,&x)

bool Pop(Stack &S,ElemType &x)
{
	if(S.top==-1)//栈空
		return false;
	x=S.data[S.top--];//先把栈顶元素赋值给x再把栈顶指针减一删掉这个元素
	return true;	
}
bool Pop(Stack &S,ElemType &x)
{
	if(S.top==0)//栈空
		return false;
	x=S.data[--S.top];//栈顶元素在栈顶的下一个，栈顶先减一指向其
	return true;	
}

读栈顶元素Get(S,&x)

bool Get(Stack S,ElemType &x)
{
	if(S.top==-1)
		return false;
	x=S.data[S.top];
	return true;
}
bool Get(Stack S,ElemType &x)
{
	if(S.top==0)
		return false;
	ElemType y=S.top-1;
	x=S.data[y];
	return true;
}

链式存储

 栈的定义

typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*Stack;

初始化操作InitStack(&S)

void InitStack(Stack &S)//不带头结点
{
	S=NULL;	
}

判空操作Empty(S)

bool Empty(Stack S)
{
	if(S==NULL)//空栈
		return true;
	return false;
}

进栈操作Push(&S,x)

bool Push(Stack &S,ElemType x)
{
	LNode *p=(LNode *)malloc(sizeof(LNode));
	if(p==NULL)
	{
		return false;
	}
	p->data=x;
	p->next=S;
	S=p;
	return true;
}

出栈操作Pop(&S,&x)

bool Pop(Stack &S,ElemType &x)
{
	if(S==NULL)//空栈
	{
		return false;
	}
	x=S->data;
    LNode *p=S;
	S=S->next;
    free(p);
	return true;
}

读栈顶元素Get(S,&x)

bool Get(Stack S,ElemType &x)
{
	if(S==NULL)//空栈
	{
		return false;
	}
	x=S->data;
	return true;
}

队列

逻辑结构

定义：队列是只有一端能够插入，只有另一端能删除的线性表。

但其实在实际应用时逻辑结构应该采用循环队列，代码对物理结构的操作也是基于此种逻辑结构。

 

特点：先进先出（FIFO）

 

基本操作

初始化操作InitQueue(&q):创建一个新队列q。

销毁操作DestroyQueue(&q)：销毁一个队列q。

入队操作InQueue(&q,x)：若队未满，入队。

出队操作OutQueue(&q,&x)：若队不为空，出队。

读队头元素Get(q,&x)：若队列不为空，读队头元素并用x带回。

判空操作Empty(q)：判队列是否为空。

判满操作IsFull(q)：判断队列q是否为满。

队列长度Length(q)：得到队列的长度。

物理结构

顺序结构

定义

#define MaxSize 10
typedef struct
{
	ElemType data[MaxSize];
	int front;//队头指针
	int rear;//队尾指针
}Queue;

InitQueue(&q)

void InitQueue(Queue &q)
{
	q.front=q.rear=0;
}

DestroyQueue(&q)

void DestroyQueue(Queue &q)
{
	q.front=q.rear=0;
}

InQueue(&q,x)

bool InQueue(Queue &q,ElemType x)
{
	if(IsFull(q)==true)
		return false;
	q.data[q.rear]=x;
	q.rear=(q.rear+1)%MaxSize;
	return true;
}

OutQueue(&q,&x)

bool OutQueue(Queue &q,ElemType &x)
{
	if(Empty(q)==true)//空队
	{
		return false;
	}
	x=q.data[q.front];
	q.front=(q.front+1)%MaxSize;
	return true;
}

Get(q,&x)

bool Get(Queue q,ElemType &x)
{
	if(Empty(q)==true)//空队
	{
		return false;
	}
	x=q.data[q.front];
	return true;
}

Empty(q)//浪费一个空间的情况

bool Empty(Queue q)
{
	if(q.front==q.rear)//
		return true;
	return false;
}

IsFull(q)//浪费一个空间的情况

bool IsFull(Queue q)//这里用浪费一个空间的办法
{
	if((q.rear+1)%MaxSize==q.front)
		return true;
	return false;
}

Length(q)

int Length(Queue q)
{
	if(Empty(q)==true)
	{
		return 0;
	}	
	if(IsFull(q)==true)
		return MaxSize-1;//因为浪费一个空间
	return (q.rear+MaxSize-q.front)%MaxSize;
}

不浪费空间判断队满队空的情况

（1）在队列结构体在定义一个size变量记录队元素个数。

（2）用flag变量记录上一步的操作是入队还是出队，入队1，出队0，如果头尾指针相同，上一步操作是1即队满，上一步为0即队空。

链式存储

定义

typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode;
typedef struct
{
	LNode *front,*rear;
}Queue;

InitQueue(&q)

bool InitQueue(Queue &q)//带头结点
{
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)
	{
		return false;
	}
	q.front=s;
	q.rear=s;
	s->next=NULL;
	return true;
}
bool InitQueue(Queue &q)//不带头结点
{
	q.front=NULL;
	q.rear=NULL;
	return true;
}

InQueue(&q,x)

bool InQueue(Queue &q,ElemType x)//带头结点
{
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)
		return false;
	s->data=x;
	s->next=NULL;
	q.rear->next=s;
	q=s;
	return true;
}

bool InQueue(Queue &q,ElemType x)//不带头结点
{
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)
		return false;
	s->data=x;
	if(Empty(q))
	{
		q.front=s;
		q.rear=s;
		return true;
	}
	s->next=NULL;
	q.rear->next=s;
	q=s;
	return true;
}

OutQueue(&q,&x)

bool OutQueue(Queue &q,ElemType &x)//带头结点
{
	if(Empty(q)==true)//空队
	{
		return false;
	}
	x=q.front->next->data;
	LNode *p=q.front->next;
	q.front->next=p->next;
	if(q.rear==p)
	{
		q.rear=q.front;
	}
	free(p);
	return true;
}

Get(q,&x)

bool Get(Queue q,ElemType &x)//带头结点
{
	if(Empty(q)==true)//空队
	{
		return false;
	}
	x=q.front->next->data;
	return true;
}
bool Get(Queue q,ElemType &x)//不带头结点
{
	if(Empty(q)==true)//空队
	{
		return false;
	}
	x=q.front->data;
	return true;
}

Empty(q)

bool Empty(Queue q)//带头结点
{
	if(q.front->next=NULL)//
		return true;
	return false;
}
bool Empty(Queue q)//不带头结点
{
	if(q.front=NULL)//
		return true;
	return false;
}

krazy_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
队列和栈
qq_36074150的博客
02-17 414
队列的定义        队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。         队首(front) ：允许进行删除的一端称为队首。         队尾(rear) ：允许进行插入的一端称为队尾。 队列的数据元素又称为队列元素。在队列中插
vs中c语言中queue怎么用,在编程语言中怎样定义队列及其使用(C++)
weixin_34005090的博客
05-21 789
队列在编程语言中是如何定义的呢？小编与大家分享自己的经验。队列的定义队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表.队列犹如一个两端开口的管道.允许插入的一端称为队头,允许删除的一端称为队尾.队头和队尾各用一个”指针”指示,称为队头指针和队尾指针.不含任何结点的队列称为”空队列”.队列的特点是结点在队列中的排队次序和出队次序按进队时间先后确定,即先进队者先出队.因此...
队列的基本操作
Enjoy_endless
01-11 500
#include<stdlib.h> #include<stdio.h> #include<string.h> //引入头文件 #define MAXLEN 20 //宏定义 typedef struct{ //节点定义 char name[10]; int age; }SD; typedef
队列的定义与应用
最新发布
Krive~Irving
05-22 113
队列，循环队列，队列实现栈
数据结构-队列（队列的基本操作）
Eddy的博客
08-02 2025
队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 ...
数据结构队列基本实现
UchihaMadara_2022的博客
04-08 405
队列是一种操作受限的线性表。在这种线性表上，插入操作限定在表的某一端进行，删除限定在表的另一端进行。允许插入的一端为队尾，允许删除的一端为对头。队列按照存储方式分为两种，分别是顺序存储和链式存储。其中顺序存储方式的队列为循环队列。废话不多说，直接上代码，下面是是我简单实现的队列的两种模式，顺序和链式，采用C++语言,在Qt5.9.0下编译成功。#include "queue.h"#ifndef Q...
C语言队列
qq_40104597的博客
05-14 247
2021-5-14
C++实现的任意进制转换（数据结构——栈和队列）
08-10
C++语言实现带小数的任意进制转换，使用了数据结构中的栈和队列，在VC++6.0上编译运行通过。对于学习C++和数据结构有一定的参考意义！
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
线性表 - 队列（数组和链表两种实现队列）
云梦归遥【qq_45834685】
05-13 326
线性表 - 队列（数组和链表两种实现队列）
数据结构之C++实现顺序队列（SeqQueue）（无主函数）
manonghouyiming的博客
03-10 697
#include&lt;iostream&gt; using namespace std; #define SIZE 10 class SeqQueue { public: SeqQueue() { m_data = new int[SIZE]; m_head = m_rear = 0; } ~SeqQueue() { if(m_data != NULL) { de...
队列的定义及其基本操作
forwardyzk的专栏
12-20 2万+
队列的定义及其基本操作 队列的定义 顺序队列及其操作 循环队列及其操作 链队列及其操作 1.队列的定义队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表. 队列犹如一个两端开口的管道.允许插入的一端称为队头,允许删除的一端称为队尾.队头和队尾各用一个”指针”指示,称为队头指针和队尾指针.不含任何结点的队列称为”空队列”.队列的特点是结点在队列中的排队次序和出队次序按进队
java 两个队列实现栈
hmi1024@163.com
04-18 217
public class MyStack { private Queue<Integer> inQueue; private Queue<Integer> outQueue; public MyStack() { inQueue = new LinkedList<>(); outQueue = new LinkedList<>(); } /** * 进栈 */ .
Python中的多进程创建和传值（克隆）Queue方法
dreamingcrazy的博客
08-18 2149
今日怼人金句“OMG，你何时有这样高尚的想法了”（一般怼和你谈道德、良心的人） 先说什么是进程，进程按照笔者的理解就是空间+任务不对记得指正笔者，比如有一个公司（进程）里有员工在做不同的事（线程）。 好啦概念了，我们先说要用的包multiprocessing，记得要和线程的threading进行区分，笔者认为（可能也是笔者接触的比较浅 的缘故） 先来基本使用 简单的进程 im...
二叉树的基本操作
学习笔记
07-19 2496
二叉树的基本操作包括创建、获取四种遍历方式
队列queue的详细讲解
热门推荐
乐不思书的专栏
04-13 4万+
 一、Java  Queue基础 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。 pol
C语言实现顺序队列、循环队列、链式队列
记录学习点滴
04-13 2310
队列：先进先出（FIFO）。队尾入队，队头出队。 1.顺序队列 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef int dataType; typedef struct { dataType data[MAXSIZE]; int front, rear; ..................
队列Queue的实现
Just The Way You Are
03-01 483
队列：先进先出 两种实现方式： 1.利用数组 2.链式存储 需要两个变量指向队头front和队尾rear，当入队时，队尾后移；出队时，队头后移 使用数组实现，当我们入队至数组满，然后出队至数组空，此时虽然数组为空，但是却不能再入队了，因为队尾rear已经指向了数组的最后一个索引位置。那么如何充分利用数组呢？ 通过一定的计算操作使得数组虚拟为环形的数组 pack...
Java算法与数据结构测试——二叉树
04-06
非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值