栈的基本操作

<span style="font-size:24px;">一、栈是一种先进后出的数据结构，有两种方式进行实现：数组和链表。用数组实现，好处是不用指针操作，但是栈的大小是固定的，入栈是需要判断栈满，出栈时需要判断栈空。栈顶指针指向最后压入栈的数据（即每次入栈的时候我的栈顶指针先要+1，之后在进行压栈操作）。</span>

<span style="font-size:24px;">数据结构中应该体现数据（数组存储），栈顶（记录数组下标）。基本操作包括：初始化栈、判空、判满、压栈、出栈、清空栈、摧毁栈。用链表实现的好处是栈的大小可以扩展，不用提前声明。使用指针和链表形式，更为复杂。栈顶指针指向压入栈的最后数据。入栈的时候，动态申请一个链栈节点。数据结构中当定义链表中的节点，并且有指向该链表的栈顶指针和栈底指针。栈底一、栈是一种先进后出的数据结构，有两种方式进行实现：数组和链表。用数组实现，好处是不用指针操作，但是栈的大小是固定的，入栈是需要判断栈满，出栈时需要判断栈空。栈顶指针指向最后压入栈的数据（即每次入栈的时候我的栈顶指针先要+1，之后在进行压栈操作）。		数据结构中应该体现数据（数组存储），栈顶（记录数组下标）。基本操作包括：初始化栈、判空、判满、压栈、出栈、清空栈、摧毁栈。用链表实现的好处是栈的大小可以扩展，不用提前声明。使用指针和链表形式，更为复杂。栈顶指针指向压入栈的最后数据。入栈的时候，动态申请一个链栈节点。数据结构中当定义链表中的节点，并且有指向该链表的栈顶指针和栈底指针。栈底指针指向NULL（其实我觉得不用也行）。基本操作：初始化链栈、判空、压栈、出栈。二、实现代码指针指向NULL（其实我觉得不用也行）。基本操作：初始化链栈、判空、压栈、</span>

<span style="font-size:24px;">出栈。二、实现代码</span>

1、数组形式实现的栈</strong></span></p><p><span style="font-size:24px;"><strong></strong></span><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 *   init_stack
 *   in_stack
 *   out_stack
 *   full_stack
 *   empty_stack
 * */


#define	SIZE	4	

struct stack{
	int sta[SIZE];
	int top;
};

void init_stack(struct stack * s)
{
	memset(s->sta, 0, sizeof(s->sta));
	s->top = -1;
}
int if_full(struct stack* s)
{
	if(s->top == SIZE-1){
		printf("stack is full. \n");
		return -1;
	}
	else 
		return 0;
}
int in_stack(struct stack* s, int data)
{
	if(!(if_full(s))){
		(s->top)++;
		s->sta[s->top] = data;
		return 0;
	}
	else 
		return -1;
}
int if_empty(struct stack* s)
{
	if(s->top == -1){
		printf("stack if empty. \n");
		return -1;
	}
	else 
		return 0;
}
int out_stack(struct stack * s)
{
	if(!(if_empty(s))){
		int tmp = s->sta[s->top];
		(s->top)--;
		return tmp;
	}
	else 
		return 0;
}
int main()
{
	struct stack S;
	init_stack(&S);
	int data = 38;
	
#if 0	
	in_stack(&S, 10);
	//in_stack(&S, 30);
	//in_stack(&S, 20);
	//in_stack(&S, 1);
	int ret = in_stack(&S, 13);
	if(ret < 0){
		exit(1);
	}
	ret = out_stack(&S);
	ret = out_stack(&S);
	printf("ret: %d\n", ret);
	ret = out_stack(&S);
	if(ret == 0){
		exit(1);
	}
	printf("ret: %d\n", ret);
#endif
	return 0;
}

动态申请空间的数组栈

/*-------------2016.11.6--------------*/
/*----------public by 于全------------*/
/*-----------栈的操作----------------
 * ---------1、创建栈-----------------
 *----------2、释放栈-----------------
 *----------3、清空栈----------------
 *----------4、判空、判满------------
 *----------5、压栈、出栈-----------
 *----------6、取栈顶元素------------
 *出现的问题：主函数 传递stack 为一个指针
 需要二级指针接收才能修改内容。所以在creat函数里
 定义一个stack，返回。--------------*/


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


#define EmptyTOS -1
#define MinStackSize 2
typedef struct StackRecord
{
	int Capacity;
	int TopOfStack;
	int *Array;
}StackRecord,*Stack;

//创建栈
Stack CreatStack (int);

//释放栈
void DestoryStack(Stack);

//判空
int IsEmpty(Stack);

//清空栈
void MakeEmpty(Stack);

//判满
int IsFull(Stack);

//压栈
void Push(int , Stack);

//打印栈
void ShowStack(Stack);

//弹出第一个数 取头元素
int Top(Stack);

//出栈
int Pop(Stack);

int main()
{
	Stack stack;
	stack = CreatStack(5);
	Push(2,stack);
	Push(3,stack);
	Push(4,stack);
	Push(5,stack);
	ShowStack(stack);
	Pop(stack);
	ShowStack(stack);

}
Stack CreatStack(int MaxElements)
{
	Stack stack;
	if(MaxElements < MinStackSize)
	{
		printf("stack size is too small \n");
	}
#if 1
	stack = (Stack)malloc(sizeof(StackRecord));
	if(stack ==NULL)
		return ;
#endif
	stack->Array = (int *)malloc(sizeof(int)*MaxElements);
	if(stack->Array== NULL)
		return ;
	stack->Capacity = MaxElements;
	stack->TopOfStack = -1;
	return stack;
}
void DestoryStack(Stack stack)
{
	if(stack != NULL)
	{
		free(stack->Array);
		free(stack);
	}
}
int IsEmpty(Stack stack)
{
	return stack->TopOfStack == EmptyTOS;
}
void MakeEmpty(Stack stack)
{
	stack->TopOfStack = EmptyTOS;
}
int IsFull(Stack stack)
{
	if(stack->TopOfStack >= stack->Capacity)
	{
		return -1;
	}
	else
		return 0;
}	 
void Push(int x,Stack stack)
{
	if(IsFull(stack))
	{
		printf("stack is full . \n");
	}
	else
	{
		stack->TopOfStack++;
		stack->Array[stack->TopOfStack] = x;
	}
}
int Top(Stack stack)
{
	if(IsEmpty(stack))
	{
		printf("stack is empty . \n");
		return 0;
	}
	else
	{
		return stack->Array[stack->TopOfStack];
	}
}
int Pop(Stack stack)
{
	if(IsEmpty(stack))
	{
		printf("stack is empty \n");
		return 0;
	}
	else
	{
		stack->TopOfStack--;
		
	}
}
void ShowStack(Stack stack)
{
	int i;
	for(i = 0 ;i<=stack->TopOfStack;i++)
	{
		printf("%d",stack->Array[i]);
	}
	printf("\n");
}

2、链栈

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

struct sta_node{
	int data;
	struct sta_node* next;
};
struct link_sta{
	struct sta_node* top;
	struct sta_node* buttom;
}; 

int init_link_sta(struct link_sta* ls)
{
	ls->top = NULL;
	ls->buttom = NULL;
}
void in_link_sta(struct link_sta* ls, int value)
{
	struct sta_node* tmp = malloc(sizeof(struct sta_node));
	tmp->data = value;
	tmp->next = NULL;

	if(ls->top == NULL){
		ls->top = tmp;
		tmp->next = ls->buttom; 
	}
	else{
		tmp->next = ls->top;
		ls->top = tmp;
	}
}
struct sta_node* if_empty(struct link_sta* ls)
{
	if(ls->top == ls->buttom){
		printf("stack is empty. \n");
		return NULL;
	}
}
struct sta_node* out_link_sta(struct link_sta* ls)
{
	if(!(if_empty(ls)))
		return NULL;
	else {
		struct sta_node* tmp = ls->top;
		ls->top = (ls->top)->next;
		tmp->next = NULL;

		return tmp;	
	}
}
int main()
{
	struct link_sta LS;
	init_link_sta(&LS);	
	
	in_link_sta(&LS, 10);
	in_link_sta(&LS, 12);

	struct sta_node* value = out_link_sta(&LS);
//	value = out_link_sta(&LS);
//	value = out_link_sta(&LS);
//	value = out_link_sta(&LS);
	if(value == NULL){
		exit(1);
	}
	printf("value: %d\n", value->data);

	return 0;
}