Cpp/Qtday060913cpp基础

最新推荐文章于 2024-07-25 10:56:50 发布

zyy11hqyj23062

最新推荐文章于 2024-07-25 10:56:50 发布

阅读量400

点赞数

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/sy311sb/article/details/132864071

版权

将栈类实现成模板类

代码

#include <iostream>

using namespace std;

template<typename T>
class Stack
{
private:
    T data[128];
    int top;
public:
    Stack();
    //Stack(T unit);
    ~Stack();
    Stack(Stack &s);
    //判空
    bool stack_empty();
    //返回布尔类型，真为空，假为非空
    //判满
    bool stack_full();
    //返回布尔类型，真为满，假为非满
    //入栈
    int stack_in(T unit);
    //出栈
    T stack_out();
    //清空栈
    bool stack_clear();
    //获取栈顶元素
    T stack_get_top();
    //求栈的大小
    int stack_size();
    //为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
    void stack_show();
};
template<typename T>
Stack<T>::Stack():top(-1){
    cout<<"Stack:无参构造"<<endl;
}
//template<typename T>
//Stack<T>::Stack(T unit):data(unit),top(0){
//    cout<<"Stack:无参构造"<<endl;
//}
template<typename T>
Stack<T>::~Stack(){
    cout<<"Stack:析构函数"<<endl;
}
template<typename T>
Stack<T>::Stack(Stack &s):top(s.top){
    for(int i=0; i<=top; i++){
        data[i] = s.data[i];
    }
    cout<<"Stack:拷贝构造函数"<<endl;
}
//判空
template<typename T>
bool Stack<T>::stack_empty(){
    //top正好记录栈顶元素的下标，所以当top为-1时，栈空
    return -1 == top;
}
//判满
template<typename T>
bool Stack<T>::stack_full(){
    //top正好记录栈顶元素的下标，所以当top为127时，栈满
    return 127 == top;
}
//入栈
template<typename T>
int Stack<T>::stack_in(T unit){
    //如果栈满，则拒绝入栈
    if(Stack::stack_full()){
        cout<<"栈已满"<<endl;
        return -1;
    }
    //将栈顶变量的值+1，就能指向新的栈顶
    top++;
    //将要入栈的数据放入数组中
    data[top] = unit;
    return 0;
}
//出栈
template<typename T>
T Stack<T>::stack_out(){
    //判断栈是否为空，为空则无法出栈
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return -1;
    }
    //按照我的定义，top正好记录了栈顶元素的下标,因此top--，会将top自减，并且top--这个表达式
    //的值为top，所以可以输出data[top]也就是栈顶元素的值，同时top自减一次，而要出栈，出的
    //就是栈顶元素
    return data[top--];
}
//清空栈
template<typename T>
bool Stack<T>::stack_clear(){
    //如果栈本身为空则无需清空
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return false;
    }
    //如果栈非空则需要清空

    //将栈顶指针置为-1即可
    top = -1;
    return true;
}
//获取栈顶元素
template<typename T>
T Stack<T>::stack_get_top(){
    //首先栈要非空
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return -1;
    }
    //原理与出栈相同，唯一的区别就是无需将栈顶变量移动
    return data[top];
}
//求栈的大小
template<typename T>
int Stack<T>::stack_size(){
    //已知，top变量记录了栈顶元素的下标，所以要求栈中的元素数量，只需将top+1就可得到
    return top+1;
}
//为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
template<typename T>
void Stack<T>::stack_show(){
    //首先栈要非空
    if(Stack::stack_empty()){
        cout<<"栈为空"<<endl;
        return ;
    }
    for(int i=top; i>-1; i--){
        cout << data[i] << "  ";
    }
    cout<<endl;
}
int main()
{
    Stack<int> s1;
    //入栈
    s1.stack_in(4);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(3);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(9);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(6);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(1);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(5);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(5);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(7);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    //出栈
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    //获取栈的大小
    cout<<"此时栈内元素的数量为:"<<s1.stack_size()<<endl;
    //栈顶元素为
    cout<<"栈顶元素为:"<<s1.stack_get_top()<<endl;
    //清空栈
    s1.stack_clear();
    cout<<"栈清空成功"<<endl;

    Stack<char> s2;
    //入栈
    s2.stack_in('H');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('e');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('l');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('l');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('o');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in(' ');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('w');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('o');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    //出栈
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    //获取栈的大小
    cout<<"此时栈内元素的数量为:"<<s2.stack_size()<<endl;
    //栈顶元素为
    cout<<"栈顶元素为:"<<s2.stack_get_top()<<endl;
    //清空栈
    s2.stack_clear();
    cout<<"栈清空成功"<<endl;
    return 0;
}

效果

由于终端不方便一次性全部展示，因此，s1,s2的完整现象需要分两次展示

将队列类实现成模板类

代码

#include <iostream>

using namespace std;

template<typename T>
class Queue
{
private:
    T data[12];
    int head;
    int tail;

public:
    //构造函数
    Queue();
    //析构函数
    ~Queue();
    //拷贝构造函数
    Queue(Queue &q);
    //判空
    bool queue_empty();
    //判满
    bool queue_full();
    //入队
    int queue_in(T unit);
    //出队
    T queue_out();
    //清空队列
    bool queue_clear();
    //求队列大小
    int queue_size();
    //为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
    void queue_show();
};

//构造函数
template<typename T>
Queue<T>::Queue():head(0),tail(0){
    cout<<"Queue:构造函数"<<endl;
}

//析构函数
template<typename T>
Queue<T>::~Queue(){
    cout<<"Queue:析构函数"<<endl;
}

//拷贝构造函数
template<typename T>
Queue<T>::Queue(Queue &q):head(q.head),tail(q.tail){
    int h = head;
    while(h!=tail){
        data[h] = q.data[h];
        h = (h+1)%12;
    }
    cout<<"Queue:拷贝构造函数"<<endl;
}

//判空
template<typename T>
bool Queue<T>::queue_empty(){
    //当队列的头变量与尾变量的值相同时，队列为空
    return head == tail;
}

//判满
template<typename T>
bool Queue<T>::queue_full(){
    //队尾变量记录的下标中是不保存变量的，以便操作与计数
    //因此，当队尾变量的值比对头变量的值小1或者-11的时候，队满
    return (tail+1)%12 == head;
}

//入队
template<typename T>
int Queue<T>::queue_in(T unit){
    //要能入队，首先队列不能为满
    if(Queue::queue_full()){
        cout<<"队列已满，无法入队"<<endl;
        return -1;
    }

    //此时可以入队
    data[tail] = unit;

    //队尾变量自增一次
    tail = (tail + 1)%12;

    return 0;
}

//出队
template<typename T>
T Queue<T>::queue_out(){
    //要能出队，首先队列不能为空
    if(Queue::queue_empty()){
        cout<<"队列已空，无法入队"<<endl;
        return -1;
    }
    //此时可以出队
    int tmp = data[head];
    //对头变量自增一次
    head = (head + 1)%12;

    return tmp;
}

//清空队列
template<typename T>
bool Queue<T>::queue_clear(){
    //若队列为空则无需清空
    if(Queue::queue_empty()){
        cout<<"队列已空，无需清空"<<endl;
        return false;
    }
    //操作队头队尾变量，使满足队列为空的条件
    head = tail;

    return true;
}

//求队列大小
template<typename T>
int Queue<T>::queue_size(){
    //根据队首队尾的位置即可求出队列大小
    return (tail + 12 - head)%12;
}

//为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
template<typename T>
void Queue<T>::queue_show(){
    //若队列为空则提示队列为空
    if(Queue::queue_empty()){
        cout<<"队列为空"<<endl;
        return;
    }
    int h = head;
    while(h!=tail){
        cout<<data[h]<<"  ";
        h = (h+1)%12;
    }
    cout<<endl;
    return;
}

int main()
{
    Queue<int> q1;
    //入队
    q1.queue_in(4);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(3);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(9);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(6);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(1);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(5);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(5);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(7);
    //展示
    cout<<"q1: ";
    q1.queue_show();

    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //展示
    cout<<"q1: ";
    q1.queue_show();

    //求队列大小
    cout<<"q1队列大小为"<<q1.queue_size()<<endl;

    //清空队列
    q1.queue_clear();
    cout<<"队列清空成功"<<endl;

    //展示
    cout<<"q1: ";
    q1.queue_show();

    //求队列大小
    cout<<"q1队列大小为"<<q1.queue_size()<<endl;


    Queue<char> q2;
    //入队
    q2.queue_in('H');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('e');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('l');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('l');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('o');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('W');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('o');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('r');
    //展示
    cout<<"q2: ";
    q2.queue_show();

    //出队
    cout<<q2.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q2.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q2.queue_out()<<"出队成功"<<endl;
    //展示
    cout<<"q2: ";
    q2.queue_show();

    //求队列大小
    cout<<"q2队列大小为"<<q2.queue_size()<<endl;

    //清空队列
    q2.queue_clear();
    cout<<"队列清空成功"<<endl;

    //展示
    cout<<"q2: ";
    q2.queue_show();

    //求队列大小
    cout<<"q2队列大小为"<<q2.queue_size()<<endl;
    return 0;
}