栈

      栈（Stack），是限定仅在表尾进行插入或删除操作的线性表。因此对栈来说，表尾端有其特殊含义，称为栈顶，相应的表头  端称为栈尾。栈又称为先进后出的线性表。栈的结构如下图所示

//不定长顺序栈
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define INITSIZE 10
typedef struct DStack
{
	int *elem;//存储栈数据
	int  top;//栈顶指针，当前可以存放数据的下标
	int stacksize;//栈的总容量
}DStack,*PDStack;
void InitStack(PDStack ps)//栈初始化
{
	assert(ps != NULL);
	if(ps == NULL)
	{
		return ;

	}
	ps->elem=(int *)malloc(INITSIZE*sizeof(int));
	ps->top=0;//当前可以存放数据的下标
	ps->stacksize = INITSIZE;
}
static bool IsFull(PDStack ps)
{
	return ps->top == ps->stacksize;//当前可以存放数据的下标等于栈的总容量
}
//将总容量扩大二倍
void Inc(PDStack ps)
{
	ps->elem = (int *)realloc(ps->elem,2*ps->stacksize*sizeof(int));
	ps->stacksize *= 2;
}
//入栈
bool Push(PDStack ps,int val)
{
	if(IsFull(ps))
	{
		Inc(ps);
	}
	ps->elem[ps->top]=val;
	ps->top++;
	return true;
}
bool IsEmpty(PDStack ps)
{
	return ps->top == 0;
}
//获取栈顶的值，但不删除栈顶元素
bool GetTop(PDStack ps,int *rtval)
{
	if(IsEmpty(ps))
	{
		return false;

	}
	if(rtval != NULL)
	{
		*rtval = ps->elem[ps->top-1];
	}
	return true;
}
//出栈，获取栈顶的值，且删除栈顶元素
bool Pop(PDStack ps, int *rtval)
{
	if(IsEmpty(ps))
	{
		return false;
	}
	if(rtval != NULL)
	{
		*rtval= ps->elem[--ps->top];
	}
	return true;
}
void Clear(PDStack ps)
{
	ps->top = 0;
}
void Destory(PDStack ps)
{
	free(ps->elem);
	ps->elem = NULL;
	ps->top=0;
	ps->stacksize = 0;
}
int main()
{
	DStack ds;
	InitStack(&ds);
	int tmp;

	for(int i=0;i<20;i++)
	{
		Push(&ds,i);
	}
	while(!IsEmpty(&ds))
	{
		Pop(&ds,&tmp);
		printf("%d\n",tmp);
	}
	Destory(&ds);


	return 0;
}

链栈，栈顶在第一个数据元素，入栈时是头插

//带头结点的链栈，栈顶在第一个数据节点，入栈和出栈都是O(1)
//链栈头插
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef struct LNode
{
	int data;
	//struct LNode *top;//不需要栈顶指针总是第一个数据节点
	struct LNode *next;
}LNode ,*PLStack;

void InitStack(PLStack ps)
{

	assert(ps!=NULL);

	ps->next = NULL;
}
//入栈
bool Push(PLStack ps,int val)
{
	LNode *p=(LNode *)malloc(sizeof(LNode));
	p->data = val;

	p->next = ps->next;
	ps->next = p;

	return true;
}
bool IsEmpty(PLStack ps)
	{
		return ps->next == NULL;
	}
//出栈，获取栈顶的值，且删除栈顶元素
bool Pop(PLStack ps,int *rtval)
{
	if(IsEmpty(ps))
	{
		return false;
	}
	if(rtval != NULL)
	{
		LNode *p=ps->next;
		*rtval = p->data;
		ps->next=p->next;
		free(p);
	}
	return true;
}
//获取栈顶的值，但不删除栈顶元素
	bool GetTop(PLStack ps,int *rtval)
	{
		if(IsEmpty(ps))
		{
			return false;
		}
		if(rtval !=NULL)
		{
			*rtval = ps->next->data;
		}

		return true;
	}
	void Destroy(PLStack ps)
	{
		LNode *p;
		while(ps->next!=NULL )
		{
			p=ps->next;
			ps->next=p->next;
			free(p);
		}
	}
	int main()
	{
		LNode ps;
		InitStack (&ps);
		int tmp;
		int i;
		for(i=0;i<20;i++)
		{
			Push(&ps,i);
			printf("%d ",i);
		}
		printf("\n");
	
		while(!IsEmpty(&ps))
		{
			Pop(&ps,&tmp);
			
			printf("%d ",tmp);
		}
		GetTop(&ps,&tmp);
		printf("%d\n",tmp);
		Destroy(&ps);


		return 0;
	}