数据结构（栈的原理）

栈

栈是限制在一端进行插入操作和删除操作的线性表（俗称栈）
允许进行操作的一端成为栈顶，另一端称为栈底
当栈中没有元素时称为“空栈”，特点：后进先出

顺序栈
他是顺序表的一种，具有顺序表同样的存储结构，由数组定义，配合用数组下标表示的栈顶指针top（相对指针）完成各种操作。
typedef int data_t; //定义栈中数据元素的数据类型
typedef struct
{
data_t *data; //用指针指向栈的存储空间
int maxlen； //当前栈的最大元素个数
int top; //指示栈顶位置（数组下标）的下标
}sqtack; //顺序栈类型定义

sqstack.h

typedef int data_t ;
typedef struct{
	data_t *data;
	int maxlen;
	int top;
}sqstack;

sqstack *stack_create(int len);
int stack_push(sqstack *s ,data_t value);
int stack_empty(sqstack *s);
int stack_full(sqstack *s);
data_t stack_pop(sqstack *s);
data_t stack_top(sqstack *s);
int stack_clear(sqstack *s);
int stack_free(sqstack *s);

sqstack.c

#include<stdio.h>
#include<stdlib.h>
#include"sqstack.h"
sqstack *stack_create(int len)
{
	sqstack *s;
	if((s=(sqstack *)malloc(sizeof(sqstack)))==NULL){
		printf("malloc sqstack failed\n");
		return NULL;
	}
	if((s->data=(data_t *)malloc(len *sizeof(data_t)))==NULL){
			printf("malloc data failed\n");
			free(s);
			return  NULL;
		}
	memset(s->data,0,len*sizeof(data_t));
	s->maxlen=len;
	s-top=-1;
	return s;
}

int stack_push(sqstack *s,data_t value)
{
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
	}
if(s->top==s=>maxlen-1){
	printf("stack is full\n");
	return -1;
	}
	s->top++;
	s->data[s->top]=value;

	return 0;
}

int stack_empty(sqstack *s)
{
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
	}
	return(s->top==-1?1:0);
}


int stack_full(sqstack *s)
{
	if(s==NULL){
		printf("s is NULL\n");
		return  -1;
		}
	return (s->top==s->maxlen-1?1:0);
}

data_t stack_pop(sqstack *s)
{
	s->top--;
	return  (s->data[top+1]);

}

int stack_clear(sqstack *s)
{
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
		}
	s->top=-1;
	return 0;
}
int stack_free(sqstack *s)
{
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
	}
	if(s->data!=NULL){
		free(s->data);
		}
	free(s);
	return 0;
}

#include<stdio.h>
#include"sqstack.h"
int main(int argc,char *argv[])
{	
	sqstack *s;
	s=stack_create(100);
	if(s==NULL)
		return -1;

	stack_push(s,29);
	stack_push(s,33);
	stack_push(s,34);
	stack_push(s,56);
	
	while(!stack_empty(s){
		printf("pop :%d ",stack_pop(s));
	}
	stack_free(s);
	return 0;


}

链式栈
插入操作和删除操作均在链表头部进行，链表尾部就是栈底，栈顶指针就是头部。
typedef int data_t //定义栈中数据元素数据类型
typedef struct node_t{
data_t data; //数据域
struct node_t *next; //链表的指针域
}linkstack_t; //链栈类型定义

linkstack.h

typedef int data_t ;
typedef struct node{
	data_t data;
	struct node *next;
}listnode,*linkstack;

linkstack stack_create();
int stack_push(linkstack s,data_t value);
data_t stack_pop(linkstack s);
int stack_empty(linkstack s);
data_t stack_top(linkstack s);
linkstack stack_free(linkstack s);

linkstack.c
#include"linkstack.h"
linkstack stack_create()
{
	linkstack s;
	s=(linkstack)malloc(sizeof(listnode));
	if(s==NULL){
		printf("malloc failed\n");
		return NULL;
	}
	s->data=0;
	s->next=NULL;
	return s;
}
int stack_push(linkstack s,data_t value)
{
	linkstack p;
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
	}
	p=(linkstack)malloc(sizeof(listnode));
	if(p==NULL){
		printf("malloc failed\n");
		return  -1;
	}
	p->data=value;
	//p->next=NULL;

	p->next=s->next;
	s->next=p;
	
	return  0;
}
data_t stack_pop(linkstack s)
{
	linkstack p;
	data_t t;
	p=s->next;
	s->next=p->next;
	t=p->data;
	free(p);
	p=NULL;
	return t;
}
int stack_empty(linkstack s)
{
	if(s==NULL){
		printf("s is NULL\n");
		return -1;
	}
	return (s->next==NULL?1:0);
}
data_t stack_top(linkstack s)
{
	return (s->next->data);

}
linkstack stack_free(linkstack s)
{
	linkstack p;
	if(s==NULL){
		printf("s is NULL\n");
		return NULL;
	}
	while(s!=NULL){
		p=s;
		s=s->next;
		printf("free:%d\n",p->data);
		free(p);
	}
	return NULL;
}

test.c

#include<stdio.h>
#include<stdlib.h>
#include"linkstack.h"

int main(int argc,char *argv[])
{
	linkstack s;
	s=stack_create();
	if(s==NULL){
		return -1;
	
	stack_push(100);
	stack_push(22);
	stack_push(444);
	stack_push(42);

	while(!stack_empty(s)){
		printf("pop:%d\n",stack_pop(s));
	}
	return 0;
}