【转】基础知识系列4--队列

原文地址：http://www.cnblogs.com/mcgrady/p/3221672.html

 

上一篇讲了栈，这一篇要总结的是我们常用的队列，我想从以下几个方面进行总结。

1，什么是队列？ 
2，队列的存储结构？ 
3，队列的常用操作及实现代码？

 

1.什么是队列

1，首先，队列也是一种特殊的线性表，它是一种操作受限的线性表。它只允许在表的一端进行元素插入，而在另一端进行元素删除。允许插入的一端称为队尾(rear)，允许删除的一端称为队头(font)。

2，对于队列，与现实生活中的排队类似，新加入的成员总是在队尾，而排在队列最前面的总是最先离开队列，即先进先出，因此队列也称为先进先出表(FIFO)。

 

2.队列的存储结构

 

3.队列的常见操作和代码实现

1，初始化队列

思路：构造一个空队列，即将头指针head和尾指针rear都设置为0。

2，入队

思路：若队列不满，则将数据x插入到尾指针rear指向的位置，然后再将rear加1。

3，出队

思路：若队列不空，则将头指针head加1，并返回被删除的元素。

4，取队头

思路：若队列不空，则返回队头元素。

5，取队长

思路：即尾指针rear-头指针head。

6，判队空

思路：只需要判断头指针head与尾指针是否相等即可

7，判队满

思路：只需判断尾指针与MaxSize是否相等即可

注：在一个非空队列中，头指针始终指向队头元素，而尾指针始终指向队尾元素的下一个位置。

 

原代码实现用一个数组，但是没有固定队列头，head和rear指针一直在加，即使固定了队列头，每次把队列头推出去也要移动数组，用循环数组可以不用移动，感觉用链表会更加灵活方便，于是我就自己写了一个demo。

循环数组实现队列：

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

#define OK     0
#define ERROR -1
#define N      5

typedef int Status;
typedef int ElemType;
typedef struct queue
{
    ElemType data[N];
    int head,rear;
}Queue;

void Init(Queue *q)
{
    q->head=q->rear=0;
}

Status InQueue(Queue *q,ElemType e)
{
    printf("Insert %d to queue\n",e);
    if((q->rear+1)%N == q->head)
    {
        printf("queue is full\n");
        return ERROR;
    }
    q->data[q->rear] = e;
    q->rear = (q->rear+1)%N;
    
    return OK;
}

Status DeleteQueue(Queue *q,ElemType *e)
{
    if(q->head == q->rear)
    {
        printf("queue is empty\n");
        return ERROR;
    }
    *e = q->data[q->head];
    printf("delete %d\n",*e);
    q->head = (q->head+1)%N;
    return OK;
}
    
void Display(Queue *q)
{
    int i=0;
    printf("Queue is :");
    while((q->head+i)%N != q->rear)
    {
        printf("%d ",q->data[(q->head+i)%N]);
        i++;
    }
    printf("\n");
}

int main(void)
{    
    int i;
    ElemType e;
    Queue *q = (Queue*)malloc(sizeof(Queue));
    
    Init(q);
    for(i=0;i<10;i++)
    {
        InQueue(q,i);
        Display(q);
    }
    while(q->head != q->rear)
    {
        DeleteQueue(q,&e);
        Display(q);
    }

    return 0;
}

运行结果

 

链表实现队列：

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

typedef struct list
{
    int data;
    struct list*next;
}List;
typedef struct queue
{
    List*front;
    List*rear; 
}Queue;

void init_queue(Queue*q)
{
    q->front=q->rear=NULL; 
}

void inqueue(Queue *q,int data)
{
    List*newnode=(List*)malloc(sizeof(List));
    newnode->next=NULL;
    newnode->data=data;
    if(q->front==NULL && q->rear==NULL)//如果是空队列 
    {
        q->front=q->rear=newnode;
    }
    else//如果队列非空 
    {
        q->rear->next=newnode;
        q->rear=newnode; 
    }
    printf("Insert %d\n",data);
}
int dequeue(Queue*q)
{ 
    List*temp=NULL;
    int result;
    //如果队列为空
    if(q->front==NULL && q->rear==NULL)
    {
        printf("queue is empty,out of queue failed\n");
        return -1;
    } 
    //如果最后一个元素出队列
    else if(q->front==q->rear)
    {
         temp=q->front;
        result=temp->data;
        q->front=q->rear=NULL;
        free(temp);
        return result;   
    }
    //非最后元素出队列 
    else
    {
        temp=q->front;
        result=temp->data;
        q->front=q->front->next;
        free(temp);
        return result;
    }
}
int queue_isEmpty(Queue*q)
{
    if(q->front==q->rear && q->front==NULL)
        return 1;
    else
        return 0; 
}

int main()
{ 
    int i; 
    Queue*q=(Queue*)malloc(sizeof(Queue));
    init_queue(q);
    for(i=0;i<5;i++)
        inqueue(q,i);
    while(!queue_isEmpty(q))
    {
        printf("Delete %d\n",dequeue(q));
    } 
}

运行结果

 

栈实现队列：

思路是：首先开辟两个栈，如果进队列，则体现得是进栈A

如果出队列，体现的是：如果栈B空（之前的元素全部弹出去了），则A全部出队列，再全部进栈B，然后栈B出栈一个元素；

如果栈B不空，则栈B出栈一个元素

代码：

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

#define OK    0
#define ERROR 1

typedef int ElemType;
typedef int Status;

typedef struct list
{
    ElemType data;
    struct list *next;
}List;

typedef struct stack
{
    List* top;
}Stack;

Stack *A,*B;

void InitStack(Stack *s)
{
    s->top =NULL;
}

void Push(Stack *s,ElemType e)
{
    List *p = (List*)malloc(sizeof(List));
    p->data = e;
    p->next = s->top;
    s->top = p;
}

Status Pop(Stack *s)
{
    ElemType temp;
    List *p;
    if(s->top == NULL)
        return ERROR;
    p = s->top;
    s->top = s->top->next;
    temp = p->data;
    free(p);
    return temp;
}

void InitQueue()
{
    A = (Stack*)malloc(sizeof(Stack));
    B = (Stack*)malloc(sizeof(Stack));
    InitStack(A);
    InitStack(B);
}

void InQueue(ElemType e)
{
    Push(A,e);
}

Status QueueIsEmpty()
{
    if(A->top == NULL && B->top == NULL)
        return 1;
    return 0;
}

Status DeleteQueue()
{
    if(B->top == NULL)
    {
        while(A->top != NULL)
            Push(B,Pop(A));
    }
    printf("Delete %d\n",Pop(B));
}

int main(void)
{
    int i;
    InitQueue();
    for(i=0;i<3;i++)
    {
        printf("Insert %d\n",i);
        InQueue(i);
    }
    DeleteQueue();
    printf("Insert 4\n");
    InQueue(4);
    printf("Insert 5\n");
    InQueue(5);
    while(!QueueIsEmpty())
        DeleteQueue();

    return 0;
}

运行结果：