數據結構習題學習筆記(The Sixth Day)

Q1:  如果用一個循環數組 qu[0m0-1]表示隊列時,該隊列只有一個頭指針 front,不設隊尾指針 rear,而改置計數器 count 用以記錄隊列中結點的個數。
1)編寫實現隊列的五個基本運算;

2)隊列中能容納元素的最多個數還是 m0-1  

隊列爲空:count==0,front==0;

隊列爲滿:count==m0;

My View;有三個關鍵的地方:1,模運算的作用:數字在一定範圍循環,實現首尾相連;

                                                2,數組的序號變化:控制在0-(m0-1)範圍內;

                                                3,count:控制在1-m0範圍內.

CODE:

 

#include <stdio.h>
#include 
<stdlib.h>

#define m0 5//最大隊列長度

typedef 
int QElemType;//隊列元素類型

typedef 
struct{
       QElemType 
*base;//初始化的動態分配存儲空間
    int front;
    
int count;
}
SqQueue;


//構造空隊列
SqQueue* makeQueue(){

    SqQueue 
*= (SqQueue *) malloc(sizeof(SqQueue));
    
if(!Q)printf("OVERFLOW! ");

    Q 
-> base = (QElemType *) malloc (m0 * sizeof (QElemType));/*比較關鍵的一步*/
    
if(!-> base)printf("OVERFLOW! ");

    Q 
-> front = 0;
    Q 
-> count = 0;
    
return Q;
}


//判斷隊列是否爲空
int isEmpty(SqQueue *Q){
    
if(Q -> count == 0)
        
return 1;
    
else
        
return 0;
}


//判斷隊列是否已滿
int isFull(SqQueue *Q){
     
if(Q -> count == m0)
         
return 1;
     
else
         
return 0;
}



//取隊頭元素
QElemType pop(SqQueue *Q){
     QElemType h 
= 0;
     
if(isEmpty(Q))
         printf(
"Sorry,the queue is empty! ");//隊列下溢出

     h 
= Q -> base[Q -> front];

     
return h;
}


//將元素e入列
void enQueue(SqQueue *Q,QElemType e){
      
if(isFull(Q)){
          printf(
"Queue overFlow! ");//隊列上溢出

      }



      
int place;
      place 
= (Q -> front + Q -> count) % m0;
      Q 
-> base[place] = e;
      Q 
-> count = (Q -> count + 1% (m0 + 1);
      
if(Q -> count == 0)
      Q 
-> count = 1;//確保count在1-5循環

}


//刪除頭元素
void deQueue(SqQueue *Q){
     
if(isEmpty(Q))
         printf(
"Queue underFlow! ");//隊列下溢出
     else{
         Q 
-> front =(Q -> front + 1% m0;
         Q 
-> count --;
       }

}


//打印當前隊列
void print(SqQueue *Q){
      
if(isEmpty(Q))
         printf(
"Sorry,the queue is empty! ");//隊列下溢出
      else{
          
int p = Q -> count;
          
int i = 0;
          printf(
"Now,there are %d elements of queue :",p);
         
while(p!=0){
           
int place = (Q -> front + i) % m0;
           printf(
"%d,",Q -> base[place]);
           i
++;
           p
--;
         }

         printf(
" ");
      }

}

 

測試代碼:

 

#include <stdio.h>
#include 
"sqqueue.h"

typedef 
int ElemType;

void main(){
   ElemType h;
   SqQueue 
*queue = makeQueue();
   print(queue);
   deQueue(queue);


   enQueue(queue,
1);
   enQueue(queue,
2);
   enQueue(queue,
3);
   enQueue(queue,
4);
   print(queue);

   deQueue(queue);
   deQueue(queue);
   deQueue(queue);

   enQueue(queue,
5);
   print(queue);

   enQueue(queue,
6);
   print(queue);

   deQueue(queue);
   enQueue(queue,
7);
   print(queue);


}

 

RUN:

Q2:假定用一個循環單鏈表表示隊列(稱爲循環隊列),該隊列只設一個隊尾指針 rear,不設隊首指針,編寫如下函數:
(1)向循環鏈隊中插入一個元素爲 x 的結點;
(2)從循環鏈隊中刪除一個結點。
My View:在構造隊列時,有一個關鍵的地方:以節點爲中心.

CODE:

 

#include <stdio.h>
#include 
<stdlib.h>

typedef 
struct QNode{
    
int data;
    
struct QNode *next;
}
QNode, *QueuePtr;//節點定義符

typedef 
struct{
    QueuePtr rear;
//隊尾指針
}
LinkQueue;//隊列定義符號

/*構造隊列*/
LinkQueue
* makeQueue(){
    LinkQueue 
*= (LinkQueue *) malloc(sizeof(LinkQueue));
    
if(!Q)printf("Q:OVERFLOW ");//存儲分配失敗
    else{
    Q
->rear=NULL;
    
//Q->rear->next = Q->rear;
    }

    
return Q;
}


//構造節點
QueuePtr makeNode(int i){
    QueuePtr N 
= (QueuePtr)malloc(sizeof(QNode));
    
if(!N)printf("Node:OVERFLOW ");//存儲分配失敗
    else{
    N
->data=i;
    N
->next=NULL;
    }

    
return N;
}


//判斷隊列是否爲空
int isEmpty(LinkQueue *Q){

    
if(Q->rear == NULL)
        
return 1;
    
else
        
return 0;
}


//將隊列置空
void makeNull(LinkQueue *Q){
    
if(!isEmpty(Q))
       printf(
"錯誤:隊列爲空!");
    
else{
       Q
->rear->next = NULL;

    }

}


//刪除隊列第一個元素
void deQueue(LinkQueue *Q){
    
if(isEmpty(Q))
       printf(
"錯誤:隊列爲空! ");
    
else{
       QueuePtr p;
       p 
= Q->rear->next;
       Q
->rear->next = p->next;
       free(p);
    }

}


/*返回隊列的第一個元素*/
int front(LinkQueue *Q)
{
    
int x;
    
if(!isEmpty(Q))
        x
=(Q->rear->next->data);
    
return x;
}


/*把元素x插入到隊列右端*/
void enqueue(LinkQueue *Q,int e)
{
    QueuePtr p 
= makeNode(e);

    
if(isEmpty(Q)){//如果隊列爲空
        Q->rear = p;
        Q
->rear->next = p;//這個很關鍵,要以節點爲中心
        /*Q->rear = Q->rear->next;這是錯誤的表達*/
    }

    
else{//如果隊列不爲空
    p->next = Q->rear->next;
    Q
->rear->next = p;
    Q
->rear = p;
    }

}


/*打印鏈表*/
void print(LinkQueue *Q){
    
if(!isEmpty(Q)){//判斷隊列是否爲空
          QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
          
if(!p)printf("Node:OVERFLOW ");//存儲分配失敗
          else{
               printf(
"隊列爲:");
               p
=Q->rear->next;

               
do
               
{
                  printf(
"%d",p->data);
                  printf(
",");
                  
if(p == Q->rear)
                      
break;
                  p
=p->next;
               }
while(1);
               printf(
" ");
          }

     }

     
else
         printf(
"錯誤:檢測到隊列爲空,無法打印! ");

}

 

測試代碼:

 

#include <stdio.h>
#include 
"nofront.h"



void main()
{

    LinkQueue 
*Queue = makeQueue();

    print(Queue);
    enqueue(Queue,
3);
    enqueue(Queue,
4);
    enqueue(Queue,
5);
    enqueue(Queue,
6);


    print(Queue);

    
int h = front(Queue);
    printf(
"the first element is %d ",h);

    deQueue(Queue);

    print(Queue);

    enqueue(Queue,
7);
    print(Queue);
}

 

RUN:

閃……

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章