栈

变量的分配方式

	int t = 10;//这是静态分配，从栈中分配

int t;
t=(int)malloc(sizeof(int));//这是动态分配，从堆中分配

栈的分类

静态栈

先进后出的数组

动态栈

先进后出的链表（头删头插）

代码

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

void init(PSTACK s);
void push(PSTACK s,int val);
void traverse(PSTACK s);
void pop(PSTACK s, int * pval);
bool clear(PSTACK s);
int main(void)
{
	STACK S;
	int val;
	init(&S);
	push(&S,6);
	push(&S, 4);
	push(&S, 9);
	push(&S, 3);
	push(&S, 6);
	push(&S, 4);
	traverse(&S);
	pop(&S, &val);
	printf("删除的值是：%d\n", val);
	traverse(&S);
	if (clear(&S))
	{
		printf("已清空\n");
	}
	traverse(&S);
	return 0;
}

void init(PSTACK s)
{
	s->pTop = (PNODE)malloc(sizeof(NODE));
	s->pTop->pNext = NULL;
	s->pBottom = s->pTop;
}
void push(PSTACK s, int val)
{
	PNODE p= (PNODE)malloc(sizeof(NODE));
	p->data = val;
	p->pNext = s->pTop;
	s->pTop = p;
}
void traverse(PSTACK s)
{
	PNODE p = s->pTop;
	while (p!=s->pBottom)
	{
		printf("%d\n", p->data);
		p = p->pNext;
	}
}
bool is_empty(PSTACK s)
{
	if (s->pTop == s->pBottom)
	{
		return true;
	}
	return false;
}
void pop(PSTACK s, int * pval)
{
	if (is_empty(s))
	{
		printf("栈为空,无法删除\n");
		return;
	}
	PNODE r = s->pTop;
	*pval = s->pTop->data;
	s->pTop = r->pNext;
	free(r);
	r = NULL;
	return;
}
bool clear(PSTACK s)
{
	if (is_empty(s))
	{
		printf("栈为空，无法清空");
		return true;
	}
	else
	{
		PNODE p = s->pTop;
		PNODE r = NULL;
		while (p != s->pBottom)
		{
			r = p->pNext;
			free(p);
			p = r;
		}
		s->pTop = s->pBottom;
		return true;
	}
	return false;
}