c++栈实现，分别使用顺序表 ，带/不带头节点的链表实现

#include<iostream>
using namespace std;
#define seq_maxlength 10

/*
*使用顺序表完成栈操作
*top数组下标指向下一个待填充下标
*get_min get_max在o(1)时间复杂度给出栈的最小最大值
*除了栈元素和栈顶下标还额外有两个栈储存最大最小值，push时需同步，pop不需要
*get_min get_max每次返回各自栈顶元素，栈顶指针与存储数据的top栈顶指针同步
* stack1()构造函数通过new分配动态内存，最大长度由宏定义seq_maxlength规定，对应析构函数~stack1()delete释放内存
* empty，与full通过栈顶下标top是否等于0和seq_maxlength判断栈是否为空或满
* pop弹出栈顶元素，先判断是否为空先top--再return，date[--top]即两步的整合，若为date[top--]则为先return再top--
* push入栈操作，先判断是否为满，再根据情况将元素压入date max 和min三个栈最后top++
*/
class stack1
{
public:
    stack1();
    bool empty();
    bool full();
    int pop();
    void push(int data);
    int get_top();
    int get_min();
    int get_max();
    ~stack1();
private:
    int top;
    int* date;
    int* max;
    int* min;
};

stack1::stack1()
{
    date = new int[seq_maxlength];
    max = new int[seq_maxlength];
    min= new int[seq_maxlength];
    top = 0;
}

bool stack1::empty()
{
    return top == 0;
}

bool stack1::full()
{
    return top == seq_maxlength ;
}

int stack1::pop()
{
    if (this->empty())
    {
        cout << "pop failed, stack empty" << endl;
        return -1;
    }
    return date[--top];
}

void stack1::push(int data)
{
    if (this->full())
    {
        cout << "push failed ,stack full" << endl;
        return ;
    }
    if (this->empty())
    {
        date[0] = data;
        max[0] = data;
        min[0] = data;
        top++;
    }
    else
    {
        date[top] = data;
        if (data > max[top - 1])
        {
            max[top] = data;
        }
        else
        {
            max[top] =max[top-1];
        }
        if (data < min[top - 1])
        {
            min[top] = data;
        }
        else
        {
            min[top] = min[top - 1];
        }
        top++;
    }
}

int stack1::get_top()
{
    if (!this->empty())
    {
        return date[top - 1];
    }
    else
    {
        cout << "get failed,stack empty" << endl;
        return -1;
    }
}

int stack1::get_max()
{
    if (!this->empty())
    {
        return max[top - 1];
    }
    else
    {
        cout << "get failed,stack empty" << endl;
        return -1;
    }
}

int stack1::get_min()
{
    if (!this->empty())
    {
        return min[top - 1];
    }
    else
    {
        cout << "get failed,stack empty" << endl;
        return -1;
    }
}

stack1::~stack1()
{
    delete date;
    delete max;
    delete min;
}

/*
*与stcak1一样通过顺序表完成栈操作
*stack2是双端共享栈
*类内声明静态数组无需特殊析构函数
*top下标指向栈顶元素下标，push采用date[++top],pop则是date[top--]
*两个公用栈push方向相反栈1沿数组下标增长顺序push
*判断是否为满则是看两个栈顶指针是否相邻
*/
class stack2
{
public:
    stack2();
    bool empty1();
    bool empty2();
    bool full();
    int pop1();
    int pop2();
    void push1(int data);
    void push2(int data);
    int get_top1();
    int get_top2();
private:
    int top1;
    int top2;
    int date[seq_maxlength];
};

stack2::stack2()
{
    top1 = -1;
    top2 = seq_maxlength;
}

bool stack2::empty1()
{
    return top1 == -1;
}

bool stack2::empty2()
{
    return top2 == seq_maxlength;
}

bool stack2::full()
{
    return top1 == (top2 - 1);
}

int stack2::pop1()
{
    if (!this->empty1())
    {
        return date[top1--];
    }
    else
    {
        cout << "pop failed ,stack1 empty" << endl;
        return -1;
    }
}

int stack2::pop2()
{
    if (!this->empty2())
    {
        return date[top2++];
    }
    else
    {
        cout << "pop failed ,stack2 empty" << endl;
        return -1;
    }
}
void stack2::push1(int data)
{
    if (!this->full())
    {
        date[++top1]=data;
    }
    else
    {
        cout << "push failed ,stacks full" << endl;
    }
}

void stack2::push2(int data)
{
    if (!this->full())
    {
        date[--top2] = data;
    }
    else
    {
        cout << "push failed ,stacks full" << endl;
    }
}

int stack2::get_top1()
{
    if (!this->empty1())
    {
        return date[top1];
    }
    else
    {
        cout << "get failed ,stack1 empty" << endl;
        return -1;
    }
}

int stack2::get_top2()
{
    if (!this->empty2())
    {
        return date[top2];
    }
    else
    {
        cout << "get failed ,stack2 empty" << endl;
        return -1;
    }
}

typedef struct Lnode
{
    int date;
    Lnode* next;
}Lnode, * Lklist;

/*
*使用链表完成栈操作
*不带头结点
*L指向栈顶节点
*pop与get_top使用bool返回值用于判断操作是否成功
* 使用new动态分配内存，需要析构函数逐步delete
*/
class stack3
{
public:
    stack3();
    bool empty();
    bool pop(int& data);
    void push(int data);
    bool get_top(int& data);
    ~stack3();
private:
    Lklist L;
};
stack3::stack3()
{
    L = NULL;
}

bool stack3::empty()
{
    return L == NULL;
}

bool stack3::pop(int& data)
{
    if (this->empty())
    {
        cout << "pop failed, stack empty" << endl;
        return false;
    }
    else
    {
        data = L->date;
        Lnode* p = L->next;
        delete L;
        L = p;
        return true;
    }
}

void stack3::push(int data)
{
    Lnode* pnew = new Lnode;
    pnew->date = data;
    pnew->next = L;
    L = pnew;
}

bool stack3::get_top(int& data)
{
    if (this->empty())
    {
        cout << "get failed, stack empty" << endl;
        return false;
    }
    else
    {
        data = L->date;
        return true;
    }
}

stack3::~stack3()
{
    while (L != NULL)
    {
        Lnode* p = L;
        L = L->next;
        delete p;
    }
}

class stack4
{
public:
    stack4();
    bool empty();
    bool pop(int& data);
    void push(int data);
    bool get_top(int& data);
    ~stack4();
private:
    Lklist L;
};

stack4::stack4()
{
    L = new Lnode;
    L->next = NULL;
}

bool stack4::empty()
{
    return L->next == NULL;
}

bool stack4::pop(int& data)
{
    if (this->empty())
    {
        cout << "pop failed, stack empty" << endl;
        return false;
    }
    else
    {
        Lnode* p = L->next;
        data = p->date;
        L->next = p->next;
        delete p;
        return true;
    }
}

void stack4::push(int data)
{
    Lnode* pnew = new Lnode;
    pnew->date = data;
    pnew->next = L->next;
    L->next = pnew;
}

bool stack4::get_top(int& data)
{
    if (this->empty())
    {
        cout << "get failed, stack empty" << endl;
        return false;
    }
    else
    {
        data = L->next->date;
        return true;
    }
}

stack4::~stack4()
{
    while (L->next != NULL)
    {
        Lnode* p = L->next;
        L->next = p->next;
        delete p;
    }
    delete L;
}