栈与队列的相关题目

  1. 栈的实现(数组)
  2.  1 template<typename T> class ArrayStack {
     2 public:
     3     ArrayStack(int c = 100): capacity(c), top(-1) {
     4         data = new T[capacity]();
     5     }
     6     ArrayStack(const ArrayStack &rhs):capacity(rhs.capacity), top(rhs.top) {
     7         data = new T[capacity]();
     8
     9         std::copy(rhs.data, rhs.data + capacity, data);
    10     }
    11
    12     ArrayStack& operator=(ArrayStack rhs) {
    13         Swap(rhs);
    14
    15         return *this;
    16     }
    17
    18     ~ArrayStack() {
    19         delete []data;
    20     }
    21
    22     void Push(const T& val) {
    23         data[++top] = val;
    24     }
    25
    26     void Pop()
    27     {
    28         if (top > -1)
    29             --top;
    30     }
    31
    32     T& Top()
    33     {
    34         return data[top];
    35     }
    36
    37     const T& Top() const
    38     {
    39         return data[top];
    40     }
    41
    42     bool Empty()
    43     {
    44         return top == -1;
    45     }
    46
    47     std::size_t Size()
    48     {
    49         return top + 1;
    50     }
    51
    52 private:
    53     void Swap(ArrayStack &rhs) {
    54         std::swap(capacity, rhs.capacity);
    55         std::swap(top, rhs.top);
    56         std::swap(data, rhs.data);
    57     }
    58
    59     int capacity;
    60     int top;
    61     T *data;
    62 };
  3. 两个栈实现一个队列

     1 template <class T> class StackQueue {
     2  public:
     3     StackQueue(){}
     4     size_t size() {
     5         return s1.size() + s2.size();
     6     }
     7
     8     bool empty() {
     9         return size() == 0;
    10     }
    11
    12     void push(const T& val) {
    13         s1.push(val);
    14     }
    15
    16     void pop() {
    17         if (s2.empty()) {
    18             while (!s1.empty()) {
    19                 s2.push(s1.top());
    20                 s1.pop();
    21             }
    22         }
    23         s2.pop();
    24     }
    25
    26     T& front() {
    27         if (!s2.empty())
    28             return s2.top();
    29         while (!s1.empty()) {
    30             s2.push(s1.top());
    31             s1.pop();
    32         }
    33
    34         return s2.top();
    35     }
    36
    37  private:
    38      std::stack<T> s1, s2;
    39 };
  4. 栈的压入、弹出序列
    输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为该栈的弹出序列。假设压入栈的所有数字均不相等。例如,序列1,2,3,4,5是某栈的压栈序列,序列4,5,3,2,1是该栈的对应的一个弹出序列,但4,3,5,2,1就不可能是该压栈序列的弹出序列。

     1 #include<iostream>
     2 #include<stack>
     3
     4 bool IsPopOrder(const int *pushorder, const int * poporder, int length) {
     5     if (pushorder == NULL || poporder == NULL || length <= 0)
     6         return false;
     7
     8     std::stack<int> s;
     9
    10     const int *pop_val = poporder;
    11     const int *push_val = pushorder;
    12
    13     while (pop_val - poporder < length) {
    14         while (s.empty() || s.top() != *pop_val) {
    15             if (push_val - pushorder == length)
    16                 break;
    17
    18             s.push(*push_val++);
    19         }
    20
    21         if (s.top() != *pop_val)
    22             return false;
    23
    24         s.pop();
    25         pop_val++;
    26     }
    27
    28     return true;
    29
    30 }
时间: 2024-11-08 15:29:45

栈与队列的相关题目的相关文章

关于栈和队列的相关问题

#include<iostream> using namespace std; #include<stack> #include<queue> #include<assert.h> //template<class T> //两个栈实现一个队列 //class StackToqueue //{ //public: // StackToqueue() // {} // void Push(const T& x) // {//始终保持让栈1进

关于栈和队列的相关操作

1.栈  分为顺序栈和链栈  对应数组和链表 top指向栈顶元素,设置空栈为-1:存在一个元素时top=0 栈的长度为StackSize 定义栈的结构体: 1 #include "stdio.h" 2 3 /* 存储空间初始分配量 */ 4 #define MAXSIZE 20 5 6 /* SElemType类型根据实际情况而定,这里假设为int */ 7 typedef int SElemType; 8 9 /* 顺序栈结构 */ 10 typedef struct 11 { 12

[ACM训练] 算法初级 之 数据结构 之 栈stack+队列queue (基础+进阶+POJ 2442+1442)

再次面对像栈和队列这样的相当基础的数据结构的学习,应该从多个方面,多维度去学习. 首先,这两个数据结构都是比较常用的,在标准库中都有对应的结构能够直接使用,所以第一个阶段应该是先学习直接来使用,下一个阶段再去探究具体的实现,以及对基本结构的改造! C++标准库中 这里记录一个经典的关于栈和队列的面试题目: 题目:实现一个栈,带有出栈(pop),入栈(push),取最小元素(getMin)三个方法.要保证这三个方法的时间复杂度都是O(1). 思路:重点是getMin()函数的设计,普通思路是设计一

数据结构与算法系列研究二——栈和队列

栈和队列的相关问题分析 一.栈和队列定义 栈和队列是两种重要的数据结构.从结构特性角度看,栈和队列也是线性表,其特殊性在于它们的基本操作是线性表的子集,是操作受限的线性表,可称为限定性的数据结构:从数据类型角度看,其操作规则与线性表大不相同,是完全不同于线性表的抽象数据类型.                    图1 栈的结构                                                 图2 队列的结构   1.1.栈是限定在表的一端进行插入和删除操作的线性

九度_题目1512:用两个栈实现队列

这个思路实在太难想了.... /* *str为PUSH,通过s1.push()使元素入栈; *str为POP时,s2非空,输出栈顶元素,s2.pop()弹出栈顶元素;若s2弹出元素后为空且s1不空,将s1中所有元素push进s2: *str为POP时,s2为空,若s1不空,将s1中所有元素push进s2,最后输出栈顶元素并通过<span style="font-family: Arial, Helvetica, sans-serif;">s2.pop()弹出栈顶元素<

栈与队列相关笔试题

1.用两个栈实现队列 分析:队列的特点是"先进先出",而栈的特点是"后进先出",入队列时让所有的元素进到stack1中,出队列时先判断stack2是否为空,不为空直接pop即可,若为空,将stack1中所有的元素"倒入"stack2中,这样就用两个栈实现了队列. 实现代码: class Solution { public: void push(int node) { stack1.push(node); } int pop() { if(stac

题目七:用两个栈实现队列

//////////////////////////////////////////////////////////////////////////////////// // 10.题目七:用两个栈实现队列 // 题目:用两个栈实现一个队列,队列的声明如下: template <typename TYPE> class CQueue { public: CQueue(){} ~CQueue(){} void AppendTail(const TYPE& node); TYPE Dele

数据结构——栈和队列相关算法实现

数据结构栈和队列的基本算法实现 限定性线性表--栈 栈的定义 栈作为一种限定性的线性表,是将线性表的插入和删除操作限制为仅在表的一端进行. 基本算法演示 /* 栈的常见操作: 1.初始化栈 2.元素进栈 3.元素出栈 4.栈的遍历 5.判断栈是否为空栈 6.清空整个栈 */ # include <stdio.h> # include <stdlib.h> typedef struct Node { int date; struct Node * pNext; }NODE,* PNO

栈和队列数据结构的基本概念及其相关的Python实现

先来回顾一下栈和队列的基本概念: 相同点:从"数据结构"的角度看,它们都是线性结构,即数据元素之间的关系相同. 不同点:栈(Stack)是限定只能在表的一端进行插入和删除操作的线性表. 队列(Queue)是限定只能在表的一端进行插入和在另一端进行删除操作的线性表.它们是完全不同的数据类型.除了它们各自的基本操作集不同外,主要区别是对插入和删除操作的"限定". 栈必须按"后进先出"的规则进行操作:比如说,小学老师批改学生的作业,如果不打乱作业本的顺