数据结构 - 队列

// 循环队列-定义

// 循环队列-定义
#define MaxSize 10
struct Queue
{
    //定义顺序对的结构体
    int data[MaxSize]; // 数据域
    int f,r; // f对头下标，r队尾下标
};
1
2
3
4
5
6
7
8

循环对列-入队：

bool enQueue(Queue &Q, int e) {
    // 在循环队列尾插入元素e
    
    // 1、判断
    if((Q.r + 1) % MaxSize == Q.f) {
        return 0; // 队满
    }
    
    // 2、执行
    Q.data[Q.r] = e;
    Q.r = (Q.r + 1) % MaxSize;
    
    // 3、处理
    return 1;
        
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

循环队列 -出队：

// 循环队列 -出队
bool deQueue (Queue &Q) {
    // 在循环队头出队
    
    // 1、判断
    if(Q.f == Q.r) {
        return 0; // 队空
    }
    
    // 2、执行
    cout << "出队的为" << Q.data[Q.f] << endl;
    Q.f = (Q.f + 1) % MaxSize;
    
    // 3、处理
    return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

循环队列-打印：

// 循环队列 打印
void print(Queue &Q) {
    // 打印队列
    cout << "从对头开始打印" << endl;
    
    int i;
    for(i = Q.f; i! = Q.r; i = (i + 1) % MaxSize) {
        cout << Q.data[i] << endl;
    }
}
1
2
3
4
5
6
7
8
9
10

链队-定义：

// 链队-定义
struct LQueue {
    // 定义链队结构体*（队头为首元结点， 队尾只用指针）
    
    int data; // 数据域
    struct LQueue *next; // 下一指针
};
1
2
3
4
5
6
7

链队-入队：

// 链队-入队
LQueue & enQueue(LQueue *r, int e) {
    // 在队尾指针r后面入队元素e
    
    LQueue *q = new LQueue;
    
    q -> data = e;
    q -> next = null;
    r -> next = q;
    
    r = q; //改变最后的队尾指针
    return r;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

链队 - 出队

// 链队 - 出队
bool deQueue(LQueue *L) {
    // 将队首元结点出队
    LQueue *p = L; *q = L -> next;
    
    // 1、判断
    if(q == NUll) {
        cout << "队空" << endl;
        return 0; //  队空
    }
    
    // 2、执行
    cout << "出队的元素" << p -> next -> data << endl;
    p -> next = q -> next;
    free(q);
    
    // 3、后处理
    return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19