数据结构之队列

一、单向链式队列

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

using namespace std;

typedef struct Node{
    //定义队列
    int data;
    struct Node* next;
}Queue;

typedef struct pointer{
    //定义指向队列头和队列尾的指针
    Queue* front;
    Queue* rear;
}Qpointer;

void QueueInit(Qpointer* qp)
{//初始化队列
    Queue* que;
    que = (Queue*)malloc(sizeof(Queue));
    que->next = NULL;
    qp->front = que;
    qp->rear = que;
}

int IsEmpty(Qpointer* qp)
{//队列非空
    if (qp->front == qp->rear)
        return 1;
    else
        return 0;
}

int QueuePush(Qpointer* qp,int element)
{//插入
    //sucess return 1,failure return 0
    Queue* que;
    que = (Queue*)malloc(sizeof(Queue));
    if (que == NULL)
        return 0;

    que->data = element;
    que->next = NULL;
    qp->rear->next = que;
    qp->rear = que;
    return 1;
}

int QueuePop(Qpointer* qp,int* element)
{//删除
    Queue* que;
    if (IsEmpty(qp)){
        return 0;
    }
    que = qp->front->next;
    *element = que->data;
    qp->front->next = que->next;
    if (qp->rear == que){
        qp->rear = qp->front;
    }
    free(que);
    return 1;
}


int main()
{
    Qpointer* qp;
    int x;

    qp = (Qpointer*)malloc(sizeof(Qpointer));
    QueueInit(qp);
    cout << "enter positive intergers:";
    cin >> x;
    while (x > 0){
        QueuePush(qp,x);
        cout << x << " ";
        x--;
    }
    cout << endl;

    //print queue
    Queue* p = qp->front->next;
    if (p == NULL)
        return 0;
    cout << "queue element:";
    while(p){
        cout << " " << p->data;
        p = p->next;
    }
    cout << endl;

    //delete queue
    cout << "delete queue:";
    while (QueuePop(qp,&x)){
        cout << x;
    }
    cout << endl;

    //free memnory
    p = qp->front;
    free(p);
    free(qp);

    return 0;
}

二、循环队列

 #include <iostream> 
 #include <malloc.h> 
 #define TRUE 1  
 #define FALSE 0  
 #define OK 1  
 #define ERROR 0  
 #define INFEASIBLE -1  
 #define OVERFLOW -2   
 using namespace std;  
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */  
 typedef int QElemType;  

 #define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)  
 typedef struct  
 {  
   QElemType *base; // 初始化的动态分配存储空间  
   int front; // 头指针,若队列不空,指向队列头元素  
   int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置  
 }SqQueue;  

 /* bo3-3.c 循环队列(存储结构由c3-3.h定义)的基本操作(9个) */  
 Status InitQueue(SqQueue &Q)  
 { /* 构造一个空队列Q */  
   (Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));  
   if(!(Q).base) /* 存储分配失败 */  
     exit(OVERFLOW);  
   (Q).front=(Q).rear=0;  
   return OK;  
 }  


 Status QueueEmpty(SqQueue Q)  
 { /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */  
   if(Q.front==Q.rear) /* 队列空的标志 */  
     return TRUE;  
   else  
     return FALSE;  
 }  

 Status GetHead(SqQueue Q,QElemType &e)  
 { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */  
   if(Q.front==Q.rear) /* 队列空 */  
     return ERROR;  
   e=*(Q.base+Q.front);  
   return OK;  
 }  

 Status EnQueue(SqQueue &Q,QElemType e)  
 { /* 插入元素e为Q的新的队尾元素 */  
   if(((Q).rear+1)%MAXQSIZE==(Q).front) /* 队列满 */  
     return ERROR;  
   (Q).base[(Q).rear]=e;  
   (Q).rear=((Q).rear+1)%MAXQSIZE;  
   return OK;  
 }  

 Status DeQueue(SqQueue &Q,QElemType &e)  
 { /* 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK;否则返回ERROR */  
   if((Q).front==(Q).rear) /* 队列空 */  
     return ERROR;  
   e=(Q).base[(Q).front];  
   (Q).front=((Q).front+1)%MAXQSIZE;  
   return OK;  
 }  

 Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))  
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi().一旦vi失败,则操作失败 */  
   int i;  
   i=Q.front;  
   while(i!=Q.rear)  
   {  
     vi(*(Q.base+i));  
     i=(i+1)%MAXQSIZE;  
   }  
   printf("\n");  
   return OK;  
 }  

void visit(QElemType i)  
 {  
  cout<<i<<" ";  
 }  

int main()  
 {  
   int i;  
   QElemType d;  
   SqQueue q;  
   i=InitQueue(q);  
   EnQueue(q,1);  
   EnQueue(q,3);  
   EnQueue(q,5);  
   EnQueue(q,7);  
   EnQueue(q,9);  
   cout<<"已经插入5个元素(1,3,5,7,9)\n";  
   cout<<"队列的元素依次为：";  
   QueueTraverse(q,visit);  
   cout<<endl;  
   i=GetHead(q,d);  
   if(i==OK)  
     cout<<"队头元素是: "<<d<<endl;  
   DeQueue(q,d);  
   cout<<"删除了队头元素，"<<d;  
   i=GetHead(q,d);  
   if(i==OK)  
     cout<<"\t新的队头元素是: "<<d<<endl;  
   DeQueue(q,d);  
   cout<<"删除了队头元素，"<<d;  
   i=GetHead(q,d);  
   if(i==OK)  
     cout<<"\t新的队头元素是: "<<d<<endl;  
    DeQueue(q,d);  
   cout<<"删除了队头元素，"<<d;  
   i=GetHead(q,d);  
   if(i==OK)  
     cout<<"\t新的队头元素是: "<<d<<endl;  
   DeQueue(q,d);  
   cout<<"删除了队头元素，"<<d;  
   i=GetHead(q,d);  
   if(i==OK)  
     cout<<"\t新的队头元素是: "<<d<<endl;       
   DeQueue(q,d);  
   cout<<"\t删除了最后一个元素"<<d<<endl;  
   if(QueueEmpty(q))  
   cout<<"现在队列是一个空队列";  
   else cout<<"队列非空";  
   cout<<endl;             
   return 0;  
 }