栈和队列的实现

已于 2023-01-29 16:13:29 修改
阅读量210 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2022-08-29 22:06:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67458830/article/details/126566855
版权

文章目录

  • 一、栈

    • 1.栈的概念及结构

    • 2.栈的实现

  • 二、队列

    • 1.队列的概念及结构

    • 2.队列的实现

  • 三、栈和队列的面试题

一、栈

1.栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

2.栈的实现

 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 

1.栈的创建

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

2.初始化

void StackInit(ST* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

3.销毁

void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);

	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

4入栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);

		if (tmp == NULL) {
			perror("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

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

5.出栈

void StackPop(ST* ps)
{
	assert(ps);

	assert(!StackEmpty(ps));
	ps->top--;
}

6.返回栈顶元素

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

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

7.判断是否为空

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

	return ps->top == 0;
}

8.返回栈的大小

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

	return ps->top;
}

二、队列

1.队列的概念及结构

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

2.队列的实现

队列也可以数组和链表的结构实现，使用链表的结构更优一些，因为如果有数组的结构，出队列在数组的头上出数组，效率会比较低。

1.队列的创建

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;

	QDataType data;
}QNode;

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

2.初始化

void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
}

3.销毁

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

4.入队

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("malloc fail\n");
		exit(-1);
	}
	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(!QueueEmpty(pq));

	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.返回队头数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

7.返回队尾数据

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

8.判断队列是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

9.返回队列的长度

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

三、栈和队列的面试题

1.有效的括号OJ链接

class Solution {
public:
    bool isValid(string s) {
        //使用C++中的STL（无需自己造轮子）
        
        stack<char>ST;
        int i=0;
        while(s[i])
        {
            if(s[i]=='('||s[i]=='{'||s[i]=='[')//将‘（’、‘[’、‘{’放入栈中
              {
                  ST.push(s[i]);
                  i++;
              }
            else
            {
                if(ST.empty())
                   return false;
                if((ST.top()=='{'&&s[i]=='}')||(ST.top()=='('&&s[i]==')')||(ST.top()=='['&&s[i]==']'))//取出栈顶的元素与所在s的位置进行匹配
                  {
                      ST.pop();
                      i++;
                  }
                  else
                     return false;
            }
        }
        if(!ST.empty())
          return false;
        else
          return true;


    }
};

2.用队列实现栈OJ链接

class MyStack {
    //定义两个MyStack类的成员为两个队列分别为q1，q2
private:
         queue<int> q1;
         queue<int> q2;
public:
    MyStack() 
    {

    }
    //将q1中插入元素x
    void push(int x) {
        q1.push(x);
    }
    //如果q1不为空的话将q1中的元素插入q2中
    int pop() {
    if(!q1.empty())
    {
        while(q1.size()>1)
    {
        q2.push(q1.front());
        q1.pop();
    }
        int ret=q1.front();
        q1.pop();
         return ret;
    
    }
    //反之
    else
    {
         while(q2.size()>1)                                //注意判断一下q1，q2是否为空
    {
        q1.push(q2.front());
        q2.pop();
    }
        int ret=q2.front();
        q2.pop();
         return ret;
    
    }
}
    
    int top() {
        if(!q1.empty()) 
          return q1.back();
        else
          return q2.back(); 
    }
    
    bool empty() {
        return q1.empty()&&q2.empty();

    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

3.用栈实现队列OJ链接

class MyQueue {
    //定义两个栈一个栈用来出数据，一个栈用来插入数据
private:
     stack<int> PushST;
     stack<int> PopST;
public:
    MyQueue() {

    }
    //将数据放入插入数据的栈中
    
    void push(int x) {
           PushST.push(x);

    }
    //如果此时出数据的栈空为空时则将数据导入出数据的栈中
    
    int pop() {
        if(PopST.empty())
        {
            while(!PushST.empty())
            {
                PopST.push(PushST.top());
                PushST.pop();
            }
            
        }
        int ret=PopST.top();
        PopST.pop();
        return ret;

    }
    
    int peek() {
    if(PopST.empty())
        { while(!PushST.empty())
            {
                PopST.push(PushST.top());
                PushST.pop();
            }
           

    }
     return PopST.top();
    }
    
    bool empty() {
        return PushST.empty()&&PopST.empty();

    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

4.设计循环队列OJ链接

class MyCircularQueue {
    //利用数组进行求解比较简单
    //定义一个vector容器
    //即一个队列的长度、头、尾
private:
  vector<int>v;
  int n;
  int head;
  int tail;
public:
    MyCircularQueue(int k)
    {
        //指定该容器的长度为为队列长度+1
        //并且进行初始化操作
        v.resize(k+1);
        n=k;
        head=tail=0;
    }
    //入队列
    bool enQueue(int value) {
   //如果此时队列满了无法进行入队列的操作
        if(isFull())
        {
            return false;
        }
        //若队列没满则进行数据的填入
        v[tail]=value;
        tail=(tail+1)%(n+1);
        return true;
 
    }
    //出队列
    bool deQueue() {
        //如果此时的队列为空的话无法进行出队列的操作
        if(isEmpty()) 
           {
               return false;
           }
        head=(head+1)%(n+1);
        return true;
    }
    //取队头值
    int Front() {
        if(isEmpty())
           return -1;
        return v[head];

    }
    //取队尾的值
    int Rear() {
        //如果此时为空的话返回-1
        if(isEmpty())
           return -1;
        return v[(tail+n)%(n+1)];

    }
    bool isEmpty() {
        return tail==head;

    }
    
    bool isFull() {
        if((tail+1)%(n+1)==head)
           return true;
        else
           return false;


    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue* obj = new MyCircularQueue(k);
 * bool param_1 = obj->enQueue(value);
 * bool param_2 = obj->deQueue();
 * int param_3 = obj->Front();
 * int param_4 = obj->Rear();
 * bool param_5 = obj->isEmpty();
 * bool param_6 = obj->isFull();
 */

‘(尐儍苽-℡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈和队列的基本操作
m0_66054454的博客
02-05 425
栈和队列的基本操作
实验二 栈和队列基本操作的实现
陈的博客
12-06 1796
实验二 栈和队列基本操作的实现 实验目的 1.掌握栈、队列的思想及其存储实现 2.掌握栈、队列基本操作的实现 实验内容 1.编写函数，采用链式存储实现栈的初始化、入栈、出栈操作。 2.编写函数，采用顺序存储实现栈的初始化、入栈、出栈操作。 3.编写函数，采用链式存储实现队列的初始化、入队、出队操作。 4.编写函数，采用顺序存储实现队列的初始化、入队、出队操作。 5.编写一个主函数，在主函数中设计一个简单的菜单，分别调用上述函数。 #include<cstdio> #include<c
栈和队列--基本操作
weixin_62580505的博客
02-07 1554
本节目标 学习栈的原理及基本实现 学习队列的原理及基本实现 栈： 一种特殊的线性表，其只允许在固定一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出 LIFO （Last In First Out) 的原则。 压栈：栈的插入操作叫做进栈，压栈，入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。 出数据在栈顶。 实现 1.利用顺序表实现，即使用尾插 + 尾删的方式实现 2.利用链表实现，即头尾皆可 但相对来说，顺序表的实.
栈和队列的基本操作的实现
J_SUNV的博客
11-20 1346
1. 实验目的 熟练掌握栈和队列的抽象数据类型，能在相应的应用问题中正确选用它们，熟练掌握栈和队列的实现方法（顺序和链式），两种存储结构和基本操作的实现算法，注意空和满的判断条件及它们的描述方法，掌握循环队列与其它顺序结构实现上的不同及解决办法，熟悉各种队列的基本操作在循环队列上的实现 2.实验内容 （1）用栈实现括号匹配的检验 （2）用栈实现形如a+b@b+a#的中心对称的字符序列的检...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
C语言用栈和队列实现的回文检测功能示例
08-30
C语言用栈和队列实现的回文检测功能示例 在计算机科学中，回文检测是指判断给定的字符串是否是一个回文的操作。回文是一种特殊的字符串，它可以从左到右阅读或从右到左阅读，结果是一样的。例如，字符串"madam"就是...
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
实验三 栈和队列的基本操作实现及其应用
qq_40119316的博客
10-14 7301
一、实验目的 1、 熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、学会使用栈和队列解决实际问题。 二、实验内容 1、自己确定结点的具体数据类型和问题规模： 分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。 分别建立一个顺序队列和链队列，实现队列的入队和出队操作。 2、设计算法并写出代码，实现一个十将二进制转换成2
栈和队列的定义和基本操作(c语言版)
【Dyson】的博客
08-16 8173
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈就可以理解为:先入后出(LIFO) Stack.h #pra...
栈和队列的基本操作实现及其应用
05-14
编程模拟队列的管理，主要包括：出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
栈与队列基本操作
m0_60777643的博客
01-30 3746
一.栈 1.顺序栈操作： 注：栈是一种只在头部进行操作的数据结构，不需要用到中间插入和删除，因此一般日常生活中用顺序表的形式来表示栈，操作可能会更方便。 ① 顺序栈的创建（初始化）： ...
实验四 栈和队列的基本操作的实现
ai bohang 的博客
02-11 2672
#include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 #define OVERFLOW 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10
队列的基本操作（实现链式栈）
xuruhua的博客
04-24 1572
  一、熟悉队列的基本概念 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表 （1）进行插入操作的一端称为队尾（入队列） （2）进行删除操作的一端称为队头（出队列） （3)队列具有先进先出（FIFO）的特性 二、 队列的性质 队列是一种操作受限制的线性表 三、 队列存储结构  1、顺序队列： （1）队头不动，出队列时队头后的所有元素向前移动 缺陷：操作时如果出队列比较多，要搬移...
栈和队列的基本操作及其应用
梦想还是要有的
12-06 7408
栈和队列的基本操作及其应用 一、实验目的 1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。 二、实验内容 本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，学生可以根据自己的情况选做！ 题目一：回
C语言实现栈和队列(栈和队列的基本操作)
热门推荐
Damn_Yang的博客
11-10 11万+
栈： 栈：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 特点：先进后出 stack.h #pragma once #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;...
C++基础：C++标准库之栈（stack）和队列（queue）
weixin_30938149的博客
05-05 1382
在C++标准库（STL）中，实现了栈和队列，方便使用，并提供了若干方法。以下作简要介绍。 1、栈（stack）说明及举例： 使用栈，要先包含头文件 ： #include<stack> 定义栈，以如下形式实现： stack<Type> s; 其中Type为数据类型（如 int，float,char等）。 栈的主要操作： s.push(item); //...
【数据结构】堆的实现和堆排序--TOP-K问题
最新发布
2301_78724721的博客
06-21 1040
在头文件中进行堆的定义和接口的声明int size;}HP;//堆的初始化//堆的销毁//堆的插入//堆的删除//取堆顶的数据// 堆的数据个数//堆的判空堆的实现堆是一种特殊的树形数据结构，通常实现为完全二叉树。堆分为最大堆和最小堆，最大堆的父节点值大于或等于其子节点值，而最小堆的父节点值小于或等于其子节点值。堆通常使用数组来实现，通过索引关系模拟树形结构，支持高效的插入、删除和查找最大/最小元素操作。堆排序堆排序是一种基于堆的排序算法。
 数据结构栈和队列实现的问题
05-31
栈和队列都是常见的数据结构，栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。...需要注意的是，在使用数组实现栈和队列时，需要考虑数据溢出的情况，而链表实现则不会有这个问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

‘(尐儍苽-℡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值