第九篇：基本数据结构——队列的链式表示

来源：互联网发布：最优化方法第二版答案编辑：程序博客网时间：2024/04/30 05:49
该队列为链式队列，初建队列时，队头和队尾均指向头结点，头结点中不存放
数据，只存放指针，头结点的下一个节点才开始存放数据，这这样做的目的是
为了在入队和出队时方便对队列的操作，而不用考虑特殊情况。
C语言源代码
[cpp] view plain copy
#include<stdio.h>  
#include<stdlib.h>  
  
typedef struct Node  
{  
    int data;  
    struct Node *pNext;  
}NODE,*PNODE;  
  
typedef struct Queue  
{  
    PNODE front;  //队头指针  
    PNODE rear;   //队尾指针  
}QUEUE,*PQUEUE;  
  
PQUEUE create_queue();  
bool is_empty(PQUEUE);  
void en_queue(PQUEUE, int);  
bool de_queue(PQUEUE,int *);  
void destroy_queue(PQUEUE);  
void traverse_queue(PQUEUE);  
  
int main()  
{  
    int data_de = 0;         //用来保存出队的元素值  
  
    //创建队列并进行入队测试  
    PQUEUE pS = create_queue();  
    en_queue(pS,2);  
    en_queue(pS,4);  
    en_queue(pS,6);  
    traverse_queue(pS);  
      
    //出队测试  
    if(de_queue(pS,&data_de))  
        printf("delete succeed,the deleted data is: %d\n",data_de);  
    else  
        printf("queue is empty! delete falied!\n");  
    traverse_queue(pS);  
      
    //销毁队列测试  
    destroy_queue(pS);  
    printf("queue destroyed!\n");  
    traverse_queue(pS);  
  
    return 0;  
}  
  
/* 
创建一个空队列，队头指针和队尾指针都指向头结点， 
头结点中不存放数据，只存放指针 
*/  
PQUEUE create_queue()  
{  
    PQUEUE pS = (PQUEUE)malloc(sizeof(Queue));  
    pS->front = (PNODE)malloc(sizeof(NODE));  
    if(!pS || !pS->front)  
    {  
        printf("pS or front malloc failed!!");  
        exit(-1);  
    }  
    else  
    {  
        pS->rear = pS->front;  
        pS->front->pNext = NULL;  
    }  
    return pS;  
}  
  
/* 
判断队列是否为空 
*/  
bool is_empty(PQUEUE pS)  
{  
    if(pS->front == pS->rear)  
        return true;  
    else  
        return false;  
}  
  
/* 
进队函数，从队尾进队，队头指针保持不变 
*/  
void en_queue(PQUEUE pS, int e)  
{  
    PNODE pNew = (PNODE)malloc(sizeof(NODE));  
    if(!pNew)  
    {  
        printf("pNew malloc failed");  
        exit(-1);  
    }  
    else  
    {  
        pNew->data = e;  
        pNew->pNext = NULL;  
        pS->rear->pNext = pNew;  
        pS->rear = pNew;  
    }  
    return;  
}  
  
/* 
出队函数，从队头出队，队尾指针保持不变，但当最后一个元素出队时， 
需要对队尾指针重新赋值，使其指向头结点 
*/  
bool de_queue(PQUEUE pS,int *pData)  
{  
    if(is_empty(pS))  
        return false;  
    else  
    {  
        PNODE p = pS->front->pNext;  
        *pData = p->data;  
        pS->front->pNext = p->pNext;  
  
        //这里是队列头元素出队的特殊情况，一般情况下，删除队头元素时  
        //仅需修改头结点中的指针，但当队列中最后一个元素被删除时，  
        //队列尾指针也丢失了，因此需对队尾指针重新赋值（指向头结点）。  
        if(pS->rear == p)           
            pS->rear = pS->front;  
        free(p);  
    }  
    return true;  
}  
  
/* 
遍历队列，从对头向队尾依次输出队中的元素 
*/  
void traverse_queue(PQUEUE pS)  
{  
    if(is_empty(pS))  
        printf("there is no data in the queue!\n");  
    else  
    {     
        PNODE pCurrent = pS->front->pNext;   
        printf("Now datas int the queue are:\n");  
        while(pCurrent)  
        {  
            printf("%d ",pCurrent->data);  
            pCurrent = pCurrent->pNext;  
        }  
        printf("\n");  
    }  
    return;  
}  
  
/* 
销毁队列,头结点也被销毁,最后也将pS节点销毁，并将其指向为空，避免垂直指针的产生 
*/  
void destroy_queue(PQUEUE pS)  
{  
    if(is_empty(pS))  
        return;  
    else  
    {  
        while(pS->front)  
        {  
            pS->rear = pS->front->pNext;  
            free(pS->front);  
            pS->front = pS->rear;  
        }  
    }  
    free(pS);  
    pS = 0;  
    return;  
}  
阅读全文
0 0