数据结构和算法学习总结04 线性表---栈

栈

栈（Stack）是特殊的线性表，是只允许在一端进行插入和删除的线性表。

允许插入和删除的叫栈顶，反之则是栈底。

栈的插入称为进栈，删除称为出栈。

特性是：后进先出，所以栈也叫后进先出表，简称LIFO表(Last In First Out)。

因为栈是线性表，所以也有顺序表和链表两种形式，一般我们常用顺序栈。

从代码中可以看出：与顺序表相比实际上就是插入和删除操作发生了改变。

 

#include <iostream>  
using namespace std;  

const int Stack_Size = 5;  

class SqStack  
{  
private:
    int *elem;  
    int top;  
    int stackSize;
public:
    void InitSqStack();        //顺序栈的初始化
    int GetTop();              //获得栈顶元素
    int Length();              //获得当前栈的容量
    void DestroySqStack();     //销毁顺序栈
    void ClearSqStack();       //清空顺序栈
    void Push(int v);          //压栈/入栈/进栈
    int Pop();                 //出栈
    void InputSqStack(int n);  //输入元素
    void OutputSqStack();      //遍历输出
};  



void SqStack::InitSqStack()  
{  
    elem=new int[Stack_Size];  
    top=-1;  
    stackSize=Stack_Size; 
}  

int SqStack::GetTop()
{
    if(top==-1)
        cout<<"空栈"<<endl;
    int e = elem[top];
    return e;
}
int SqStack::Length()
{
    if(top==-1)
        cout<<"空栈"<<endl;
    return top+1;
}  

void SqStack::DestroySqStack()  
{  
    delete[] elem;  
    top=-1;  
    stackSize=0;  
}  

void SqStack::ClearSqStack()
{
    top=-1;
}

void SqStack::Push(int v)  
{  
    if(top==stackSize-1) 
    {
        int *newStack;
        newStack = new int[stackSize + 1];
        for(int i=0;i<=top;i++)
        {
            newStack[i]=elem[i];
        }
        delete[] elem;
        elem = newStack;
        stackSize++;
    }
    elem[++top]=v;  
}  

int SqStack::Pop()  
{  
    int v;  
    if(top==-1)  
        cout<<"空栈"<<endl;  
    v=elem[top--];  
    return v;  
}  

void SqStack::InputSqStack(int n)
{
    int a; 
    cout<<"enter numbers:"<<endl; 
    for (int i = 0; i < n; i++) 
    { 
        cin>>a;
        Push(a);
    } 
}

void SqStack::OutputSqStack()
{ 
    if ((elem == NULL)||(top==-1))
        cout<<"出现错误"<<endl; 
    else 
    { 
        for (int i = 0; i <= top; i++) 
        { 
            cout<<elem[top-i]<<" "; 
        } 
        cout<<endl;
    } 
}

void main()  
{  
    SqStack S;  
    S.InitSqStack();  
    S.InputSqStack(6);
    S.OutputSqStack();
    cout<<S.GetTop()<<endl;  
    S.Pop(); 
    S.OutputSqStack();
}  

 

 

 

链栈的情况(简单实现，主要代码)，使用链表的头插法

struct Node
{
    int data;
    Node *next;
};

class Stack  
{  
private:
    Node *top;
public:
    Stack(){ 
        top = new Node;
        top->next = NULL;
    }
    void Push(int v);  
    int Pop();        
    void InputStack(int n);  
    void OutputStack();   
};  

void Stack::Push(int v)  
{  
    Node *p;
    p=new Node;
    p->data=v;
    p->next=top;             //用的是头插法，top始终是栈顶
    top =p;
}  

int Stack::Pop()  
{  
    Node *p;
    int x;
    p=top;
    top=p->next;             //删除节点，用x记录要删除的元素。
    x=p->data;
    delete p;
    return x;
}  

void Stack::InputStack(int n)
{
    int a; 
    cout<<"enter numbers:"<<endl; 
    for (int i = 0; i < n; i++) 
    { 
        cin>>a;
        Push(a);
    } 
}

void Stack::OutputStack()
{ 
   Node *p;
   p= top;
   while(p->next!=NULL)
   {
       cout<<p->data<<" ";
       p = p->next;
   }
   cout<<endl;
}

void main()  
{  
    Stack S;    
    S.InputStack(5);
    S.OutputStack();
    cout<<S.Pop()<<endl;  
    S.OutputStack();
} 

在这里的top不是头指针，直接就是头结点。