栈的实现 c++

栈是典型的LIFO(Last In First Out)结构;

对一个栈来说，入栈的时候只能把新的元素添加到栈顶， 出栈的时候只能从栈顶弹出；好比装羽毛球的桶，装羽毛球的时候，只能从最上面把羽毛球装入，取球的时候只能从最上面取出

这里用链表形式来实现栈的结构，栈的每个储存单元由一个类node来实现, 为了便于阅读，不用类模板，用int型

class node{
public:
   int val;
   node *next;
   node(int x=0){val = x; next = NULL;}  
};

一个结点包括该结点的值和指向下一个结点的指针

一个栈的常见操作有：出栈，压栈，删除结点，获取栈顶，获取栈的大小, 为了方便检验栈的实验的正确性，还有一个遍历程序；

栈的一个简单结构如下，这个实现肯定存在一定的缺陷，请大家指正

class stack{
public:
    stack(){}
    int GetSize(){return size;}
    int GetTop(){if(top==NULL) return -999999; else return top->val;} 6     bool deleteNode(node* n);
    bool isEmpty(){return size == 0;}
    void pop();
    void push();
    void clear();
    void traverse();
private:
    node* top;
    int size;
    node* GetPre(node* n);
};

分别来实现栈最常用的两个功能：压栈：push， 出栈：pop

node* stack::push(int val){
    size++;   //每次压栈，栈的大小增加1
    if(top == NULL){ //栈为空栈的时候，建立新的结点并让栈顶top指向该结点
        top = new node(val);
        return top;
    }//更新栈顶
    node* temp = new node(val);
    temp->next = top;
    top = temp;
    return top;
}

void stack::pop(){
    if(top == NULL) return;
    node* temp = top; //让栈顶指向栈顶的下一个结点，并把原来的栈顶置空，就实现栈顶的弹出
    top = top->next;
    temp = NULL;
    size--;//每弹出一次，栈的大小减小1
}

删除结点是栈里面相对复杂的一种操作，要考虑删除结点的位置，以及要删除的结点是否存在

bool stack::deleteNode(node* n){
    node* temp = top;
    bool flag = false;
    while(temp){
        if(temp == n){
            size--;
            flag = true; //标志要删除的结点是否在栈中
            if(temp == top) {
                top = top->next;
                break;
            }
            else{//找到要删除结点的前驱，并使其指向要删除结点的后驱，这里存在一个缺陷就是没有在内存中删除掉这个结点，只实现了在栈中删除这个结点，但是依然占用内存
                node* pre = GetPre(temp);
                pre->next = temp->next;
                break;
            }
        }
        temp = temp->next;
    }21     return flag;
}

整个程序的实现：

#include<iostream>
using namespace std;
class node{
public:
    int val;
    node* next;
    node(int x=0){val = x; next = NULL;}
};

class stack{
public:
    void pop();
    node* push(int val);
    void traverse();
    void clear();
    bool deleteNode(node* n);
    stack(){size = 0; top = NULL;}
    node* GetTop(){return top;}
    int GetSize(){return size;}
    bool isEmpty(){return size == 0;}
private:
    node* top;
    int size;
    node* GetPre(node* n);
};

void stack::pop(){
    if(top == NULL) return;
    node* temp = top;
    top = top->next;
    temp = NULL;
    size--;
}

node* stack::push(int val){
    size++;
    if(top == NULL){
        top = new node(val);
        return top;
    }
    node* temp = new node(val);
    temp->next = top;
    top = temp;
    return top;
}

void stack::traverse(){
    if(top == NULL) {
        cout<<"stack is empty!"<<endl;
        return;
    }
    node* temp = top;
    cout<<"the size of this stack is: "<<size<<endl<<"stack is as follows: ";
    while(temp){
        cout<<temp->val<<" ";
        temp = temp->next;
    }
    cout<<endl;
}

void stack::clear(){
    node* temp;
    size = 0;
    while(top){
        temp = top;
        top = top->next;
        temp = NULL;
    }
}

node* stack::GetPre(node* n){
    if(n == NULL) {
        cout<<"this node has is NULL!"<<endl;
        return NULL;
    }
    if(n == top){
        cout<<"this node has no pre node!"<<endl;
        return NULL;
    }
    node* temp = top;
    while(temp->next){
        if(temp->next == n) 
            return temp;
    }
    cout<<"this node does not exist in the stack!"<<endl;
    return NULL;
}



bool stack::deleteNode(node* n){
    node* temp = top;
    bool flag = false;
    while(temp){
        if(temp == n){
            size--;
            flag = true;
            if(temp == top) {
                top = top->next;
                break;
            }
            else{
                node* pre = GetPre(temp);
                pre->next = temp->next;
                break;
            }
        }
        temp = temp->next;
    }
    if(!flag) cout<<"this node does not exist!"<<endl;
    return flag;
}

int main(){
    stack s;
    cout<<"检测压栈功能"<<endl;
    cout<<"压入1，2，3"<<endl;
    s.push(1);
    s.push(2);
    s.push(3);
    s.traverse();
    cout<<"检测出栈功能"<<endl;
    s.pop();
    s.traverse();
    cout<<"清除这个栈"<<endl;
    s.clear();
    s.traverse();
    cout<<"压入1，2，3，4，5"<<endl;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    s.push(5);
    s.traverse();
    cout<<"删除第二个结点"<<endl;
    s.deleteNode(s.GetTop()->next);
    s.traverse();
return 0;}

 检验是否正确，检测不是很严谨，只实现了基本的功能