数据结构 - 队列

郝斌版《数据结构》学习笔记

时间：2015.08.31 - 2015.09.05

队列：“先进先出”（两个口，一个口进，一个口出，时间相关的适用）。

front

rear 队尾

入队

出队

链式队列 - 用链表实现

静态队列 - 用数组实现

        静态队列通常都必须是循环队列

为什么是循环队列？

        传统的数组增减之后，内存空余且不能使用

需要几个参数？各参数的含义？

        2个参数不同场合有不同的含义

                1）队列初始化【front和rear的值都为零】

                2）队列非空【front代表队列的第一个元素，rear代表队列最后一个有效元素的下一个元素】

                3）队列空【front和rear值相等，但不一定是零】

入队、出队伪算法讲解

        入队:

                两步完成：1.将值存入r所代表的位置

                                  2.错误的写法r = r + 1;

                                     正确的写法是：r = (r + 1) % 数组的长度

        出队：

                一步完成：1. f = (f + 1) % 数组的长度

循环队列判断为空、已满

        为空：front和rear值相等

        已满：

                预备知识：

                                front与rear的值大小不定，可大可小可相等。

                两种方式：

                                1、多增加一个表标识参数

                                2、少用一个元素【通常使用的方式】

                                            如果front与rear紧挨着，则队列已满

                                            if ((r + 1) % 数组长度 == f)

                                                      已满

                                            else

                                                      未满

队列的具体应用：

        所有和时间有关的操作都有队列的影子。

# include <stdio.h>

# include <malloc.h>

typedef struct Queue

{

 int * pBase;

 int front;

 int rear;

} QUEUE;

void init(QUEUE *); //加*改变实参

bool en_queue(QUEUE *, int); //入队

void traverse_queue(QUEUE *); //遍历

bool full_queue(QUEUE *);

bool empty_queue(QUEUE *);

bool out_queue(QUEUE *, int *); //出队

int main(void)

{

 QUEUE Q;

 int val;

 init(&Q);

 en_queue(&Q, 1);

 en_queue(&Q, 2);

 en_queue(&Q, 3);

 en_queue(&Q, 4);

 en_queue(&Q, 5);

 en_queue(&Q, 6);

 traverse_queue(&Q);

 if (out_queue(&Q, &val))

  printf("succeed, 出队元素是：%d\n", val);

 else

  printf("failed");

 traverse_queue(&Q);

 return 0;

}

void init(QUEUE * pQ)

{

 pQ->pBase = (int *)malloc(sizeof(int) * 6);

 pQ->front = 0;

 pQ->rear = 0;

}

bool full_queue(QUEUE * pQ)

{

 if ((pQ->rear + 1) % 6 == pQ->front)

  return true;

 else

  return false;

}

bool en_queue(QUEUE * pQ, int val)

{

 if (full_queue(pQ))

 {

  return false;

 }

 else

 {

  pQ->pBase[pQ->rear] =val;

  pQ->rear = (pQ->rear + 1) % 6;

  return true;

 }

}

void traverse_queue(QUEUE * pQ)

{

 int i = pQ->front;

 while (i != pQ->rear)

 {

  printf("%d ", pQ->pBase[i]);

  i = (i + 1) % 6;

 }

 printf("\n");

 

 return;

}

bool empty_queue(QUEUE * pQ)

{

 if (pQ->front == pQ->rear)

  return true;

 else

  return false;

}

bool out_queue(QUEUE * pQ, int * pVal)

{

 if (empty_queue(pQ))

  return false;

 else

 {

  *pVal = pQ->pBase[pQ->front];

  pQ->front = (pQ->front + 1) % 6;

  return true;

 }

}