自主编程实现栈和链式栈

         栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端

被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元

素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素

成为新的栈顶元素。

         栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数

据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个

读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

  

       

       下面是普通栈的操作代码：

#include <stdio.h>

#define STACK_SIZE 100
#define OK       0
#define ERROR    -1

typedef int dataType ;
typedef struct
{
	dataType data[STACK_SIZE] ;    //栈数组
	int top ;   //栈顶下表
}SeqStack ;

//置空栈
int InitStack(SeqStack * stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	stack->top = -1 ;   //栈顶下标为-1，即栈为空
	return OK ;
}

//判断空栈
int StackEmpty(SeqStack * stack)
{
    if(stack == NULL)
	{
		return  ERROR ;
	}
    int nTemp = (stack->top == -1 ? 1 : 0 );
    return nTemp ; 	
} 

//判断满栈
int Stackfull(SeqStack * stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	int temp = (stack->top == STACK_SIZE ? 1 : 0) ;
	return temp ;
}

//数据入栈
int Pushdata(SeqStack*stack,dataType mydata)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	if(Stackfull(stack) == 1)
	{
		return ERROR ;
	}
	stack->data[++(stack->top)] = mydata ;

	return OK ;
}

//出栈
int Pop(SeqStack*stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	//判断空栈
	if(StackEmpty(stack) == 1)
	{
		return ERROR ;
	}
	
	dataType mydata = stack->data[stack->top] ;
	(stack->top)-- ;
	return mydata ;
}

//获取栈顶元素
int Gettop(SeqStack *stack)
{
	 if(stack == NULL)
	 {
		 return NULL ;
	 }
	 
	 //判断是否为空栈
	 if(StackEmpty(stack) == 1)
	 {
		 return ERROR ; 
	 }
	 
	 return stack->data[stack->top] ;
		 
}



int main()
{
	SeqStack stack ;   //结构体对象
	if(InitStack(&stack) != OK)
	{
		return -1 ;
	}
	
	if(StackEmpty(&stack) == 1)
	{
		printf("是空栈\n") ;
	}
	else
	{
		printf("不是空栈\n") ;
	}
	
	//数据入栈
	int i ;
	for(i=0;i<10;i++)
	{
		if(Pushdata(&stack,i)!= OK)
		{
			return -1 ;
		}
	}
	
	if(Stackfull(&stack) == 1)
	{
		printf("为满栈\n") ;
	}
	else
	{
		printf("不为满栈\n") ;
	}
	
	for(i=0;i<10;i++)
	{
		printf("%4d",Pop(&stack)) ;
	}
	
	if(StackEmpty(&stack) == 1)
	{
		printf("是空栈\n") ;
	}
	else
	{
		printf("不是空栈\n") ;
	}
	
	return 0 ;
}

          链式栈的操作代码：

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

#define    OK       0 
#define    ERROR   -1
#define    MALL0C_ERROR  -2		

typedef int dataType ;
typedef struct node 
{
	dataType data ;   //数据域
	struct node *next ;
}Node ;

typedef Node * pNode ;

typedef struct
{
	pNode top ;   //栈顶指针
}LinkStack ;


//置空栈
int InitStack(LinkStack * stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	stack->top == NULL ;   //栈顶为空
	
	return OK ;	
}

//判断空栈
int StackEmpty(LinkStack *stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	
	int temp = (stack->top = NULL?1:0);

	return temp ;
}

//数据入栈
int Pushdata(LinkStack *stack,dataType mydata)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	pNode node = (pNode)malloc(sizeof(Node)/sizeof(char)) ;
	if(node == NULL)
	{
		return MALL0C_ERROR ;
	}
	 
	node->data = mydata ;
	node->next = stack->top ;
	stack->top = node ;
	
	return OK ;
}

//数据出栈
int Popdata(LinkStack *stack)
{
	if(stack == NULL)
	{
		return ERROR ;
	}
	pNode p = stack->top ; 
	int mydata = p->data ;
	
	stack->top = p->next ;
	free(p) ;
	
	return mydata ;
}

//获取栈顶元素
int GetTop(LinkStack *stack)
{
	 if(stack == NULL)
	 {
		 return ERROR ;
	 }
	 return stack->top->data ;
}
	

int main()
{
	LinkStack lstack ;   //定义链式栈对象
	if(InitStack(&lstack) != OK )
	{
		return -1 ;
	}
	
	if(StackEmpty(&lstack) == 1)
	{
		printf("是空栈\n") ;
	}
	else
	{
		printf("不是空栈\n") ;
	}
	
	int i ;
	for(i=0;i<10;i++)
	{
		if(Pushdata(&lstack,i) != OK)
		{
			printf("%d 入栈失败！\n",i) ;
		}
	}
	
	for(i=0;i<10;i++)
	{
		printf("%4d",Popdata(&lstack)) ;
	}
	
	if(StackEmpty(&lstack) == 1)
	{
		printf("是空栈\n") ;
	}
	else
	{
		printf("不是空栈\n") ;
	}
	
	return 0 ;
}