【数据结构与算法】线性结构的应用：栈、队列

线性结构的两种常见应用之一  栈
    定义
        一种可以实现“先进后出”的存储结构
        栈类似于箱子
    分类
        静态栈
        动态栈
            
    算法
        出栈
        入栈

    应用
        函数调用
        中断
        表达式求值
        内存分配
        缓存处理
        迷宫

//栈
#include
#include
#include

typedef struct Node
{
	int data;
	struct Node *pNext;
}NODE,*PNODE;

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK,*PSTACK;//PASTCK等价于struct STACK*

void init(PSTACK);
void push(PSTACK,int );
void traverse(PSTACK);
bool pop(PSTACK,int *);
void clear(PSTACK pS);


int main(void)
{
	STACK S;//STACK 等价于struct Stack
	int val;

	init(&S);//目的是造出一个空栈
	push(&S,1);//入栈
	push(&S,2);
	push(&S,3);
	push(&S,4);
	push(&S,5);
	push(&S,6);
	traverse(&S);//遍历输出

	clear(&S);//清除
	traverse(&S);//遍历输出


	if(pop(&S,&val))
	{
		printf("出栈成功，出栈的元素是%d\n",val);
	}
	else
	{
		printf("出栈失败！\n");
	}
	traverse(&S);//遍历输出

	return 0;

}

void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(NULL == pS->pTop)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL;//pS->Bottom->pNext = NULL
	}
	
}

void push(PSTACK pS,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	pNew->data = val;
	pNew->pNext = pS->pTop;//pS->pTop不能改为pS->Bottom
	pS->pTop = pNew;

	return;
}

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;

	while(p!= pS->pBottom)
	{
		printf("%d ",p->data);
		p=p->pNext;
	}
	printf("\n");

	return;
}

bool empty(PSTACK pS)
{
	if(pS->pTop == pS->pBottom)
		return true;
	else
		return false;
}

//把pS所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中，如果出栈失败返回false，否则返回true。
bool pop(PSTACK pS,int *pVal)
{
	if(empty(pS))//pS本身存放的就是S的地址
	{
		return false;
	}
	else
	{
		PNODE r = pS->pTop;
		*pVal = r->data;
		pS->pTop = r->pNext;
		free(r);
		r = NULL;

		return true;
	}
}

//clear清空
void clear(PSTACK pS)
{
	if(empty(pS))
	{
		return;
	}
	else
	{
		PNODE p = pS->pTop;
		PNODE q = p->pNext;

		while(p!=pS->pBottom)
		{
			q=p->pNext;
			free(p);
			p=q;
		}
		pS->pTop = pS->pBottom;
	}
	
}

线性结构的两种常见应用之二  队列

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

分类：
    链式队列--用链表实现
    
    静态队列--用数组实现
        静态队列通常都必须是循环队列

        循环队列的讲解：
        1.静态队列为什么必须是循环队列
        2.循环队列需要几个参数来确定
            两个参数  front
                  rear
        3.循环队列各个参数的含义
            不同场合有不同含义
            1）队列初始化
                front 和rear的值都是零
            2）队列非空
                front代表的是队列的第一个元素
                rear代表的是队列的最后一个有效元素的下一个元素
            3）队列空
                front和rear的值相等，但不一定是零
        4.循环队列入队伪算法讲解
            两步完成：
            1）将值存入r所代表的位置
            2）错误的写法rear=rear+1;
               正确的写法是：rear=(rear+1)%数组的长度
        5.循环队列出队伪算法讲解
            front=（front+1）%数组的长度
        6.如何判断循环队列是否为空
            如果front与rear的值相等，则该队列就一定为空
        7.如何判断循环队列是否已满
            1）多增加一个表标识参数
            2）少用一个元素

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

队列的算法：
        入队
    出队

#include
#include

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

void init(QUEUE *);
bool en_queue(QUEUE *,int val);//入队
void traverse_queue(QUEUE *);
bool full_queue(QUEUE *);
bool emput_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);
	en_queue(&Q,7);
	en_queue(&Q,8);

	traverse_queue(&Q);
	if(out_queue(&Q,&Val))
	{
		printf("出队成功，队列出队的元素是：%d\n",Val);

	}
	else
	{
		printf("出队失败！\n");
	}

		traverse_queue(&Q);
	return 0;
}

void init(QUEUE *pQ)
{
	pQ->pBase = (int *)malloc(sizeof(int) *6);
	pQ->front = 0;
	pQ->rear = 0;

}

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

bool full_queue(QUEUE * pQ)
{
	if((pQ->rear+1)%6 == pQ->front)
		return true;
	else
		return false;
}

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 emput_queue(QUEUE *pQ)
{
	if(pQ->front == pQ->rear)
		return true;
	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;
	}
}

    递归

  //递归
//不同函数之间的调用

#include
void f();
void g();
void k();

void f()
{printf("fff\n");g();}

void g()
{printf("ggg\n");k();}

void k()
{printf("kkk\n");}

int main()
{f();  return 0;}
//函数自己调用自己


//阶乘的循环使用

#include
int main(void)
{
	int val;
	int i,mult=1;

	printf("请输入一个数字：");
	printf("val = ");
	scanf("%d",&val);

	for(i=1;i<=val;i++)
		mult = mult*i;

	printf("%d的阶乘是：%d\n",val,mult);

	return 0;
}

#include
//假定n的值是1或大于1的值
long f(long n)
{
	if(1 ==n)
		return 1;
	else
		return f(n-1)*n;
}

int main(void)
{
	printf("%d\n",f(100));

	return 0;
}