基本数据结构之队列

一、基本数据结构之队列

       队列作为计算机系统一种非常常见的数据结构被大家所熟知。同堆栈一样，队列也是有插入和删除只能在限定段的线性表。

         队列是一种FIFO(First In First Out)的线性表。具体通常用链表或数组来实现。队列只允许在后端(rear)进行插入操作，在前段(front)进行删除操作。

         队列的操作方式和堆栈类似，唯一的区别就是队列只允许在后端进行数据添加。

         队列通常能够解决一下问题：

         1）解决主机与外部设备之间速度不匹配的问题。设置一个缓冲队列。

         2）解决因多用户引起的资源竞争问题。系统按照请求时间设置一个请求队列（还可以给每个任务加一个优先级，就成为了优先级队列）。

         下面介绍队列的几种常见的实现方式：

        

/*
单链队列的实现：单链队列使用链表作为基本数据结构，所以不存在溢出问题(除非主存耗完)，队列长度也没有限制。
但是插入和读取的时间成本较高。
*/
/* 单链队列--队列的链式存储结构 */
typedef struct QNode {
  QElemType data;
  struct QNode *next;
}QNode, *QueuePtr;

typedef struc {
  QueuePtr front, rear; /* 队头队尾指针 */
}LinkQueue;

/* 链队列的基本操作(9个) */

/* 构造一个空队列 */
void InitQueue(LinkQueue *Q)
{
  Q->font = Q->rear = malloc(sizeof(QNode);
  if(!Q->font)
    exit(1);
  Q->front->next = NULL;
}

/* 销毁队列Q */
void DestroyQueue(LinkQueue *Q)
{
  while(Q->front) {
    Q->rear = Q->front->next;
    free(Q->front);
    Q->front = Q->rear;
  }
}

/* 清空队列Q */
void ClearQueue(LinkQueue *Q)
{
  QueuePtr p,q;
  Q->rear = Q->front;
  p = Q->front->next;
  Q->front->next = NULL;
  while(p) {
    q = p;
    p = q->next;
    free(q);
  }
}

/* 若Q为空队列，则返回TRUE，否则返回FALSE */
Status QueueEmpty(LinkQueue Q)
{
  if(Q->font->next == NULL)
    return TRUE;
  else
    return FALSE;
}

/* 求队列的长度 */
int QueueLength(LinkQueue Q)
{
  int i = 0;
  QueuePtr p;
  p = Q.front;
  while(Q.rear != p) {
    i++;
    p = p->next;
  }
  return i;
}

/* 若队列不为空，则用e返回Q的队头元素，并返回OK，否则返回ERROR */
Status GetHead_Q(LinkQueue Q, QElemType *e)
{
  QueuePtr p;
  if(Q.front == Q.rear)
    return ERROR;
  p = Q.front->next;
  *e = p->data;
  return OK;
}

/* 插入e作为Q新的队尾元素 */
void EnQueue(LinkQueue *Q, QElemType e)
{
  QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
  if(!p)
    exit(1);
  p->data = e;
  p->next = NULL;
  Q->rear->next = p;
  Q->rear = p;
}

/* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */
Status DeQueue(LinkQueue *Q, QElemType *e)
{
  QueuePtr p;
  if(Q->front == Q->rear)
    return ERROR;
  p = Q->front; /* 指向头结点 */
  *e = p->data;
  Q->front = p->next;
  if(Q->rear == p)
    Q->rear = Q->front;
  free(p);
  return OK;
}

/* 从队头到队尾依次对队列Q中每个元素调用函数vi() */
void QueueTraverse(LinkQueue Q, (void)(*visit)(QElemType))
{
  QueuePtr p;
  p = Q.front->next;
  while(p) {
    visit(p->data);
    p = p->next;
  }
  printf("\n");
}
-----------------------------我就是分割线啦---------------------------
循环队列
循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。
/* 队列的顺序存储结构(循环队列) */
#define MAX_QSIZE 5 /* 最大队列长度加1*/
typedef struct {
  QElemType *base;/* 初始化的动态分配存储空间 */
  int front;/* 头指针，若队列不空，指向队列头元素 */
  int rear;/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

循环队列的基本操作(9个)
/* 构造一个空队列 */
void InitQueue(SqQueue *Q)
{
  Q->base = malloc(MAX_QSIZE * sizeof(QElemType));
  if(!Q->base)
    exit(1);
  Q->front = Q->rear = 0;
}

/* 销毁队列Q，Q不再存在 */
void DestroyQueue(SqQueue *Q)
{
  if(Q->base)
    free(Q->base);
  Q->base = NULL;
  Q->front = Q->rear = 0;
}

/* 将Q清为空队列 */
void ClearQueue(SeQueue *Q)
{
  Q->front = Q->rear = 0;
}

/* 若队列Q为空队列，则返回TRUE；否则返回FALSE */
Status QueueEmpty(SqQueue Q)
{
  if(Q.front == Q.rear)
    return TRUE:
  else
    return FALSE:
}

/* 返回Q的元素个数，即队列的长度 */
int QueueLength(SeqQueue Q)
{
  return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;
}

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

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

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

/* 从队头到队尾依次对队列Q中每个元素调用函数visit() */
void QueueTraverse(SqQueue Q, void(*visit)(QElemType))
{
  int i ;
  i = Q.front;
  while(i!=Q.rear)
  {
    visit(Q.base[i];
    i = (i+1)%MAX_QSIZE;
  }
  printf("\n");
}
---------------------------------------------我还是分割线---------------------
#include<stdio.h>
#include<stdlib.h>
/*阵列结构，说白了就是用数组存储元素 */
struct Queue
{
  int Array[10];//阵列空间大小
  int head;//前端(front)
  int tail;//后端(rear)
  int length;//当前队列长度，并且使用此成员判断满和空
};

/*元素插入队列*/
void EnQueue(struct Queue *Queue1,int x)
{
  Queue1->Array[Queue1->tail]=x;
  if(Queue1->tail+1==10)//Queue1->length 改空间大小为10
  {
    Queue1->tail=0;//1改为0
  }
  else
  {
    Queue1->tail=Queue1->tail+1;
  }
  Queue1->length=Queue1->length+1;//当前个数增1
}

/*删除队列元素*/
int DeQueue(struct Queue *Queue1)
{
  int x=Queue1->Array[Queue1->head];
  if(Queue1->head+1==10)//空間大小10
  {
    Queue1->head=0;
  }
  else
  {
    Queue1->head=Queue1->head+1;
  }
  Queue1->length=Queue1->length-1;//移出后減少1
  return x;
}
/*基本操作*/
int main()
{
  struct Queue *Queue1=malloc(sizeof(struct Queue));
  Queue1->length=0;
  Queue1->head=0;
  Queue1->tail=0;
  EnQueue(Queue1,5);//將5放入
  EnQueue(Queue1,8);//將8放入
  EnQueue(Queue1,3);//將3放入
  EnQueue(Queue1,2);//將2放入
  printf("%d ",DeQueue(Queue1));
  printf("%d ",DeQueue(Queue1));
  printf("%d ",DeQueue(Queue1));
  system("pause");
}

Note:以上便是队列的基本介绍，包括队列的概念以及应用，最后介绍了，队列的几种常见实现方式。