C++ 栈

数组实现

#include <iostream>
using namespace std;

template<class T>
class ArrayStack
{
public:
    // 默认构造
    ArrayStack();
    // 析构函数
    ~ArrayStack();
    
    void push(T t); // 向栈中添加一个t元素
    T peek(); // 向栈中取一个元素
    T pop(); // 在栈中删除一个元素
    int size(); // 大小
    int isEmpty(); // 判断是否为空
    
private:
    T *arr; // 数组
    int count;
};

// 创建栈
template<class T>
ArrayStack<T>::ArrayStack() : count(0)
{
    arr = new T[12];
    if (!arr)
    {
        cout << "arr malloc error!" << endl;    
    }
}

// 销毁栈
template<class T>
ArrayStack<T>::~ArrayStack()
{
    if (arr)
    {
        delete[] arr;
        arr = NULL;
    }
}

// 将val添加到栈中
// 向栈中添加一个元素
template<class T>
void ArrayStack<T>::push(T t)
{
    arr[count++] = t;    
}

// 返回栈顶元素值
template<class T>
T ArrayStack<T>::peek()
{
    return arr[count - 1];    
}

// 返回栈顶元素值，并删除栈顶元素
template<class T>
T ArrayStack<T>::pop()
{
    T ret = arr[count - 1];
    count--;
    return ret;
}

// 返回栈的大小
template<class T>
int ArrayStack<T>::size()
{
    return count;    
}

// 返回栈是否为空
template<class T>
int ArrayStack<T>::isEmpty()
{
    return count == 0;    
}

int main()
{
    
    int tmp = 0;
    
    ArrayStack<int>* astack = new ArrayStack<int>();
    
    cout << "main" << endl;
    
    astack->push(10);
    astack->push(20);
    astack->push(30);
    
    // 将栈顶元素赋值给tmp，并删除栈顶元素
    tmp = astack->pop();
    
    cout << "tmp = " << tmp << endl;
    
    // 直将栈顶赋值给tmp，不删除元素
    tmp = astack->peek();
    astack->push(40);
    while (!astack->isEmpty())
    {
        tmp = astack->pop();
        cout << tmp << endl;
    }

    return 0;    
}

链表实现

#include <iostream>
using namespace std;

template<class T>
struct Node
{
public:
    Node() { } // 默认构造
    Node(T t, Node* next); // 有参构造
public:
    T data; // 数据域
    Node* next; // 指针域
};

template<class T>
Node<T>::Node(const T t, Node* next)
{
    this->data = t;
    this->next = next;
}

template<class T>
class LinkStack
{
public:
    LinkStack(); // 默认构造
    ~LinkStack(); // 析构函数
    

    
    // 入栈
    void push(T t);
    // 获取栈顶元素
    T peek();
    // 获取栈顶元素，并删除
    T pop();
    // 返回栈顶元素数量
    int size();
    // 判断栈是否为空
    int isEmpty();
private:
    Node<T>* top; // 头节点
    int count; // 计数
};

// 默认构造  创建栈
template<class T>
LinkStack<T>::LinkStack() : count(0)
{
    top = new Node<T>();
    top->next = NULL;
}

// 析构函数  销毁栈
template<class T>
LinkStack<T>::~LinkStack()
{
    Node<T>* tmp;
    Node<T>* pnode = top->next;
    if (pnode != NULL)
    {
        while (pnode != NULL)
        {
            tmp = pnode;
            pnode = pnode->next;
            delete tmp;
        }
    }
    delete top;
    top = NULL;
}



// 入栈
template<class T>
void LinkStack<T>::push(T t)
{
    // 创建新节点
    Node<T>* pnode = new Node<T>(t, top->next);
    // 设置新节点为栈顶
    top->next = pnode;
    // 数量+1
    count++;
}

// 获取栈顶元素
template<class T>
T LinkStack<T>::peek()
{
     // 获取栈顶元素
    Node<T>* tmp = top->next;
    // 判断是否为空
    if (tmp == NULL)
    {
        cerr<<"Error, stack is empty!";
    }
    // 栈顶不为空，返回栈顶元素
    return tmp->data;   

}

// 获取栈顶元素，并删除
template<class T>
T LinkStack<T>::pop()
{
    // 获取栈顶元素
    Node<T>* tmp = top->next;
    // 判断是否为空
    if (tmp == NULL)
    {
        cerr<<"Error, stack is empty!";
    }
    // 不为空，删除栈顶元素
    top->next = tmp->next;
    // 返回栈顶元素
    return tmp->data; 
}

// 返回栈的元素数量
template<class T>
int LinkStack<T>::size()
{
    return count;
}

// 判断栈是否为空
template<class T>
int LinkStack<T>::isEmpty()
{
    return count == 0;
}

// 测试内置数据类型

void int_test()
{
    LinkStack<int>* linkstack = new LinkStack<int>();   
    
    cout << "当前栈为：" << (linkstack->isEmpty() == 1 ? "空" : "不空") << endl;
    
    // 入栈
    linkstack->push(10);
    linkstack->push(20);
    linkstack->push(30);
    linkstack->push(40);
    
    // 获取栈顶元素  将其赋值给tmp
    int tmp = linkstack->peek();
    cout << "当前栈顶元素为：" << tmp << endl;
    
    // 获取栈顶元素，并删除
    tmp = linkstack->pop();
    cout << "被删除的栈顶元素：" << tmp << endl;
    
    // 打印栈
    for (int i = 0; i < linkstack->size() - 1; ++i)
    {
        tmp = linkstack->pop();
        cout << tmp << endl;
    }
    
    cout << "当前栈为：" << (linkstack->isEmpty() == 1 ? "空" : "不空") << endl; 
}



class Person
{
public:
    Person() { }
    Person(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
public:
    string name;
    int age;
};

// 测试自定义数据类型
void person_test()
{
    Person p1("张三", 19);
    Person p2("李四", 20);    
    Person p3("王五", 21);    
    Person p4("赵六", 22);    
    Person p5("七七", 10);  
    
    LinkStack<Person>* ls = new LinkStack<Person>();
    
    // 入栈
    ls->push(p1);
    ls->push(p2);
    ls->push(p3);
    ls->push(p4);
    ls->push(p5);
    
    // 获取栈顶元素
    Person p = ls->peek();
    cout << "姓名：" << p.name << " 年龄：" << p.age << endl;
    
    // 获取栈顶元素，并删除
    p = ls->pop();
    cout << "姓名：" << p.name << " 年龄：" << p.age << endl;
    
    cout << "--------------------" << endl;
    
    // 打印栈
    for (int i = 0; i < ls->size() - 1; ++i)
    {
        p = ls->pop();
        cout << "姓名：" << p.name << " 年龄：" << p.age << endl;
    }
    
    
}

int main()
{
    
    int_test();
    
    cout << "------------------------------" << endl;
    
    person_test();
    
    return 0;    
}