算法导论 使用两个栈实现队列

最新推荐文章于 2022-04-28 22:16:05 发布
最新推荐文章于 2022-04-28 22:16:05 发布
阅读量590 收藏
点赞数
分类专栏： 1. 算法导论 学习笔记 文章标签： 算法导论 栈 队列 C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_24229853/article/details/48478385
版权

使用两个栈实现队列

1. 如何使用两个栈实现队列？

因为栈的顺序是后进先出，队列是先进先出。通过把一个栈“倒”进第二个栈，可以在第二个栈以原来入栈的顺序出栈，就达到了队列的先进先出效果。
注意关于如何“倒”，也有效率的高低之分。
我使用的方法是（一个栈称StackIn，另一个栈称StackOut）：
1.当入队列时，不用判断StackOut有没有元素，只要没达到队列的上限，就直接压入StackIn。
2.当出队列时，如果StackOut不为空，直接弹出StackOut的栈顶元素；如果StackOut是空的，那么让StackIn的元素先倒进StackOut，再从StackOut弹出栈顶元素。
这种方法时间复杂度是相对其他几种方法比较低的。关于另外几种如何“倒”的方法，更详细的介绍，可以看另一篇博文：http://www.cnblogs.com/wanghui9072229/archive/2011/11/22/2259391.html

2. 使用两个栈实现队列的实现（C++代码）

//SequeStack.h
#pragma once

#include <assert.h>

template<typename ElemType>
class SequeStack
{
public:
    SequeStack(unsigned int size);
    bool Push(ElemType elem);
    bool Pop(ElemType* retElem);
    bool Empty() const;
    bool Visit(ElemType* elem, unsigned int pos) const;
    bool Full() const;
    unsigned int const& GetLength() const;
private:
    ElemType* m_array;
    unsigned int m_top;
    unsigned int m_size;
    unsigned int m_length;
};

template<typename ElemType>
unsigned int const& SequeStack<ElemType>::GetLength() const
{
    return m_top;
}

template<typename ElemType>
bool SequeStack<ElemType>::Full() const
{
    return m_top >= m_size ? true : false;
}

template<typename ElemType>
bool SequeStack<ElemType>::Visit(ElemType* elem, unsigned int pos) const
{
    if (pos >= m_size || pos < 0)
    {
        assert(false && "Error: Visit Pos is out range of array!");
        return false;
    }
    *elem = m_array[pos];
    return true;
}


template<typename ElemType>
bool SequeStack<ElemType>::Empty() const
{
    return m_top ? false : true;
}

template<typename ElemType>
bool SequeStack<ElemType>::Pop(ElemType* retElem)
{
    if (Empty())
    {
        assert(false && "Error: SequeStack is underflow!");
        return false;
    }
    else
    {
        *retElem = m_array[--m_top];
        return true;
    }
}

template<typename ElemType>
bool SequeStack<ElemType>::Push(ElemType pushElem)
{
    if (m_top == m_size)
    {
        assert(false && "Error: SequeStack is overflow!");
        return false;
    }
    else
    {
        m_array[m_top++] = pushElem;
        return true;
    }

}

template<typename ElemType>
SequeStack<ElemType>::SequeStack(unsigned int size)
    : m_array(new ElemType[size]),m_top(0),m_size(size),m_length(0)
{
    memset(m_array,0,sizeof(ElemType)*size);
}

//QueueByTwoStack.h
#pragma once

#include <assert.h>
#include "SequeStack.h"

template<typename ElemType>
class QueueByTwoStack
{
public:
    QueueByTwoStack(unsigned int size);
    bool DeQueue(ElemType* elem);
    bool EnQueue(const ElemType& elem);
    bool Empty() const;
    bool Visit(ElemType* elem, const unsigned int& pos) const;
    unsigned int GetLength() const;
private:
    bool StackInToStackOut();
    SequeStack<ElemType>* m_stackIn;
    SequeStack<ElemType>* m_stackOut;
    unsigned int m_size;
};

template<typename ElemType>
unsigned int QueueByTwoStack<ElemType>::GetLength() const
{
    return m_stackIn->GetLength() + m_stackOut->GetLength();
}

template<typename ElemType>
bool QueueByTwoStack<ElemType>::StackInToStackOut()
{
    if (!m_stackOut->Empty()) // StackOut必须为空才能倒
    {
        return false;
    }

    while(!m_stackIn->Empty()) //现在将m_stackIn倒进m_stackOut
    {
        ElemType tempElem;
        m_stackIn->Pop(&tempElem);
        m_stackOut->Push(tempElem);
    }
    return true;
}

template<typename ElemType>
bool QueueByTwoStack<ElemType>::Visit(ElemType* elem, const unsigned int& pos) const
{
    if (pos >= m_size)
    {
        return m_stackOut->Visit(elem, pos - m_size);
    }
    else
    {
        return m_stackIn->Visit(elem, pos);
    }
}

template<typename ElemType>
bool QueueByTwoStack<ElemType>::Empty() const
{
    if (m_stackIn->Empty() && m_stackOut->Empty())
        return true;
    return false;
}

template<typename ElemType>
bool QueueByTwoStack<ElemType>::EnQueue(const ElemType& elem)
{
    if ( m_stackIn->Push(elem) && GetLength() <= m_size )
    {
        return true;
    }
    assert(false && "Error: SequeDeQueue is overflow!");
    return false;
}

template<typename ElemType>
bool QueueByTwoStack<ElemType>::DeQueue(ElemType* elem)
{
    if (Empty())
    {
        assert(false && "Error: SequeDeQueue is underflow!");
        return false;
    }

    StackInToStackOut(); //尝试倒进stackOut

    return m_stackOut->Pop(elem);
}

template<typename ElemType>
QueueByTwoStack<ElemType>::QueueByTwoStack(unsigned int size)
    :m_stackIn(new SequeStack<ElemType>(size)),m_stackOut(new SequeStack<ElemType>(size)),m_size(size)
{

}

//Util.h
#pragma once

namespace Util
{
    template<typename T>
    void PrintMemory(const T& dateStruct, unsigned int size)
    {
        cout << "PrintMemory: ";
        for (int i = 0; i != size; i++)
        {
            ElemType tempElem;
            dateStruct.Visit(&tempElem,i);
            printf("%d ",tempElem);
        }
        printf("\n");
        printf("\n");
    }
}
#include "Util.h"
#include "QueueByTwoStack.h"
#include <iostream>

using namespace std;

typedef int ElemType;

int main()
{

    const int QUEUE_SIZE = 6;
    QueueByTwoStack<int> testQueueByTwoStack(QUEUE_SIZE);

    cout << "testQueueByTwoStack is " << (testQueueByTwoStack.Empty() ? "Empty." : "Not Empty.") << endl;
    Util::PrintMemory(testQueueByTwoStack,QUEUE_SIZE*2);

    for (int i = 0; i != 4; i++) //4个元素入队列{1、2、3、4}
    {
        testQueueByTwoStack.EnQueue(i+1);
        cout << "EnQueue:" << i+1 << endl;
        cout << "testQueueByTwoStack is " << (testQueueByTwoStack.Empty() ? "Empty." : "Not Empty.") << endl;
        Util::PrintMemory(testQueueByTwoStack,QUEUE_SIZE*2);
    }

    for (int i = 0; i != 2; i++) //2个元素出队列{1、2}
    {
        ElemType tempElem;
        testQueueByTwoStack.DeQueue(&tempElem);
        cout << "DeQueue:" << tempElem << endl;
        cout << "testQueueByTwoStack is " << (testQueueByTwoStack.Empty() ? "Empty." : "Not Empty.") << endl;
        Util::PrintMemory(testQueueByTwoStack,QUEUE_SIZE*2);
    }

    for (int i = 0; i != 4; i++) //4个元素入队列{5、6、7、8}
    {
        testQueueByTwoStack.EnQueue(i+5);
        cout << "EnQueue:" << i+5 << endl;
        cout << "testQueueByTwoStack is " << (testQueueByTwoStack.Empty() ? "Empty." : "Not Empty.") << endl;
        Util::PrintMemory(testQueueByTwoStack,QUEUE_SIZE*2);
    }

    for (int i = 0; i != 6; i++) //6个元素出队列{3、4、5、6、7、8}
    {
        ElemType tempElem;
        testQueueByTwoStack.DeQueue(&tempElem);
        cout << "DeQueue:" << tempElem << endl;
        cout << "testQueueByTwoStack is " << (testQueueByTwoStack.Empty() ? "Empty." : "Not Empty.") << endl;
        Util::PrintMemory(testQueueByTwoStack,QUEUE_SIZE*2);
    }

    return 0;
}

3. 程序运行结果

testQueueByTwoStack is Empty.
PrintMemory: 0 0 0 0 0 0 0 0 0 0 0 0

EnQueue:1
testQueueByTwoStack is Not Empty.
PrintMemory: 1 0 0 0 0 0 0 0 0 0 0 0

EnQueue:2
testQueueByTwoStack is Not Empty.
PrintMemory: 1 2 0 0 0 0 0 0 0 0 0 0

EnQueue:3
testQueueByTwoStack is Not Empty.
PrintMemory: 1 2 3 0 0 0 0 0 0 0 0 0

EnQueue:4
testQueueByTwoStack is Not Empty.
PrintMemory: 1 2 3 4 0 0 0 0 0 0 0 0

DeQueue:1
testQueueByTwoStack is Not Empty.
PrintMemory: 1 2 3 4 0 0 4 3 2 1 0 0

DeQueue:2
testQueueByTwoStack is Not Empty.
PrintMemory: 1 2 3 4 0 0 4 3 2 1 0 0

EnQueue:5
testQueueByTwoStack is Not Empty.
PrintMemory: 5 2 3 4 0 0 4 3 2 1 0 0

EnQueue:6
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 3 4 0 0 4 3 2 1 0 0

EnQueue:7
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 4 0 0 4 3 2 1 0 0

EnQueue:8
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 4 3 2 1 0 0

DeQueue:3
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 4 3 2 1 0 0

DeQueue:4
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 4 3 2 1 0 0

DeQueue:5
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 8 7 6 5 0 0

DeQueue:6
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 8 7 6 5 0 0

DeQueue:7
testQueueByTwoStack is Not Empty.
PrintMemory: 5 6 7 8 0 0 8 7 6 5 0 0

DeQueue:8
testQueueByTwoStack is Empty.
PrintMemory: 5 6 7 8 0 0 8 7 6 5 0 0

梦幻DUO
关注
专栏目录
算法导论 - 基于 C# 的栈和队列实现
东城十三
06-23 780
栈和队列是两种基础且常用的数据结构。栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。通过本文档，您应能够理解栈和队列的基本原理及其在 C# 中的实现，并能够在合适的场景中应用这些数据结构。
剑指 Offer 09. 用两个栈实现队列
Hanfeige的博客
09-11 327
剑指 Offer 09. 用两个栈实现队列 题目描述： 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例： 输入： ["CQueue","appendTail","deleteHead","deleteHead"] [[],[3],[],[]] 输出：[null,null,3,-1] 示例二; 输入： ["CQueue","de
剑指offer 20.用两个栈实现队列
拥抱技术
04-28 122
class MyQueue { public: /** Initialize your data structure here. */ //用两个栈实现队列。时间复杂度o(n); //push操作就是在主栈上push //pop操作就是先将主栈元素输入到副栈里，然后弹出栈顶元素，再Pop; //peek 操作相对于pop操作少一个pop操作即可，弹出副栈栈顶即可。 //empty 就是判断主栈是否为空。 stack<int>sta,c; .
两个栈实现队列
李豆豆的博客
12-20 337
用两个栈实现队列，并分析相关队列操作的运行时间。 单栈push和pop的运行时间都为O(1)，所以需要考虑的就是两个栈之间切换所用时间。 最坏情况：在push和pop交替操作时，需要将一个栈中的数据转移到另一个栈中，转移所用时间为O(n)，n为当前栈中元素个数。 最好情况：用flag记录上一次是push还是pop，如果和当前操作一致，则直接操作对应的栈，时间复杂度为O(1)。 package main const maxSize = 10 type StackDeque struct { push
两个队列实现栈
李豆豆的博客
12-21 220
用两个队列实现栈，并分析相关栈操作的运行时间。 思路同：两个栈实现队列 type DequeStack struct { pushDeque *Deque popDeque *Deque flag bool // true in push, false in pop } func (d *DequeStack) exchange(from, to *Deque) { to.Clean() for true { if v, ok := from.Pop(); ok { to.Push(v
算法导论 使用两个队列实现一个栈
梦幻DUO的游戏开发之路
09-17 763
用两个队列实现一个栈1. 算法导论原题 10.1-7 Show how to implement a stack using two queues. Analyze the running time of the stack operations. 译：使用两个队列实现一个栈。分析栈操作的运行时间（这部分本博文不解答）。 2. 如何使用两个队列实现一个栈？ 由于队列的方式是后进后
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
栈和队列的数组实现—《算法导论》学习笔记之六
Mr_Avin的博客
11-26 538
《算法导论》在介绍了一些排序算法以及关于它们运行的时间分析后，开始介绍一些简单的数据结构，栈，队列，表，有根树···这些是实现高级数据结构以及更多算法设计的基础知识，有一种排序算法是桶排序，可以利用链表的结构在线性时间内完成排序。   栈和队列是经常放在一块比较的两种结构，栈的特性是先进后出(FILO)，而队列的特性是先进先出(FIFO)。在现实生活中可以找到很多有这两种特性的例子，笔者在此不作
算法导论 用两个队列实现一个栈 10.1-7
臻舍
05-27 445
问题：用两个队列实现一个栈 思路：队列是先进先出，栈是后进先出。将Q.tail当成S.top，则出栈和队列的删除相同。入栈，要通过一个空的队列L1和另一个存有之前值的队列L2，设值x要存入栈中，则先将x存入空的队列L1中，再依次将L2的值取出加入到L1中。 代码：
mit算法导论期末试题+答案原版
01-05
### MIT算法导论期末试题及答案解析 #### 标题解析 标题“MIT算法导论期末试题+答案原版”明确指出了这份资料是麻省理工学院（MIT）《算法导论》课程的期末考试题目及其对应的答案。这里的“原版”强调了这是官方...
算法导论第三版答案_算法导论_
09-29
《算法导论》是计算机科学领域的一本经典之作，它深入浅出地介绍了算法的设计、分析和实现。这本书对于Python编程者来说，尤其有价值，因为它不仅涵盖了基础算法，还涉及了高级算法技巧，有助于提升编程者的问题解决...
算法导论用C++实现代码
04-18
在《算法导论》的C++实现中，我们可能会遇到以下几个关键知识点： 1. **基本数据结构**：包括数组、链表、栈、队列、哈希表和树等。例如，二分查找通常在有序数组中使用，而链表可以用于实现动态大小的数据结构，如...
算法导论 顺序双向栈——两个栈共享同一存储空间
梦幻DUO的游戏开发之路
09-15 4379
双向栈——两个栈共享同一存储空间1. 什么是双向栈？ 算法导论原题： 10.1-2 Explain how to implement two stacks in one array A[1..n] in such a way that neither stack overflows unless the total number of elements in both stacks
算法导论 XOR双向循环链表——内存高效链表
梦幻DUO的游戏开发之路
09-20 1903
XOR双向循环链表——内存高效双向链表1. 算法导论原题 10.2-8 ? Explain how to implement doubly linked lists using only one pointer value x.np per item instead of the usual two(next and pre). Assume that all pointer values
算法导论 顺序循环双向队列
梦幻DUO的游戏开发之路
09-15 1498
顺序双向队列1. 什么是顺序双向队列？ 算法导论原题： 10.1-5 Whereas a stack allows insertion and deletion of elements at only one end, and a queue allows insertion at one end and deletion at the other end, a deque (dou
算法导论 O(n)时间内反转单链表
梦幻DUO的游戏开发之路
09-18 1488
算法导论 O(n)时间内反转单链表1. 算法导论原题 Give a O(n) time nonrecursive procedure that reverses a singly linked list of n elements. The procedure should use no more than constant storage beyond that needed for thel
算法导论 使用单链表实现队列
梦幻DUO的游戏开发之路
09-17 1228
使用单链表实现队列1. 算法导论原题 10.2-3 Implement a queue by a singly linked list L. The operations ENQUEUE and DEQUEUE should still take O(1) time. 译：使用两个队列实现一个队列。入队和出队的时间复杂度都应该是O(1)。 2. 使用单链表实现队列 我们假设链表是
算法导论 KMP字符串匹配
梦幻DUO的游戏开发之路
09-28 1052
KMP字符串匹配 1. KMP字符串匹配的原理 Knuth-Morris-Pratt算法（简称KMP），是一种非常高效的字符串匹配。设n为文本的长度，m为待查找文本模板的长度，则预处理时间需要O（m），匹配时间需要O（n）。 1.预处理阶段。KMP字符串匹配的原理就是为待查找的字符串模板创建一个前缀函数，该前缀函数得到对于模板每一个子字符串(1~i)，若有相同的长度的前缀和相同的长度的后缀的字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值