数据结构学习（C语言）之栈

（郝斌老师视频课）

简介：

30_栈的定义
31_栈的分类
32_栈可以执行哪些操作
33_ 栈程序演示
34_栈的日常具体应用

30_栈的定义

定义：
一种可以实现“先进后出”的存储结构
栈类似于箱子

31_栈的分类

分类：
静态栈
动态栈

32_栈可以执行哪些操作

算法：
出栈
压栈

# include 
# include 

void f(int k)
{
	int m;

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

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

	return 0;
}
//m q i p都是在栈中分配的（静态）
//100  200都是在堆中分配的（动态）
//静态的或局部变量分配在栈中分配，动态分配在堆中分配
//栈中的变量由计算机分配，动态由程序员分配并且需要手动释放

33_栈程序演示

动态栈中的元素和链表中的一样，一个节点Node有一个数据域和一个指针域。对于栈来说，重要的就是栈顶和栈底了，所以在定义栈的时候只需要栈顶和栈底。

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

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;    //pTop  pBottom都是指针变量，指向的是节点。因为pTop是栈顶，其元素也包含两部分数据和指针。
}STACK,*PSTACK;//PSTACK等价于struct STACK*

但是此时并没有分配内存。主函数中STACK S，此时为一个栈分配了内存。也就是计算机给S分配了两个内存，一个存放 pTop，一个存放pBottom，但是内存里面的数字是垃圾数字。

int main(void)
{
	STACK S;  //STACK 等价于 struct Stack  
	
return 0;
}

1、初始化栈
STACK S;创建了一个栈，但是栈中的都是垃圾数字，所以首先需要初始化，初始化的目的是造出一个空栈，也就是栈顶和栈顶都指向相同的地址，指针域为空。

void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));//比如说一个节点占8个字节，malloc(sizeof(NODE)表示8个字节中的第一个字节的地址
	//前面加上(PNODE)，表示转换为PNODE型的地址，把第一个字节的地址转化为8个字节个数的地址，
	//这样计算机就会明白pS->pTop就指向了第一个的8个字节，pS->pTop+1就指向了第2个的8个字节
	
	//PNODE定义的变量，是一个地址，其实是首地址（只占4个字节），它暗自是指的是占有8个字节，只是操作时传值值传递首地址，但是操作实际上是操作包括收地址在内的8个字节
	if (NULL == pS->pTop)
	{
		printf("动态内存分配失败!\n");
		exit(-1);
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL; //pS->Bottom->pNext = NULL;
	}
}

2、进栈、压栈
向栈顶放入一个元素。


首先要动态产生一个新的节点；
使新的节点的指针指向前一个节点（原来的栈顶），把值传给新节点的数据域；
栈顶指向新的节点。

void push(PSTACK pS, int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE)); //产生新的节点
	
	pNew->data = val;//把传入的值给新的节点数据域
	pNew->pNext = pS->pTop; //pS->Top不能改成pS->Bottom，图1  //新节点指向刚才的栈顶
	pS->pTop = pNew;  //栈顶指向新节点

	return;
}

3、遍历输出栈中元素
循环从栈顶输出节点的数据域中的值，直到栈顶等于栈底，不再输出。

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

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

	return;
}

4、出栈
出栈就是把栈顶这一节点释放，然后让pTop指向刚才栈顶的下一个节点。需注意为了防止内存泄露，一定要先定义一个临时变量存放以前的栈顶，然后pTop指向原来节点的下一个节点以后，释放临时变量存放的栈顶，不然直接 pTop指向原来节点，会导致我们无法再找到原来的栈顶，导致内存泄露。

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

5、清空栈
定义一个临时变量，让临时变量循环等于栈顶，循环释放这个临时变量，也就释放了栈顶。但是需要注意的是：需要定义两个指针才可以，否则你循环释放的时候，p循环指向栈顶，释放了p，就找不到p的下一个节点了了，所以还需要一个q，不断存储p的下一个节点。
同样，你也不能直接让pTop指向pBottom，因为这样做会导致内存泄露。同上分析。

//clear清空
void clear(PSTACK pS)
{
	if (empty(pS))
	{
		return;
	}
	else
	{
//定义两个指针才可以，否则你循环释放的时候，释放了p，就找不到p的下一个节点了了，所以还需要一个q
		PNODE p = pS->pTop;
		PNODE q = NULL;

		while (p != pS->pBottom)
		{
			q = p->pNext;
			free(p);
			p = q;//p指向了p的下一个节点
		}
		pS->pTop = pS->pBottom;  //p=pBottom.循环停止，这回就可以把pTop指向pBottom，前面的内存已经释放了，不会导致内存泄露了。
	}
}

6、测试代码

#include
#include
#include

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 *);
bool empty(PSTACK);
void clear(PSTACK);


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);//目的是便于输出
	if (pop(&S, &val))
	{
		printf("出栈成功，出栈的元素是%d\n", val);
	}
	else
	{
		printf("出栈失败！");
	}
	traverse(&S);//目的是便于输出
	clear(&S);
	traverse(&S);//目的是便于输出
	if (pop(&S, &val))
	{
		printf("出栈成功，出栈的元素是%d\n", val);
	}
	else
	{
		printf("出栈失败！");
	}
	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->pBottom->pNext=NULL;
	}

}

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

}

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))//pS本身存放的就是S的地址
	{
		return;
	}
	else
	{
		PNODE p = pS->pTop;
		PNODE q = NULL;
		while (p != pS->pBottom)
		{
			q = p->pNext;
			free(p);
			p = q;
		}
		pS->pTop = pS->pBottom;
	}
}

34_栈的日常具体应用

应用
函数调用
中断
表达式求值：https://www.jianshu.com/p/29c7e5b0f448
内存分配
缓冲处理
迷宫