数据结构学习笔记之队列

定义：

    一种可以实现“先进先出”的存储结构；

分类：

        链式队列：---用链表实现

                front

                rear 

        静态队列：--用数组实现

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

循环队列

1. 静态队列为什么必须是循环队列

2.循环队列需要几个参数来确定

      front 

       rear

2个参数不同场合有不同的含义及其含义的讲解

先记住，慢慢体会

        （1）队列初始化

                  front 和rear的值都是零

        （2）队列非空

                   front代表队列的第一个元素

                  rear代表队列最后一个有效元素的下一个元素

        （3）队列空

                   front 和rear的值相等，但不一定是零

3.循环队列各个参数的含义

    上面

4.循环队列入队伪算法讲解

    （1）将值存入r所代表的位置

    （2）r =（r+1）%数组的长度

5.循环队列出队伪 算法讲解

    f=(f+1)%数组的长度

6.如何判断循环队列是否为空

    如果front与rear值相等，则为空

7.如何判断循环队列是否已满

    定义另一个变量len表示队列长度（一般不用）

    或少用一个元素

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

           已满

    else

           不满

队列的具体应用：

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

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

typedef struct Queue
{
	int * pBase;
	int front;
	int rear;
}QUEUE;

void init(QUEUE *);
bool in_queue(QUEUE *, int);
bool out_queue(QUEUE *, int * pVal);
void traverse_quue(QUEUE *);
bool full_queue(QUEUE *);
bool empty_queue(QUEUE *);
 
int main(void)
{
	QUEUE Q;
	int val;
	init(&Q);

	in_queue(&Q, 1);
	in_queue(&Q, 2);
	in_queue(&Q, 3);
	in_queue(&Q, 4);
	in_queue(&Q, 5);
	

	traverse_quue(&Q);

	if (out_queue(&Q, &val))
	{
		printf_s("出队成功！出队元素为%d\n", val);
	}
	else
	{
		printf_s("出队失败。。。。");
	}
	system("pause");
	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 empty_queue(QUEUE *pQ)
{
	if (pQ->front == pQ->rear)
		return true;
	else
		return false;
}

bool in_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_quue(QUEUE * pQ)
{
	int i = pQ->front;

	while (i != pQ->rear)
	{
		printf_s("%d  ", pQ->pBase[i]);
		i = (i + 1) % 6;
	}

	return;
}

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;
	}
}