c++实现栈的各种操作_清空栈函数

以下是c++实现的栈的各种操作：

本例中栈的结构如下图：

#include <iostream>
using namespace std;
 
//    定义一个节点的结构
typedef struct Node
{
    int data;            //数据域
    struct Node * next;//指针域
}NODE,*PNODE;
 
//    定义一个栈结构
typedef struct Stack
{
    PNODE pTop;            //栈顶
    PNODE pBottom;        //栈底
}STACK,*PSTACK;
 
void InitStack(PSTACK );        //    初始化栈的函数
bool PushStack(PSTACK ,int);    //    进行压栈操作的函数
void TraverseStack(PSTACK );    //    遍历栈函数
bool IsEmpty(PSTACK );          //    判断栈是否为空的函数
int PopStack(PSTACK);           //    进行出栈操作的函数
void Clear(PSTACK );            //    清空栈的函数
 
int main(void)
{
    STACK S;                        //    定义一个栈
    int i;
    int num;
    int data;                        //    临时保存用户输入的数据
    int re_num;                        //    保存PopStack函数的返回值
    InitStack(&S);
    cout << "你想输入的数据个数：";
    cin >> num;
    for (i = 0;i < num;i++)
    {
        cout << "第" << i+1 << "个数：";
        cin >> data;
        if (PushStack(&S,data))                //    调用PushStack函数
        {
            continue;
        }
        else
        {
            cout << "进行进栈操作失败！\n";
        }
    }
    TraverseStack(&S);                        //    调用遍历函数
    cout << endl << "你想去掉的数字个数: ";
    cin >> data;
    cout << endl << "你去掉的数字是：";
    for (i = 0; i < data;i++)
    {
        re_num = PopStack(&S);              //    调用PopStack函数，并把返回值赋给re_num;
        cout << re_num << " ";
    }
    cout << endl << "删除后剩下的数字：";
    TraverseStack(&S);
    cout << endl;
    Clear(&S);                             //    调用清空栈函数
    cout << endl << "清空栈后...\n";
    TraverseStack(&S);
    cout << endl;
    return 0;
}
 
//    进行栈的初始化的函数
void InitStack(PSTACK pS)
{
    pS->pTop = new NODE;                  //    分配内存空间给栈顶
    if (NULL == pS->pTop)
    {
        cout << "动态分配内存失败\n";
    }
    else
    {
        pS->pBottom = pS->pTop;           //    使栈底也指向栈顶空间
        pS->pTop->next = NULL;            //    栈顶指针置为NULL；
    }
    return ;
}
 
//    进行进栈操作的函数
bool PushStack(PSTACK pS,int data)
{
    PNODE pNew = new NODE;                    //    定义一个新节点，并分配内存空间
    if (NULL == pNew)
    {
        return false;
    }
    pNew->data = data;                        //    把要进栈的数据赋给新节点的data成员
    pNew->next = pS->pTop;                        //    使新节点的指针指向栈顶
    pS->pTop = pNew;                                //    把新节点作为新栈顶
 
    return true;
}
 
//    遍历栈的函数
void TraverseStack(PSTACK pS)
{
    PNODE pNew = pS->pTop;
    while(pNew!= pS->pBottom)                //    只要栈顶不等于栈底，循环
    {
        cout << pNew->data << " ";           //    打印栈顶的成员data
        pNew = pNew->next;                  //    栈顶指针向下移动一次
    }
    return ;
}
 
//    判断栈是否为空
bool IsEmpty(PSTACK pS)
{
    if(pS->pTop == pS->pBottom)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
//    进行出栈操作函数
int PopStack(PSTACK pS)
{
    PNODE pSwap = NULL;
    int return_val;
    if (IsEmpty(pS))                //判断栈是否为空
    {
        cout << "栈为空." << endl;
    }
    else
    {
        return_val = pS->pTop->data;    //    把栈顶的成员data的值赋给return_val做为函数返回值
        pSwap = pS->pTop;                //    使pSwap指向栈顶
        pS->pTop = pS->pTop->next;        //    使栈顶指向栈顶下一个节点
        delete pSwap;                    //    释放以前的栈顶空间
        return return_val;
    }
}
 
//    清空栈的函数
void Clear(PSTACK pS)
{
    PNODE pNew = NULL;
 
    while (pS->pTop != pS->pBottom)        //    栈顶和栈底不等，循环
    {
        pNew = pS->pTop;                    //    使一个新节点和栈顶指向同一空间
        pS->pTop = pS->pTop->next;        //    使栈顶指向栈顶的下一个节点
        delete pNew;                        //    释放掉以前的栈顶空间
    }
    return ;
}