day3_C++

#ifndef STACK_H
#define STACK_H

#include 
#include 

using namespace std;


typedef int datatype;

#define MAX 5

class Stack
{
public:
    /*构造函数*/
    Stack();
    /*拷贝构造函数*/
    Stack(const Stack& others);
    /*析构函数*/
    ~Stack();

    /*判满 true 满 */
    bool is_full();
    /*判满 true 空*/
    bool is_empty();
    /*入栈*/
    void in_stack(datatype e);
    /*出栈*/
    datatype out_stack();
    /*清空栈*/
    void clear_stack();
    /*求栈顶元素*/
    datatype get_stackTop_E();
    /*求栈的大小*/
    void get_stackSize();


private:
    int top;
    datatype *data;
};

#endif // STACK_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include "stack.h"

Stack::Stack():data(new int[MAX]),top(-1)
{
    memset(this->data,0,MAX);
    //在堆区申请max个int大小的空间
    cout<<"栈容器初始化成功"<data[i] = others.data[i];
    }
    cout<<"拷贝完成"<top ==MAX-1)
        return true;
    else
        return false;
}

bool Stack::is_empty()
{
    if(this->top == -1)
        return true;
    else
        return false;
}


void Stack::in_stack(datatype e)
{
    if(this->is_full()==false){
        this->top++;
        this->data[this->top] = e;
        cout<<"入栈成功"<is_empty()==false){
        datatype temp = this->data[this->top];
        this->top--;
        return temp;
    }else{
         cout<<"出栈失败，栈空"<is_empty()==false){
        this->top=-1;
        cout<<"清空成功"<is_empty()==true)
         return NULL;
     return this->data[this->top];
}

void Stack::get_stackSize(){
    cout<<"栈中有元素 "<top+1<<"个"<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88

用C++的类完成数据结构 循环队列的相关操作

queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include 
#include 

using namespace std;

typedef int datatype;
#define MAX 5

class Queue
{

public:
    /*构造函数*/
    Queue();
    /*拷贝构造函数*/
    Queue(const Queue& others);
    /*析构函数*/
    ~Queue();

    /*判满 true 满 */
    bool is_full();
    /*判满 true 空*/
    bool is_empty();
    /*入队*/
    void in_queue(datatype e);
    /*出队*/
    datatype out_queue();
    /*清空队*/
    void clear_queue();
    /*求队的大小*/
    void get_queueSize();


private:
    datatype *data;
    int font;
    int tail;
};

#endif // QUEUE_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

queue.cpp

#include "queue.h"

Queue::Queue():data(new int [MAX]),tail(0),font(0)
{
    memset(this->data,0,MAX);
    cout<<"循环队列初始化成功"<font;
    int t = this->tail;
    while ((f+MAX)%MAX==t) {
        this->data[f] = others.data[f];
        f++;
    }
    cout<<"拷贝完成"<tail+1)%MAX == this->font){
        return true;
    }
    return false;
}

bool Queue::is_empty()
{
    if(this->font == this->tail){
        return true;
    }
    return false;
}

Queue::~Queue()
{
    //释放堆区数据
    delete []data;
    cout<<"析构完成"<is_full() == true){
        cout<<"队列满了"<data[this->tail] = e;
    this->tail =  (this->tail+1)%MAX;
    cout<<"入队成功"<is_empty() == true){
        cout<<"队列空，无元素"<data[this->font];
    this->font = (this->font+1)%MAX;
    return temp;
}


void Queue::clear_queue()
{
    if(this->is_empty() == true){
        cout<<"队列空，无元素"<font = 0;
    this->tail = 0;
}

void Queue::get_queueSize()
{
    cout<<"队列的大小是：" <<(this->tail-this->font+MAX)%MAX<