C++ 栈_清空栈

理论原理：

 顺序栈代码实现：

#include <iostream>
#include <string>
 
using namespace std;
 
#define MAX 10
 
template<typename T>
struct Stack
{
    T data[MAX];
    int size;
    Stack(T *data);
    //入栈
    void pushStack(T t);
    //出栈
    void popStack();
    //访问栈顶元素
    T* topStack();
    //获取栈大小
    int sizeStack();
    //清空栈
    void clearStack();
};
 
struct Person
{
    string name;
    int age;
};
 
template<typename T>
Stack<T>::Stack(T *data)
{
    size=0;
}
 
template<typename T>
void Stack<T>::pushStack(T t)
{
    if(size == MAX)
    {
        return;
    }
    data[size]=t;
    size++;
}
 
template<typename T>
void Stack<T>::popStack()
{
    if(size == 0)
    {
        return;
    }
    size--;
}
 
template<typename T>
T* Stack<T>::topStack()
{
    if(size == 0)
    {
        return NULL;
    }
    return &data[size-1];
}
 
template<typename T>
int Stack<T>::sizeStack()
{
    return size;
}
 
template<typename T>
void Stack<T>::clearStack()
{
    size=0;
}
 
 
int main()
{
    //初始化数据
    Person p[5]={{"A",10},{"B",20},{"C",30},{"D",40},{"E",50}};
    //初始化栈
    Stack<Person> stack(NULL);
    //入栈
    for(int i=0;i<5;i++)
    {
        stack.pushStack(p[i]);
    }
    //获取栈大小
    cout<<stack.sizeStack()<<endl;
    //获取栈顶元素
    Person *person=stack.topStack();
    cout<<person->name<<" "<<person->age<<endl;
    //出栈
    stack.popStack();
    //获取栈顶元素
    person=stack.topStack();
    cout<<person->name<<" "<<person->age<<endl;
    //清空栈
    stack.clearStack();
    //获取栈大小
    cout<<stack.sizeStack()<<endl;
    //获取栈顶元素
    person=stack.topStack();
    cout<<person->name<<" "<<person->age<<endl;
    return 0;
}

 顺序栈运行结果：

链式栈代码实现 ：

#include <iostream>
#include <string>
 
using namespace std;
 
struct Link_Node
{
    Link_Node *next;
};
 
struct Link_Stack
{
    Link_Node *head;
    int size;
    Link_Stack();
    ~Link_Stack();
    //入栈
    void pushStack(Link_Node *node);
    //出栈
    void popStack();
    //访问栈顶元素
    Link_Node* topStack();
    //获取栈的大小
    int sizeStack();
    //清空栈
    void clearStack();
};
 
struct Person
{
    Link_Node node;
    string name;
    int age;
    Person(string name,int age);
};
 
Link_Stack::Link_Stack()
{
    head=new Link_Node;
    head->next=NULL;
    size=0;
}
 
Link_Stack::~Link_Stack()
{
    delete head;
}
 
void Link_Stack::pushStack(Link_Node *node)
{
    node->next=head->next;
    head->next=node;
    size++;
}
 
void Link_Stack::popStack()
{
    if(size == 0)
    {
        return;
    }
    head->next=head->next->next;
    size--;
}
 
Link_Node *Link_Stack::topStack()
{
    if(size == 0)
    {
        return NULL;
    }
    return head->next;
}
 
int Link_Stack::sizeStack()
{
    return size;
}
 
void Link_Stack::clearStack()
{
    head->next=NULL;
    size=0;
}
 
Person::Person(string name, int age)
{
    this->name=name;
    this->age=age;
}
 
int main()
{
    //初始化数据
    Person p1("A",10);
    Person p2("B",20);
    Person p3("C",30);
    Person p4("D",40);
    Person p5("E",50);
    //初始化栈
    Link_Stack stack;
    //入栈
    stack.pushStack((Link_Node*)&p1);
    stack.pushStack((Link_Node*)&p2);
    stack.pushStack((Link_Node*)&p3);
    stack.pushStack((Link_Node*)&p4);
    stack.pushStack((Link_Node*)&p5);
    //访问栈顶元素
    Person *person=(Person*)stack.topStack();
    cout<<person->name<<" "<<person->age<<endl;
    //出栈
    stack.popStack();
    person=(Person*)stack.topStack();
    cout<<person->name<<" "<<person->age<<endl;
    cout<<stack.sizeStack()<<endl;
    stack.clearStack();
    cout<<stack.sizeStack()<<endl;
    return 0;
}

链式栈运行结果：