1.将顺序栈定义成模板类；​​​​​​

顺序栈模板代码--- 

#include <iostream>

using namespace std;

template<typename T>
class Stack
{
private:
    T *data;  //指向堆区空间
    int top;  //记录栈顶位置

public:
    Stack();  //无参构造
    Stack(T size);  //有参构造
    ~Stack();  //析构函数
    bool Empty();  //判空
    bool Full(T size);  //判满
    T get_elemsize();  //返回容纳的元素数
    void Push(T size,T elem);  //入栈
    void Pop();  //出栈
    void Output();  //遍历栈内元素
    T get_top();  //访问栈顶元素

    //重载=运算符（一个Stack对象赋值给另一个Stack对象）
    Stack<T> &operator =(const Stack<T> &R)
    {
        if(this == &R)
            return *this;

        delete [] data;
        data = new T[R.top+1];

        for(int i=0; i<=R.top; i++)
            data[i] = R.data[i];
        top = R.top;

        return *this;
    }

};

//无参构造
template<typename T>
Stack<T>::Stack():data(new T[10]),top(-1) {}

//有参构造
template<typename T>
Stack<T>::Stack(T size):data(new T[size]),top(-1) {}

//析构函数
template<typename T>
Stack<T>::~Stack() {delete [] data;}

//判空
template<typename T>
bool Stack<T>:: Empty()
{
    return top==-1;
}

//判满
template<typename T>
bool Stack<T>:: Full(T size)
{
    return top==size-1;
}

//返回容纳的元素数
template<typename T>
T Stack<T>::get_elemsize()
{
    return top+1;
}

//入栈
template<typename T>
void Stack<T>::Push(T size,T elem)
{
    if(Full(size) == true)
        return;
    data[++top] = elem;
}

//出栈
template<typename T>
void Stack<T>::Pop()
{
    if(Empty() == true)
        return;
    top--;
}

//遍历栈内元素
template<typename T>
void Stack<T>::Output()
{
    if(Empty() == true)
        return;
    for(int i=0; i<=top; i++)
    {
        cout<<data[i]<<" ";
    }
    cout<<endl;
}

//访问栈顶元素
template<typename T>
T Stack<T>::get_top()
{
    if(Empty() == true)
        return 0;
    return data[top];
}


int main()
{
    int size;
    cout<<"输入栈的大小>>> ";
    cin>>size;

    Stack<int> s1(size);  //有参构造

    char ch;
    int elem;
    do         //入栈
    {
        cout<<"输入入栈元素>>> ";
        cin>>elem;
        s1.Push(size,elem);

        if(s1.Full(size) == true)
        {
            cout<<"栈满，退出入栈"<<endl;
            break;
        }

        cout<<"继续入栈？ y/Y ";
        cin>>ch;
    }while(ch == 'y' || ch =='Y');

    s1.Output();  //遍历

    s1.Pop();  //弹出栈顶元素
    cout<<"弹出栈顶元素后>>> ";
    s1.Output();  //遍历

    cout<<"容纳的元素数>>> "<<s1.get_elemsize()<<endl<<endl;

    cout<<"获取栈顶元素>>> "<<s1.get_top()<<endl;
    cout<<endl;

    Stack<int> s2;
    s2 = s1;       //重载=
    cout<<"赋值后s2>>> ";
    s2.Output();  //遍历s2

    return 0;
}

 

2.将循环顺序队列定义成模板类；

循环顺序队列模板代码---

#include <iostream>

using namespace std;

#define MAXSIZE 6

template<typename T>
class Queue
{
private:
    T *data;  //指向堆区空间
    int front;  //记录队头
    int rear;  //记录队尾

public:
    Queue();  //无参构造
    Queue(T size);  //有参构造
    ~Queue();  //析构函数
    bool Empty();  //判空
    bool Full(T size);  //判满
    T get_elemsize(T size);  //返回容纳的元素数
    void Push(T size,T elem);  //入队
    void Pop(T size);
    void Output(T size);  //遍历队内元素
    T get_firstelem();  //访问第一个元素
    T get_endelem();  //访问最后一个元素

    //重载=运算符（一个Queue对象赋值给另一个Queue对象）
    Queue<T> &operator =(const Queue<T> &R)
    {
        if(this == &R)
            return *this;

        delete [] data;
        data = new T[MAXSIZE];

        for(int i=front; i != R.rear; i=(i+1)%MAXSIZE)
            data[i] = R.data[i];
        front = R.front;
        rear = R.rear;

        return *this;
    }

};

template<typename T>
Queue<T>::Queue():data(new T[MAXSIZE]),front(0),rear(0) {}  //无参构造

template<typename T>
Queue<T>::Queue(T size):data(new T[size]),front(0),rear(0) {}  //有参构造

template<typename T>
Queue<T>::~Queue() {delete [] data;}  //析构函数

template<typename T>
bool Queue<T>::Empty()  //判空
{
    return front==rear;
}

template<typename T>
bool Queue<T>::Full(T size)  //判满
{
    return front == (rear+1)%size;
}

template<typename T>
T Queue<T>::get_elemsize(T size)  //返回容纳的元素数
{
    return (size-front+rear)%size;
}

template<typename T>
void Queue<T>::Push(T size,T elem)  //入队
{
    if(Full(size) == true)
        return;
    data[rear] =  elem;
    rear = (rear+1)%size;
}

template<typename T>
void Queue<T>::Pop(T size)          //出队
{
    if(Empty() == true)
        return;
    front = (front+1)%size;
}

template<typename T>
void Queue<T>::Output(T size)   //遍历队内元素
{
    if(Empty() == true)
        return;
    for(int i=front; i != rear; i=(i+1)%size)
    {
        cout<<data[i]<<" ";
    }
    cout<<endl;
}

//访问第一个元素
template<typename T>
T Queue<T>::get_firstelem()
{
    return data[front];
}

//访问最后一个元素
template<typename T>
T Queue<T>::get_endelem()
{
    return data[rear-1];
}

int main()
{

    int size;
    cout<<"输入队列的大小>>> ";
    cin>>size;

    Queue<int> s1(size);  //有参构造

    char ch;
    int elem;
    do         //入队
    {
        cout<<"输入入队元素>>> ";
        cin>>elem;
        s1.Push(size,elem);

        if(s1.Full(size) == true)
        {
            cout<<"队满，退出入队"<<endl;
            break;
        }

        cout<<"继续入队？ y/Y ";
        cin>>ch;
    }while(ch == 'y' || ch =='Y');

    s1.Output(size);  //遍历

    s1.Pop(size);  //弹出队尾元素
    cout<<"弹出一个队尾元素后>>> ";
    s1.Output(size);  //遍历

    cout<<"容纳的元素数>>> "<<s1.get_elemsize(size)<<endl<<endl;
    cout<<"获取第一个元素>>> "<<s1.get_firstelem()<<endl;
    cout<<"获取最后一个元素>>> "<<s1.get_endelem()<<endl;
    cout<<endl;

    Queue<int> s2;
    s2 = s1;       //重载=
    cout<<"赋值后s2>>> ";
    s2.Output(size);  //遍历s2


    return 0;
}

 

3.今日c++知识脑图；