数据结构之栈

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈所涉及的方法有很多，其中比较经典的是入栈和出栈，还有对栈进行遍历

 下面给出我的代码块

 

头文件部分，用于定义一个栈类

//
//  Header.h
//  栈
//
//  Created by mouweng on 17/3/19.
//  Copyright © 2017年 栈. All rights reserved.
//

#ifndef Header_h
#define Header_h
#include<iostream>
using namespace std;
 class MyStack
{
public:
    MyStack(int size);//分配内存初始化栈空间，设定栈容量。
    ~MyStack();//回收栈空间
    bool StackEmpty();//判定栈是否为空，为空返回true，非空返回false
    bool StackFull();//判断栈是否满，为满返回true，不满返回false
    void ClearStack();//清空栈
    int StackLength();//已有元素个数
    void push(char elem);//元素入栈，栈顶上升
    char pop();//元素出栈，栈顶下降
    void StackTraverse();//遍历栈中所有元素
private:
    char *m_pBuffer;//栈空间指针
    int m_iSize;//栈容量
    int m_iTop;//栈顶，栈中元素的个数
};


#endif /* Header_h */

主函数部分：

//
//  main.cpp
//  栈
//
//  Created by mouweng on 17/3/19.
//  Copyright © 2017年 栈. All rights reserved.
//

#include <iostream>
#include "Header.h"
using namespace std;

MyStack::MyStack(int size)
{
    m_iSize=size;
    m_iTop=0;
    m_pBuffer=new char[size];
}
MyStack::~MyStack()
{
    delete []m_pBuffer;
}


 bool MyStack:: StackEmpty()
{
    if (m_iTop==0)//if(0==m_iTop)---当写成一个等号时，系统会自动报错
        return true;
    else
        return false;
}
bool  MyStack:: StackFull()
{
    if(m_iTop==m_iSize)//>=也是可以
        return true;
    else
        return false;
}

void MyStack::ClearStack()//剩下的值存不存在无所谓，下次赋值可以覆盖
{
    m_iTop=0;
}

int MyStack::StackLength()
{
    return m_iTop;
}

void MyStack::push(char elem)//将元素放在栈顶
{
    if(StackFull())
        cerr<<"the stack is full"<<endl;
    else
    {
        m_pBuffer[m_iTop]=elem;
        m_iTop++;
    }
}

char MyStack::pop()
{
    if(StackEmpty())
    {
        throw 1;
    }
    
    else
    {
        m_iTop--;
        return m_pBuffer[m_iTop];
    }
}

void MyStack::StackTraverse()
{
    for(int i=0;i<m_iTop;i++)
        cout<<m_pBuffer[i]<<" ";
    cout<<endl;
}

int main()
{
    MyStack *pStack = new MyStack(5);
    
    pStack->push('s');
    pStack->push('t');
    pStack->push('a');
    pStack->push('c');
    pStack->push('k');

    pStack->StackTraverse();
    
    
    char elem=pStack->pop();
    cout<<elem<<endl;
    
    pStack->ClearStack();
    
    
    cout<<pStack->StackLength()<<endl;
    
    if(pStack->StackEmpty())
    {
        cout<<"栈为空"<<endl;
    }
    if(pStack->StackFull())
    {
        cout<<"栈未满"<<endl;
    }
    
    
    
    delete pStack;
    pStack = NULL;
}

但，你知道的，上面的栈的实现方式在对栈进行构造时就需要给出栈的大小，虽然也已经是一种动态的栈，但在一定程度上影响了栈的灵活性，有没有一种方式让我们在想要加入的时候就申请一个空间，而删除元素的时候就释放掉这个空间呢？ 答案当然是有的，不过这需要联系上我们之前所讲的单链表的结构。这样我们就能使我们的栈变得更加灵活。

//
//  Header.h
//  栈
//
//  Created by mouweng on 17/3/19.
//  Copyright © 2017年 栈. All rights reserved.
//

#ifndef Header_h
#define Header_h
#include<iostream>
using namespace std;
class MyStack
{
public:
    MyStack();//分配内存初始化栈空间，设定栈容量。
    ~MyStack();//回收栈空间
    void ClearStack();//清空栈
    int StackLength();//已有元素个数
    void push(char elem);//元素入栈，栈顶上升
    char pop();//元素出栈，栈顶下降
    void StackTraverse();//遍历栈中所有元素
private:
    class Node
    {
    public:
        char data;
        Node *next;
        void PrintData()
        {
            cout<<data<<endl;
        }
    };
    Node *NodePointer;//栈空间指针
    int m_iTop;//栈顶，栈中元素的个数
};


#endif /* Header_h */

//
//  main.cpp
//  单链表
//
//  Created by mouweng on 17/3/18.
//  Copyright © 2017年 单链表. All rights reserved.
//

//
//  main.cpp
//  栈
//
//  Created by mouweng on 17/3/19.
//  Copyright © 2017年 栈. All rights reserved.
//

#include <iostream>
#include "List.h"
using namespace std;

MyStack::MyStack()
{
    m_iTop=0;
    NodePointer=new Node;
    NodePointer->data=0;
    NodePointer->next=NULL;
    
}
MyStack::~MyStack()
{
    //前面部分相当于
    m_iTop=0;
    Node *currentNode=NodePointer->next;
    while(currentNode!=NULL)
    {
        Node *temp=currentNode->next;
        delete currentNode;
        currentNode = temp;
    }
    
    
    delete NodePointer;
    NodePointer->next=NULL;
}




void MyStack::ClearStack()//剩下的值存不存在无所谓，下次赋值可以覆盖
{
    m_iTop=0;
    Node *currentNode=NodePointer->next;
    while(currentNode!=NULL)
    {
        Node *temp=currentNode->next;
        delete currentNode;
        currentNode = temp;
    }
    NodePointer->next=NULL;
}

int MyStack::StackLength()
{
    return m_iTop;
}

void MyStack::push(char elem)//将元素放在栈顶
{
    Node *temp=NodePointer;
    Node *currentNode=new Node;
    if(currentNode==NULL)//申请内存失败，返回0；
        return;
    currentNode->data=elem;
    for(int i=0;i<m_iTop;i++)
        temp=temp->next;
    currentNode->next=temp->next;
    temp->next=currentNode;
    m_iTop++;
}

char MyStack::pop()
{
    Node *temp=NodePointer;
    for(int i=0;i<m_iTop-1;i++)
    {
        temp=temp->next;
    }
    Node *aftertemp=temp->next;
    temp->next=aftertemp->next;
    int aftertempdata=aftertemp->data;
    delete aftertemp;
    m_iTop--;
    return aftertempdata;
    
}

void MyStack::StackTraverse()
{
    Node *temp=NodePointer;
    while(temp->next!=NULL)
    {
        temp=temp->next;
        temp->PrintData();
    }
}

int main()
{
    MyStack *pStack= new MyStack;
    pStack->push('s');
    pStack->push('t');
    pStack->push('a');
    pStack->push('c');
    pStack->push('k');
    pStack->StackTraverse();
    cout<<endl;
    
    pStack->pop();
    pStack->StackTraverse();
    cout<<endl;
    cout<<pStack->StackLength();
    cout<<endl;
    pStack->ClearStack();
    pStack->StackTraverse();
}