栈--顺序表实现

栈-先进后出

先进后出(输入1234 ，输出4321）

#include <iostream>
#include <stack>//栈的头文件
using namespace std;
/*
4个接口
empty() 判断是否为空
push(v) 入栈接口
pop()   出栈接口
top()   获取栈顶元素接口
*/
int main() {
    stack<int> intStk;
    stack<double> doubleStk;
    intStk.push(1);
    intStk.push(2);
    intStk.push(3);
    intStk.push(4);
    while(!intStk.empty()){
        cout << intStk.top() << ' ';
        intStk.pop();
    }
    cout << endl;
    doubleStk.push(1.1);
    doubleStk.push(2.2);
    doubleStk.push(3.3);
    doubleStk.push(4.4);
    while(!doubleStk.empty()){
        cout << doubleStk.top() << ' ';
        doubleStk.pop();
    }
    return 0;
}

全部代码

#include <iostream>
#include <stdexcept>
using namespace std;
template<typename T>
//栈的顺序表实现
class Stack{
private:
    T *data;
    int size;
    int capacity;
    void resize(); //扩容函数
public:
    Stack():data(new T(capacity)),size(0),capacity(10){} //构造函数
    //Stack():data(new T(10),size(0),capacity(10)){}
    ~Stack();
    void push(T element);//进栈
    T pop();//出栈
    T top() const;//获取元素
    int getSize() const;//获取栈的大小
};

template<typename T>
void Stack<T>::resize(){//顺序表扩容
    int newCapacity = capacity*2;
    T *newData = new T[newCapacity];
    for (int i = 0; i < size; i++) {
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity = newCapacity;
}
//顺序表的析构函数
template<typename T>
Stack<T>::~Stack(){
    delete[] data;
}
//入栈函数
template<typename T>
void Stack<T>::push(T element){
    if(size == capacity){
        resize();
    }
    data[size++] = element;
}
//出栈函数
template<typename T>
T Stack<T>::pop(){
    if(size == 0){
        throw std::underflow_error("Stack is empty");
    }
    return data[--size];
}
//获取栈顶元素
template<typename T>
T Stack<T>::top() const{
    if(size == 0){
        throw std::underflow_error("Stack is empty");
    }
    return data[size-1];
}

//获取栈的大小
template<typename T>
int Stack<T>::getSize() const{
    return size;
}

int main(){
    Stack<int> st;
    st.push(4);
    st.push(7);
    st.push(13);
    cout << st.top() <<endl;
    st.push(17);
    cout << st.top() <<endl;
    st.pop();
    st.pop();
    cout << st.top() <<endl;
    cout << st.getSize() << endl;
    return 0;
}

结构体

//栈的顺序表实现
class Stack{
private:
    T *data;
    int size;
    int capacity;
    void resize(); //扩容函数
public:
    Stack():data(new T(capacity)),size(0),capacity(10){} //构造函数
    //Stack():data(new T(10),size(0),capacity(10)){}
    ~Stack();
    void push(T element);//进栈
    T pop();//出栈
    T top() const;//获取元素
    int getSize() const;//获取栈的大小
};

栈扩容函数

template<typename T>
void Stack<T>::resize(){//顺序表扩容
    int newCapacity = capacity*2;
    T *newData = new T[newCapacity];
    for (int i = 0; i < size; i++) {
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity = newCapacity;
}

栈析构函数

template<typename T>
Stack<T>::~Stack(){
    delete[] data;
}

入栈函数 （增）

template<typename T>
void Stack<T>::push(T element){
    if(size == capacity){
        resize();
    }
    data[size++] = element;
}

出栈函数 （删）

template<typename T>
T Stack<T>::pop(){
    if(size == 0){
        throw std::underflow_error("Stack is empty");
    }
    return data[--size];
}

查询栈顶数据 （查）

template<typename T>
T Stack<T>::top() const{
    if(size == 0){
        throw std::underflow_error("Stack is empty");
    }
    return data[size-1];
}

获取栈的实际长度

template<typename T>
int Stack<T>::getSize() const{
    return size;
}

测试main函数

int main(){
    Stack<int> st;
    st.push(4);
    st.push(7);
    st.push(13);
    cout << st.top() <<endl;
    st.push(17);
    cout << st.top() <<endl;
    st.pop();
    st.pop();
    cout << st.top() <<endl;
    cout << st.getSize() << endl;
    return 0;
}