C++实现顺序栈、循环顺序队列

顺序栈：

header.h:

#ifndef HEADER_H
#define HEADER_H

#include <iostream>
using namespace std;

#define MAX 10
typedef int datatype;

class SeqStack
{
private:
    datatype *data;
    int top;        //记录栈顶元素下标

public:
    //初始化顺序栈
    void init();

    //判空
    bool stack_empty();

    //判满
    bool stack_full();

    //入栈
    void stack_push(datatype e);

    //遍历栈
    void stack_show();

    //出栈
    void stack_pop();

    //销毁
    void free();

};

#endif // HEADER_H

seq_stack.cpp：

#include <iostream>
#include <iomanip>
#include <header.h>

using namespace std;

//初始化顺序栈
void SeqStack::init()
{
    data = new int[MAX];
    top = -1;
    cout << "初始化顺序栈成功" << endl;
}
//判空
bool SeqStack::stack_empty()
{
    return -1 == top;
}
//判满
bool SeqStack::stack_full()
{
    return MAX-1 == top;
}
//入栈
void SeqStack::stack_push(datatype e)
{
    //判断逻辑
    if(stack_full() || !data)
    {
        cout << "入栈失败" << endl;
        return ;
    }
    //先加后压
    top++;
    data[top] = e;

    cout << "入栈成功" <<endl;
}
//遍历栈
void SeqStack::stack_show()
{
    //判断逻辑
    if(stack_empty() || !data)
    {
        cout << "遍历失败" << endl;
        return ;
    }
    //遍历逻辑
    cout << "此时栈中元素有：";
    for(int i = 0; i <= top; i++)
        cout << setw(3) << left << data[i];
    cout << endl;
}
//出栈
void SeqStack::stack_pop()
{
    //判断逻辑
    if(stack_empty() || !data)
    {
        cout << "出栈失败" << endl;
        return ;
    }
    //先弹后减"
    cout << "[" << data[top] << "]出栈成功" << endl;
    top--;
}
//销毁
void SeqStack::free()
{
    delete []data;
    data = nullptr;
    cout << "销毁成功" << endl;
}

main.cpp:

#include <iostream>
#include <header.h>

using namespace std;

int main()
{
    SeqStack S;

    //初始化顺序栈
    S.init();

    //入栈
    S.stack_push(1);
    S.stack_push(2);
    S.stack_push(3);
    S.stack_push(4);

    //遍历
    S.stack_show();

    //出栈
    S.stack_pop();
    S.stack_show();

    //销毁
    S.free();
    S.stack_show();

    return 0;
}

测试结果：

---

循环顺序队列：

header.h:

#ifndef HEADER_H
#define HEADER_H

typedef int datatype;
#define MAX 8

class CirQueue
{
private:
    datatype *data;
    int front;
    int tail;

public:
    //初始化循环队列
    void init();

    //判空
    bool queue_empty();

    //判满
    bool queue_full();

    //入队
    void queue_push(datatype e);

    //遍历
    void queue_show();

    //出队
    void queue_pop();

    //求队列长度
    int queue_size();

    //销毁
    void free();
};

#endif // HEADER_H

cir_queue.cpp:

#include <iostream>
#include <iomanip>
#include <header.h>

using namespace std;

//初始化循环队列
void CirQueue::init()
{
    data = new datatype[MAX];       //存放队列
    front = 0;          //记录队头元素的下标
    tail = 0;           //记录队尾元素的下标
}
//判空
bool CirQueue::queue_empty()
{
    return front == tail;
}
//判满
bool CirQueue::queue_full()
{
    return (tail+1)%MAX == front;
}
//入队
void CirQueue::queue_push(datatype e)
{
    //判断逻辑
    if(queue_full() || !data)
    {
        cout << "入队失败" << endl;
        return ;
    }
    //入队逻辑
    data[tail] = e;

    //队尾后移
    tail = (tail+1) % MAX;

    cout << "入队成功" << endl;
}

//遍历
void CirQueue::queue_show()
{
    //判断逻辑
    if(queue_empty() || !data)
    {
        cout << "遍历失败" << endl;
        return ;
    }
    cout << "此时队内成员有：";
    //遍历逻辑
    for(int i = front; i < tail; i = (i+1) % MAX)
        cout << setw(3) << left << data[i];
    cout << endl;
}

//出队
void CirQueue::queue_pop()
{
    //判断逻辑
    if(queue_empty() || !data)
    {
        cout << "出队失败" << endl;
        return ;
    }

    //出队逻辑
    cout << "[" << data[front] << "]出队成功" << endl;
    //队头后移
    front = (front+1) % MAX;
}

//求队列长度
int CirQueue::queue_size()
{
    return (tail+MAX-front)%MAX;
}

//销毁
void CirQueue::free()
{
    delete []data;
    data = nullptr;
    cout << "销毁成功" << endl;
}

main.cpp:

#include <iostream>
#include <header.h>

using namespace std;

int main()
{
    CirQueue Q;

    //初始化循环顺序队列
    Q.init();

    //入队
    Q.queue_push(1);
    Q.queue_push(2);
    Q.queue_push(3);
    Q.queue_push(4);
    Q.queue_push(5);

    //遍历
    Q.queue_show();

    //出队
    Q.queue_pop();
    Q.queue_show();

    //求队列长度
    cout << "队列长度为：" << Q.queue_size() << endl;

    //销毁
    Q.free();
    Q.queue_show();

    return 0;
}

测试结果如下：