堆栈

堆栈(stack)
其特点是先进后出
堆栈是最容易实现的ADT之一，其基本操作通常称为push和pop，push操作是把一个新值压入到堆栈顶部，而pop操作是把堆栈顶部的值移出堆栈并返回这个值
1. 数组实现堆栈

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


#define STACK_SIZE 10   //堆栈中值数量的最大限制
#define STACK_TYPE int
#define size_t int


//static STACK_TYPE stack[STACK_SIZE]; //存储堆栈中值的数组
static STACK_TYPE *stack;            //指向存储堆栈元素空间的指针
static int top_element = -1;         //指向堆栈顶部元素的指针
static size_t stack_size;

void push(STACK_TYPE value);  		 //入栈
void pop(void);						 //出栈
STACK_TYPE top(void);				 //返回栈顶元素，但不对栈内元素修改
int stack_is_full(void);			 //检测堆栈是否已满，若已满返回TRUE，否则返回FALSE
int stack_is_empty(void);			 //检测堆栈是否为空栈，若栈为空则返回TRUE， 否则返回FALSE
void create_stack(size_t size);//创建堆栈
void destroy_stack(void);            //销毁堆栈


void create_stack(size_t size)
{
	assert(stack_size == 0);
	stack_size = size;
	stack = (STACK_TYPE *)malloc(stack_size * sizeof(STACK_TYPE));
	assert(stack != NULL);
}

void destroy_stack(void)
{
	assert(stack_size > 0);
	stack_size = 0;
	free(stack);
	stack = NULL;
	printf("destroy stack\n");
}


void push(STACK_TYPE value)
{
	assert(!stack_is_full());
	top_element++;
	stack[top_element] = value;
}
void pop(void)
{
	assert(!stack_is_empty());
	top_element--;
}

STACK_TYPE top(void)
{
	assert(!stack_is_empty());
	return stack[top_element];
}

int stack_is_empty(void)
{
	assert(stack_size > 0);
	return top_element == -1;
}
int stack_is_full(void)
{
	assert(stack_size > 0);
	return top_element == stack_size-1;
}
int main()
{
	int t;
	int i;
	create_stack(10);
	while((t=getchar())!= '\n')
	{
		if(stack_is_full())
		{
			printf("warning:stack overflow\n");
			break;
		}
		else
			push(t);
	}
	while(!stack_is_empty())
	{
		printf("stack value:%c\n",top());
		pop();
		
	}
	
	destroy_stack();
	return 0;
}

2. 链表实现堆栈
由于堆栈的特点，其只有是堆栈的顶部元素才可以被访问，所以我们可以使用单链表就可以实现链式堆栈，其中，我们把新元素压入堆栈中是通过在链表的起始位置添加一个元素实现的，而出栈是通过移除第一个元素实现的。在下面的程序中，我们是从上面的数组实现堆栈中改编的。

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


#define STACK_SIZE 10   //堆栈中值数量的最大限制
#define STACK_TYPE int
#define size_t int
#define FALSE 0

typedef struct stack_node{
	STACK_TYPE stack_value;
	struct stack_node *next;
}Stack_Node;


//static STACK_TYPE stack[STACK_SIZE]; //存储堆栈中值的数组
//static STACK_TYPE *stack;            //指向存储堆栈元素空间的指针
//static int top_element = -1;         //指向堆栈顶部元素的指针
static size_t stack_size;
Stack_Node *stack;                   //指向堆栈的栈顶元素的节点的指针




void push(STACK_TYPE value);  		 //入栈
void pop(void);						 //出栈
STACK_TYPE top(void);				 //返回栈顶元素，但不对栈内元素修改
int stack_is_full(void);			 //检测堆栈是否已满，若已满返回TRUE，否则返回FALSE
int stack_is_empty(void);			 //检测堆栈是否为空栈，若栈为空则返回TRUE， 否则返回FALSE
void create_stack(size_t size);//创建堆栈
void destroy_stack(void);            //销毁堆栈


void create_stack(size_t size)
{
}

void destroy_stack(void)
{
	while(!stack_is_empty())
		pop();
}


void push(STACK_TYPE value)
{
	Stack_Node *new_insert;
	new_insert = (Stack_Node *)malloc(sizeof(Stack_Node));
	assert(new_insert != NULL);
	new_insert->stack_value =value;
	new_insert->next = stack;
	stack = new_insert;
	
}
void pop(void)
{
	Stack_Node *pop_element;
	assert(!stack_is_empty());
	pop_element = stack;
	stack = pop_element->next;
	free(pop_element);	
}

STACK_TYPE top(void)
{
	assert(!stack_is_empty());
	return stack->stack_value;
}

int stack_is_empty(void)
{
	
	return stack == NULL;
}
int stack_is_full(void)         //由于堆栈是由链表实现的
{
	return FALSE;
}
int main()
{
	int t;
	int i;
	//create_stack(10);
	while((t=getchar())!= '\n')
	{
		if(stack_is_full())
		{
			printf("warning:stack overflow\n");
			break;
		}
		else
			push(t);
	}
	while(!stack_is_empty())
	{
		printf("stack value:%c\n",top());
		pop();
		
	}
	
	destroy_stack();
	return 0;
}