您的位置：首页 > 理论基础 > 数据结构算法

数据结构与算法（4）--队列

2015-11-25 23:11 274 查看

队列

线性结构的两种应用：栈和堆

栈和堆表示的是分配内存的方式不同

静态是以出栈压栈的方式分配内存的

动态内存是以一种堆排序的方式分配内存的

静态内存在栈中分配，动态内存在堆中分配（如double *q=(double *) malloc（200）)

(q是静态分配的，在栈里分配的；200字节是动态分配的，是在堆里分配的）。

在栈里分配的是系统自动帮忙分配的，在堆里分配的是程序员手动分配的

栈定义：

一种可以实现“先进后出”的存储结构（凡是满足这一特点的就是栈存储）

分类：

静态栈

动态栈

算法：

压栈

出栈

应用：

函数调用

中断

表达式求职

内存分配

缓冲处理

迷宫

队列定义：一种可以实现“先进先出”的存储结构

分类：链式队列（用链表实现）

静态队列（用数组实现）静态队列通常都必须是循环队列

循环队列的讲解：

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

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

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

（1）队列初始化

font个rear的值都是零

（2）队列非空

font代表的是队列的第一个元素

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

（3）font和rear的值相等，但不一定是零

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

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

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

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

预备知识：

front的值可能比rear大

front的值可能比rear小

front的值也可能与rear相等

判断方法：

(1)、多用一个标识参数

(2)、少用一个元素空间（队列满的条件：（rear+1）%QueueSize==front）

8、通用的计算队列长度公式为：（rear-front+QueueSize）%QueueSize

入队（r 向后移一个）伪算法：

(1)、将值存入r所代表的位置

(2)、正确写法：r=（r+1）%数组的长度

错误写法：r=r+1

#include<stdio.h>           /*以数组为内核，实现队列的基本功能*/
#include<malloc.h>
typedef	struct Queue
{
int * pBase;
int front;
int rear;
}QUEUE;
void init(QUEUE *);            //初始化
bool en_queue(QUEUE *,int val);//入队    QUEUE * ：往哪个队列放入，val:放入的值
void traverse_queue(QUEUE *);  //遍历队列
bool full_queue(QUEUE * pQ);
bool out_queue(QUEUE * pQ,int * pVal);   //元素出队

int main(){
QUEUE Q;
init(&Q);
int val;
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("出队成功，出队的元素是：%d\n",val);
}
else{
printf(" 出队失败");
}
return 0;
}

void init(QUEUE *pQ){
pQ->pBase=(int *)malloc (sizeof(int )* 6); //先创建一个数组，将pBase当做数组的首地址
pQ->front=0;
pQ->rear=0;
}

bool en_queue(QUEUE * pQ,int val){
if(full_queue(pQ)==true){
return false;
}
else{
pQ->pBase[pQ->rear ]=val;
pQ->rear=(pQ->rear+1)%6;    //pQ->rear在队列中的位置
return true;
}
}

bool full_queue(QUEUE * pQ){
if(((pQ->rear)+1)%6==pQ->front){
printf(" 已满\n");
return true;
}
else{
printf(" 未满\n");
return false;
}
}

void traverse_queue(QUEUE * pQ){
int i=pQ->front;
while(i!=pQ->rear){
printf("%d\n",pQ->pBase[i]);
i++;
i=(i+6)%6;
}
}

bool emput_queue(QUEUE * pQ){
if(pQ->front==pQ->rear){
return false;
}
else{
return false;
}
}

bool out_queue(QUEUE * pQ,int * pVal){
if(emput_queue(pQ)){
return false;
}
else{
*pVal=pQ->pBase[pQ->front];
pQ->front=(pQ->front+1)%6;
return true;
}
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航