数据结构考研学习-第三章队列1-循环队列

队列：先进先出操作受限制的线性表

队列实现方式-数组

1. 定义队列

lengthQ灵活添加

typedef struct {
    //静态数组实现队列,头出尾部进入
    int data[MAX_size];
    int Front,Rear;
    int lengthQ;
}SQuence;

2. 队空判断

我这里不采用牺牲表空间的做法，在结构体定义的的length，记录队列元素个数，据此判断表空

bool Qempty(SQuence q){
    if(q.lengthQ == 0)
        return true;
    else
        return false;
}

3. 初始化

void init(SQuence &q){
    q.Front = q.Rear = 0;
    q.lengthQ = 0;
}

4. 进队

核心：进队算法可以看出这种结构可以再次利用已经失效的空间，这样的队列又叫做循环队列，rear指向下一个可插入的位置

q.Rear = (q.Rear+1)%MAX_size;

bool Qjoin(SQuence &q,int c){
    if(q.lengthQ == MAX_size){
        return false;
    }
    q.data[q.Rear] = c;
    q.Rear = (q.Rear+1)%MAX_size;
    q.lengthQ += 1;
    return true;
}

5.出队

核心：front头部出队，指向下一个可出队的位置

    q.Front = (q.Front+1)%MAX_size;

bool Qdelete(SQuence &q,int &c){
    if(Qempty(q)){
        return false;
    }
    c = q.data[q.Front];
    q.Front = (q.Front+1)%MAX_size;
    q.lengthQ -= 1;
    return true;
}

6. 预览-查看

查看初始化队列

bool view(SQuence q){
    if(Qempty(q)){
        cout<<"ERRR:表空"<<endl;
        return false;
    }
   int i=0;
    int t = q.Front;
    while(i<q.lengthQ){

        cout<<"i="<<i<<",data="<<q.data[t]<<endl;
        t= (t+1)%MAX_size;
        i++;
    }
    cout<<"当前front："<<q.Front<<endl;
    cout<<"当前rear："<<q.Rear<<endl;
    cout<<"队列中元素个数"<<q.lengthQ<<endl;
    return true;
}

查看已经更改的队列

void myview(SQuence q){

     for(int i=0;i<MAX_size;i++){
        cout<<"i="<<i<<",data="<<q.data[i]<<endl;
    }
     cout<<"队列中元素个数"<<q.lengthQ<<endl;
     cout<<"当前front："<<q.Front<<endl;
    cout<<"当前rear："<<q.Rear<<endl;

}

7. 测试

cout << "Hello World!" <<endl;
    SQuence s;
    init(s);
    cout<<Qempty(s)<<endl;
    for(int i= 0;i<MAX_size;i++){
        Qjoin(s,i);
    }
    myview(s);

    {
        cout<<"删除数据次数："<<endl;
        int a;
        cin>> a;
        for(int i=a;i>0;i--){
            int t;bool flag = Qdelete(s,t);
            cout<<"返回值："<<flag<<",删除数据："<<t<<endl;
        }
        view(s);
    }



    {
        cout<<"插入数据次数："<<endl;
        int a;
        cin>>a;
        for(int i=a;i>=1;i--){
            int b = i;
           cout<<"返回值："<<Qjoin(s,b*2)<<",插入数据"<<b*2<<endl;
        }
        view(s);
    }
       {
        cout<<"再次删除数据次数："<<endl;
        int a;
        cin>> a;
        for(int i=1;i<=a;i++){
            int t;bool flag = Qdelete(s,t);
            cout<<"返回值："<<flag<<",删除数据："<<t<<endl;
        }
        view(s);
    }
       {
        cout<<"再次插入数据次数："<<endl;
        int a;
        cin>>a;
        for(int i=a;i>=1;i--){
                int b = i;
           cout<<"返回值："<<Qjoin(s,3*b)<<",插入数据"<<3*b<<endl;
        }
        view(s);
    }
    cout<<"再看一次全队列！"<<endl;
    myview(s);
    return 0;

8. 结果分析

1. 初始化为首尾都为0，在队中插入7个操作元素
2. 出队三次，012，先进先出，正常，返回状态：1，正常
3. 头部出队，front变化，移动到3，正常
4. 尾部进队，四次，最后一次返回状态，0，正常，因为最大长度是7
5. rear，实际成功操作三次，移动到3，正常

6. 出队顺序与进队顺序相同，出队8次，个数为7，最后一次报错，正常
7. 进队5次，rear，经历了，3,4，5,6，0，插入了所给元素，指向下一位置，1，正常
8. 此时front虽然经历了，出队7次，但队列循环，仍在3位置，正常
9. 再见一次全队是为了解这里的出队，实际上是用新来的数据覆盖旧的，垃圾回收系统完成了