【Python、C++】栈的基本实现

一.栈的含义

栈是一种基本的数据结构，它是有序集合，它的元素总是从栈的“顶端”(top)输入，同时从栈的“顶端”输出。所以它遵循的原则是先入后出，即FILO（first-in-last-out）。

根据上述要求，我们可以知道最先输入的元素在最低端，且其最后输出；最后输入的元素在最顶端，且其最先输出。

---

实现思路：

$\bullet$ 对于栈来说，它既可以用数组实现也可以用链表实现，下面我们分别用Python数组、C++数组、C++链表进行实现。

$\bullet$ 对于栈来说，它的最主要操作就是入栈（push）、出栈（pop）。此外，我们还会实现判空、判满、显示栈顶元素、打印栈中所有元素的操作

---

二.栈的实现（Python）

(1)基本操作函数

函数	作用
Stack()	创建一个空栈，它返回一个栈
push(item)	将一个元素item加入栈顶端，无返回值
peek()	把栈顶端的元素返回
pop()	把栈顶端的元素删除并返回
isEmpty()	判断栈是否为空，返回一个布尔值
size()	返回栈的长度（元素个数）

(2)代码实现

class Stack:
    def __init__(self):    #初始化函数，生成一个空栈（基于列表）
        self.items = []
    def isEmpty(self):     #判断是否为空，即判断存放元素的列表是否为空
        return self.items == []
    def push(self,item):   #向栈中加入元素，调用列表的append函数
        self.items.append(item)
    def peek(self):        #返回栈顶元素
        return self.items[len(self.items)-1]
    def pop(self):         #删除栈顶元素，调用列表pop函数
        return self.items.pop()
    def size(self):        #返回长度，调用len函数
        return len(self.items)

(3)具体操作

>>> s = Stack()
>>> s.isEmpty()
True
>>> s.push(4)
>>> s.push('dog')
>>> s.isEmpty()
False
>>> s.push(8.4)
>>> s.size()
3
>>> s.pop()
8.4

三.栈的实现（C++）

（1）数组实现

代码

#include<iostream>
#include<cstdlib>
using namespace std;
/*
    使用数组实现Stack
*/
class Stack
{
    private:
        int *arr;
        int top;
        int maxSize;
    public:
        //构造函数
        Stack(int size)
        {
            top=-1;
            maxSize=size;
            arr = new int[maxSize];
        }
        //判满
        bool isFull()
        {
            return maxSize-1==top;
        }
        //判空
        bool isEmpty()
        {
            return top==-1;
        }
        //向栈中添加数据
        void push(int a)
        {
            if(isFull())
            {
                cout<<"The Stack is full!"<<endl;
                return ;
            }
            arr[++top]=a;
            cout<<a<<" has been pushed!"<<endl;
        }
        //删除并返回栈顶元素
        int pop()
        {
            if(isEmpty())
            {
                cout<<"The Stack is empty!"<<endl;
                return -1;
            }
            return arr[top--];
        }
        //返回栈顶元素
        int front()
        {
            if(isEmpty())
            {
                cout<<"The Stack is empty!"<<endl;
            }
            return arr[top];
        }
        //打印栈中元素
        void print()
        {
            if(isEmpty())
            {
                cout<<"The Stack is empty!"<<endl;
            }
            int index=top;
            while(index>=0)
            {
                cout<<arr[index]<<" ";
                index--;
            }
            cout<<endl;
        }
};


int main()
{
    Stack s=Stack(4);
    s.push(1);
    s.push(2);
    s.push(5);
    s.push(7);
    s.push(9);
    cout<<"The front element is "<<s.front()<<endl;

    s.print();

    system("pause");
    return 0;
}

结果

（2）链表实现

代码

#include<iostream>
#include<cstdlib>
using namespace std;
/*
    使用单链表实现Stack
*/
//链表节点
class node
{
    public:
        int value;
        node* next;
        node(int val,node* nextval=NULL)
        {
            value=val;
            next=nextval;
        }
};
//链表
class Stack
{
    private:
        int maxSize;
        int size;
        node* top;
    public:
        //构造函数
        Stack(int Size)
        {
            size=0;
            this->maxSize=Size;
        }
        //判满
        bool isFull()
        {
            return size==maxSize;
        }
        //判空
        bool isEmpty()
        {
            return size==0;
        }

        //入栈
        void push(int value)
        {
            if(isFull())
            {
                cout<<"The Stack is full!"<<endl;
                return ;
            }

            if(size==0)
            {
                //得新建一个节点
                top=new node(value);
            }else
            {
                node* temp=top;
                top=new node(value);
                top->next=temp;
            }
            size++;
            cout<<value<<" has been pushed!"<<endl;
        }
        //出栈
        int pop()
        {
            if(isEmpty())
            {
                cout<<"The Stack isempty!"<<endl;
                return -1;
            }
            int val=top->value;
            top=top->next;
            size--;
            return val;
        }
        //返回栈顶元素
        int front()
        {
            if(isEmpty())
            {
                cout<<"The Stack is empty!"<<endl;
            }
            return top->value;
        }
        //打印栈中元素
        void print()
        {
            if(isEmpty())
            {
                cout<<"The Stack is empty!"<<endl;
            }
            node* temp=top;
            while(temp!=NULL)
            {
                int val=temp->value;
                cout<<val<<" ";
                temp=temp->next;
            }
            cout<<endl;
        }
}; 

int main()
{
    Stack s=Stack(4);
    s.push(1);
    s.push(2);
    s.push(5);
    s.push(7);
    s.push(9);
    cout<<"The front element is "<<s.front()<<endl;

    s.print();
    
    system("pause");
    return 0;
}

结果