队列习题

Posted 2021-11-04 duwenze

循环队列的基本操作：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #define maxSize 20
 4 typedef int QElemType;
 5 typedef struct   
 6 {
 7     QElemType elem[maxSize];
 8     int front,rear;
 9 }CircQueue;
10 void InitQueue(CircQueue *Q)  //初始化队列 
11 {
12     Q->front=Q->rear=0; 
13 }
14 int EnQueue(CircQueue *Q,QElemType x) //进队列 
15 {
16     if((Q->rear+1)%maxSize==Q->front)
17     {
18         return 0;
19     }
20     Q->elem[Q->rear]=x;
21     Q->rear=(Q->rear+1)%maxSize;
22     return 1;     
23 }
24 int DeQueue(CircQueue *Q,QElemType *x) //出队列 
25 {
26     if(Q->front==Q->rear)
27     {
28         return 0;
29     }
30     *x=Q->elem[Q->front];
31     Q->front=(Q->front+1)%maxSize;
32     return 1;
33 }
34 int QueueSize(CircQueue *Q) //求对列长度 
35 {
36     return (Q->rear-Q->front+maxSize)%maxSize;
37 }
38 int QueueEmpty(CircQueue *Q) //判断队列空否 
39 {
40     return Q->front==Q->rear;
41 }
42 int QueueFull(CircQueue *Q) //判断队列满否 
43 {
44     return (Q->rear+1)%maxSize==Q->front;
45 }
46 int GetFront(CircQueue *Q,QElemType *x) //读取队头 
47 {
48     if(Q->front==Q->rear)
49     {
50         return 0;
51     }
52     *x=Q->elem[Q->front];
53     return 1;
54 }

1.返回循环队列中最小元素的值的位置：

 1 int FindMin(CircQueue *Q)
 2 {
 3     int locate=-1;     //locate为最小元素的位置，物理位置 
 4     int x,n=QueueSize(Q);
 5     int min;
 6     GetFront(Q,&min);
 7     for(int i=0;i<n;i++) //遍历队列 
 8     {
 9         DeQueue(Q,&x);
10         if(min>x)
11         {
12             min=x;
13             locate=i;
14         }
15         EnQueue(Q,x); 
16     } 
17     return locate;
18 }

2.借助空栈将循环队列元素逆置

所需顺序栈的基本操作：

 1 typedef int SElemType;
 2 typedef struct 
 3 {
 4     SElemType *elem;
 5     int maxsize,top;
 6 }SeqStack;
 7 void StackInit(SeqStack *S) //初始化栈 
 8 {
 9     (*S).elem=(SElemType *)malloc(maxSize*sizeof(SElemType));
10     if(S->elem==NULL)
11     {
12         printf("存储分配错误！\\n");
13         exit(1);
14     }
15     S->maxsize=maxSize;
16     S->top=-1;
17 }
18 int StackPush(SeqStack *S,SElemType x) //进栈 
19 {
20     if(S->top==S->maxsize-1)
21     {
22         return 0;
23     }
24     S->elem[++S->top]=x;
25     return 1; 
26 }
27 int StackPop(SeqStack *S,SElemType *x) //出栈 
28 { 
29     if(S->top==-1)
30     {
31         return 0;
32     }
33     *x=S->elem[S->top--];
34     return 1;
35 }

队列逆置：

 1 void QueueReverse(CircQueue *Q)
 2 {
 3     int x,n=QueueSize(Q);
 4     SeqStack S;
 5     StackInit(&S);
 6     for(int i=0;i<n;i++)
 7     {
 8         DeQueue(Q,&x);
 9         StackPush(&S,x);
10     }
11     for(int i=0;i<n;i++)
12     {
13         StackPop(&S,&x);
14         EnQueue(Q,x);
15     }
16 }

3.使用两队列模拟栈

 1 void QStackInit(CircQueue *Q1,CircQueue *Q2) //初始化模拟栈 
 2 {
 3     InitQueue(Q1);
 4     InitQueue(Q2);
 5 }
 6 bool QStackEmpty(CircQueue *Q1,CircQueue *Q2) //判断模拟栈空否 
 7 {
 8     return QueueEmpty(Q1)&&QueueEmpty(Q2);
 9 }
10 bool QStackFull(CircQueue *Q1,CircQueue *Q2) //判断模拟栈满否 
11 {
12     return QueueFull(Q1)||QueueFull(Q2);
13 }
14 bool QStackPush(CircQueue *Q1,CircQueue *Q2,int x) //进入模拟栈 
15 {
16     if(QStackFull(Q1,Q2))
17     {
18         return false;
19     }
20     if(QStackEmpty(Q1,Q2))
21     {
22         EnQueue(Q1,x);
23     }
24     else if(!QueueEmpty(Q1))
25     {
26         EnQueue(Q1,x);
27     }
28     else
29     {
30         EnQueue(Q2,x);
31     } 
32     return true;
33 }
34 bool QStackPop(CircQueue *Q1,CircQueue *Q2,int *x) //出模拟栈 
35 {
36     if(QStackEmpty(Q1,Q2))
37     {
38         return false;
39     }
40     if(!QueueEmpty(Q1))
41     {
42         while(1)
43         {
44             DeQueue(Q1,x);
45             if(!QueueEmpty(Q1))
46             {
47                 EnQueue(Q2,*x);
48             }
49             else
50             {
51                 break;
52             }    
53         }
54     }
55     else
56     {
57         while(1)
58         {
59             DeQueue(Q2,x);
60             if(!QueueEmpty(Q2))
61             {
62                 EnQueue(Q1,*x);
63             }
64             else
65             {
66                 break;
67             }
68         }    
69     }
70     return true;
71 }

以下是使用模拟栈将十进制数转化二进制数：

 1 int main()
 2 {
 3     CircQueue Q1,Q2;
 4     InitQStack(&Q1,&Q2);
 5     int x,i,result=0;
 6     printf("请输入一个十进制数：\\n");
 7     scanf("%d",&x);
 8     while(x!=0)
 9     {
10         i=x%2;
11         x=x/2;
12         QStackPush(&Q1,&Q2,i); 
13     }
14     while(!QStackEmpty(&Q1,&Q2))
15     {
16         QStackPop(&Q1,&Q2,&i);
17         result=result*10+i;
18     }
19     printf("二进制为：%d\\n",result);
20     
21 } 

运行结果如下：