线性结构常见应用之一——栈

定义：

栈是一种“先进后出”（后进先出）的存储结构，类似于一个装东西的箱子，即先装进去的后出来

实际上说，栈是操作受限的链表

分类：

静态栈

动态栈

以数组为基本内核的称为静态栈

下面举个例子

例1：

# include <stdio.h>
# include <malloc.h>
 
void f(int k)
{
	int m;

	double * q = (double *)malloc(200);
}

int main(void)
{
	int i = 10;
	int * p = (int *)malloc(100);

	return 0;
}

    这个程序没什么实际意义，举这么一个程序，仅仅是想说明一下，内存的分配问题

    在这个程序中，k、m、q、i、p还有那为q动态分配的200个字节的内存和为p动态分配的100个字节的内存，计算机为它们都分配了内存，所不同的是，为k、m、q、i、p这些静态变量分配的内存是在栈中分配的，而为那动态分配的200个和100个字节的内存是在堆中分配的

总结起来：

局部变量所占内存是在栈里边分配的

动态分配的内存是在堆里边分配的

栈和堆都表示内存分配的一种方式

还有就是

静态的或者说局部变量以压栈（入栈）和出栈的方式分配内存

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

算法：

出栈

压栈（入栈）

应用：

函数调用

中断

表达式求值

内存分配

缓冲处理

迷宫

再举一个例子

例2：

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

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

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK, * PSTACK;  //PSTACK 等价于 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->Top不能改成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 = NULL;

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

输出结果为：

在本程序的第11到第15行是定义了一个栈，其中有两个指针变量，一个指向栈的顶部，一个指向栈的底部。

第17到21行的函数分别表示初始化栈、压栈、遍历、判断栈是否成功输出、清空栈

第94到100行的函数是判断栈是否为空 

另外，如果把第37行代码前的 // 去掉，则栈为空，此时再次输出（遍历）栈，即把第38行代码前的 // 去掉，则输出结果为

出栈失败，是因为栈已经为空，无法输出，所以输出失败

【所有代码均在windows系统下C-Free5.0下运行通过】

（如有错误，敬请指正）