C++用栈实现先入先出队列相关知识与代码实现

目录

• 1、栈（stack）的基本知识
• 2、栈（stack）的相关术语和基本操作
• 3、栈的代码测试
•  4、队列的基本知识
• 5、整体所需操作
• 6、用栈实现队列代码解释

 

---

回到顶部

1、栈（stack）的基本知识

C++的栈是一种数据结构，它是一个后进先出（LIFO）的线性结构，具有两个基本操作：push和pop。

push操作将数据压入栈顶，而pop操作将栈顶数据弹出。
C++中的栈实现在STL中，可以使用std::stack来创建一个栈。
std::stack可以被视为一种容器适配器，它基于其他容器实现，
例如std::deque和std::list。

适用场景：
在C++中，栈通常用于实现函数调用堆栈和表达式求值等场景。当一个函数被调用时，它的返回地址和其他必要数据被压入栈中，当函数返回时，这些数据被弹出。

 

             

基本存储方式：

（1）顺序存储：利用一段连续的内存空间进行存储。

（2）链式存储：利用非连续的内存空间存储，元素之间使用指针进行链接。（通常单链表实现，栈顶是表头，栈底的表尾）。

构造函数：

	构造函数原型	解释
1	stack<T> stk	默认构造
2	stack(const stack &stk)	拷贝构造

赋值操作：

	函数原型：=	解释
1	stack& operator=(const stack &stk)	重载=操作符

数据存取：

	函数原型：push、pop、top	解释
1	push(elem)	入栈：向栈顶添加元素
2	emplace()	入栈：构造和添加元素
3	pop()	出栈：移除当前栈顶元素
4	top()	返回栈顶元素

push与emplace的异同点：

• 对于int、double等内置数据类型而言，push()和emplace()是相同的

• 对于自定义数据类型而言，使用push()前必须先将要添加的对象构造出来(实例化)，而使用emplace()既可以填入实例化的对象也可以填入对象的构造参数

回到顶部

2、栈（stack）的相关术语和基本操作

栈顶（top）:

线性表允许插入和删除的那一段。值得注意的是，栈顶指针top的指向是有些两种方式的，一种是指向栈顶当前元素，一种是指向栈顶的下一位置。

栈底（bottom）：

固定的，不允许进行插入和删除的另一端。

空栈：

不含有任何元素的空表。

基本操作：

（1）栈判空：

bool isEmpty(SqStack S)
{
    if (S.top==-1)
    {
        return true;
    }
    return false;
}

（2）栈判满

bool isFull(SqStack S)
{
    if (S.top == MAXSIZE - 1)
    {
        return true;
    }
    return false;
}

（3）入栈

bool Push(SqStack& S, ElemType e)
{
    bool flag = isFull(S);
    if (flag==true)
    {
        printf("栈满\n");
        return false;
    }
    S.top++;
    S.data[S.top] = e;
    return true;
 
}

（4）出栈

bool Pop(SqStack& S, ElemType& e)
{
    bool flag = isEmpty(S);
    if (flag)
    {
        printf("栈空\n");
        return false;
    }
    e = S.data[S.top];
    S.top--;
    return true;
}

（5）取栈顶

//取栈顶
bool GetTop(SqStack& S, ElemType& e)
{
    bool flag = isEmpty(S);
    if (flag)
    {
        return false;
    }
    e = S.data[S.top];
    return true;
}

（6）初始化一个空栈

InitStack(&s);

（7）判断一个在栈是否为空

StackEmpty(s);

回到顶部

3、栈的代码测试

int _tmain(int argc, _TCHAR* argv[])
{
    ArrayStack <int> p(5);
    for (int i = 0; i < 5; i++)
    {
        p.push(i);
    }
    cout << "栈的大小:"<<p.size() << endl;
    cout << "栈是否为空:"<<p.isEmpty() << endl;
    cout << "栈顶元素："<<p.top() << endl;
    cout << "依次出栈:" << endl;
    while (!p.isEmpty())
    {
        cout << p.pop() << endl;
    }
    getchar();
    return 0;
}

回到顶部

 4、队列的基本知识

•  与栈相比，栈是先进后出，队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。
•  在队尾添加元素，在队头删除元素。

队列(queue)的结构如下：类似于生活中的排队买票，最先排队的人位于队伍最前端，后来的人依次从队伍末尾加入队伍。当队首的人买票成功后离开，原先位于第二位的人顶上成为新的队首，后续以此类推。

           

相关术语 ：

（1）入队：队列的插入操作。   允许插入数据的位置叫队尾 

（2）出队：队列的删除操作。   允许删除数据的位置叫队头

 操作：

1.  入队： 通常命名为push()
2.  出队： 通常命名为pop()

 queue构造函数：

	构造函数原型	解释
1	queue<T> que	默认构造
2	queue(const queue &que)	拷贝构造

 queue赋值操作：

	函数原型：=	解释
1	queue& operator =(const queue &que)	重载 = 操作符

 queue数据存取：

	函数原型：push、pop、back、front	解释
1	push(elem)	向队尾添加队尾
2	emplace()	向队尾添加元素
3	pop()	移除当前队首元素
4	back()	返回队尾元素
5	front()	返回队首元素

queue其他操作：

	函数原型：empty、size、swap	解释
1	empty()	判断队列是否为空
2	size()	返回队列的大小
3	swap(queue<T> & que)	将当前队列中元素和que中元素交换

回到顶部

5、整体所需操作

队列

queue<int> q; //定义一个空队列q

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。//同front()
empty() -- 返回队列是否为空。
back()访问队尾元素
size()访问队中的元素个数

栈

stack<int> s;

push(x) -- 元素 x 入栈
pop() -- 移除栈顶元素
top() -- 获取栈顶元素
empty() -- 返回栈是否为空

回到顶部

6、用栈实现队列代码解释

官方：

将一个栈当作输入栈，用于压入 push传入的数据；另一个栈当作输出栈，用于 pop和 peek操作。

每次 pop或 peek时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。

class MyQueue {
private:
    stack<int>inStack, outStack;

    void in2out(){
        while (!inStack.empty()) {
            outStack.push(inStack.top());
            inStack.pop();
        }
    }

public:
    MyQueue() {

    }
    
    void push(int x) {
        inStack.push(x);
    }
    
    int pop() {
        if (outStack.empty()){
            in2out();
        }

        int x = outStack.top();
        outStack.pop();
        return x;

    }
    
    int peek() {
        if (outStack.empty()){
            in2out();
        }
        return outStack.top();

    }
    
    bool empty() {
        return inStack.empty() && outStack.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();
 */