数据结构(五)

接着队列，下面是队列的代码实现：

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

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

void init(QUEUE *);//初始化
bool full_queue(QUEUE *);//判断是否满
bool en_queue(QUEUE *,int val);//入队
void traverse_queue(QUEUE *);//遍历
bool empty_queue(QUEUE *);//判断是否为空
bool out_queue(QUEUE *,int * val);//出队

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);
	en_queue(&Q,7);
	en_queue(&Q,8);
	printf("****入队后****\n");
	traverse_queue(&Q);
	if(full_queue(&Q))
	{
		printf("**队列已满**\n");
	}
	if(empty_queue(&Q))
	{
		printf("*****队列为空*****\n");
	}
	printf("****出队后****\n");
	out_queue(&Q,&val);
	printf("****出队的数是：%d\n",val);
    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 * val)
{
	if(empty_queue(pQ))
	{
		return false;
	}
	else
	{
		* val=pQ->pBase[pQ->front];
		pQ->front=(pQ->front+1)%6;
		return true;
	}
}

队列的具体应用：所有和时间有关操作都有队列的影子。

 

递归：一个函数直接或间接调用自己。

先来体验一下：

#include<stdio.h>

void f();
void g();
void k();

void f()
{
	printf("ffffff\n");
	g();
	printf("111111\n");
}
void g()
{
	printf("gggggg\n");
	k();
	printf("222222\n");
}
void k()
{
	printf("kkkkkk\n");
}

int main(void)
{
	f();
	return 0;
}

说明一下：主函数先执行，发现是f函数，于是找到f函数，执行f函数，打印出ffffff，再执行下一句g函数，于是到g函数打印出gggggg，再往下是k函数，于是跳到k函数打印出kkkkkk，k函数执行完毕后，k函数返回给被调用函数g，g再执行下一句，打印出222222.g函数执行完毕后，返回给调用g函数的f函数，f再执行下一句打印出111111，f执行后，返回给调用f的主函数，程序完毕。

可见，递归函数在内存中的存储是栈的形式。