栈的顺序实现和链式实现

/*
链式栈：链式栈相比顺序栈可以动态的增加和减少栈的大小，可以更加高效的使用内存 。
        链式栈需要为每个元素申请一个指针节点，内存占用比较大。 
*/
#define FAILURE 0         //失败 
#define SUCCEED 1         //成功 
#define NO 0              //否 
#define YES 1             //是 

/* 修改本条代码以自定义栈数据类型 (默认为char型)*/
typedef char SDataType;
/* 修改本条代码以自定义栈数据类型 (默认为char型)*/
 

typedef struct _STACK //栈结构 
{
    SDataType Data;
    struct _STACK *next; 
}STACK;

int InitStack(STACK *S) //初始化栈
{
    S->next=NULL;
    return SUCCEED;
}

int DestroyStack(STACK * &S) //销毁栈(传入指针S的地址) 
{
  STACK *Mid_P;
  while(S)
  {
    Mid_P=S->next;
    free(S);
    S=Mid_P;
  }
  return SUCCEED;
}

int ClearStack(STACK *S) //将栈清空
{
  STACK *Mid_P,*Mid_P2=S->next;
  while(Mid_P2)
  {
     Mid_P=Mid_P2->next;
     free(Mid_P2);
     Mid_P2=Mid_P;    
  }    
  S->next=Mid_P2;
  return SUCCEED;
} 

int StackLength(STACK *S) //返回栈中的元素个数 
{
    int len=0;
    STACK *M_S=S;
    while(M_S->next)
    {
     len++;
     M_S=M_S->next;
    }
    return len;
}

int Push(STACK *S,SDataType Data) //将Data压人栈中 
{
    
    STACK *Mid_P=(STACK *)malloc(sizeof(STACK));
    if(!Mid_P) return FAILURE;
    Mid_P->Data=Data;
    Mid_P->next=S->next;
    S->next=Mid_P;
    return SUCCEED;
}

int Pop(STACK *S,SDataType &Data)  //栈头数据弹出栈 
{
    if(!S->next) return FAILURE;
    STACK *Mid_P=S->next;
    S->next=Mid_P->next;
    Data=Mid_P->Data;
    free(Mid_P);
    return SUCCEED;
}

int GetTop(STACK *S,SDataType &Data) //获取栈头元素 
{
    if(!S->next) return FAILURE;
    Data=S->next->Data;
    return SUCCEED;
}
 

 

 

 

/*
顺序栈：顺序栈相比链式栈，顺序栈可以动态的增加栈的大小，但是不可以根据当前需要适当减少栈的空间，所以如果系统某一时段栈中的数据非常大
        但是这个时期很短，这个时候顺序栈将一直以最大的空间占用内存，造成内存浪费。
        但是顺序栈易于理解，而且不需要为每个栈元素申请一个指针节点。 
*/ 
#define FAILURE 0         //失败 
#define SUCCEED 1         //成功 
#define NO 0              //否 
#define YES 1             //是 
#define STACK_INIT_SIZE 100 //栈初始大小 
#define STACK_SIZE_INCREMENT 10 //增量大小 

/* 修改本条代码以自定义栈数据类型 (默认为char型)*/
typedef char SDataType;
/* 修改本条代码以自定义栈数据类型 (默认为char型)*/

typedef struct Stack //栈结构 
{
    SDataType *top;
    SDataType *base;
    int STACK_SIZE;
}STACK;

/*栈操作函数声明*/
int InitStack(Stack *S); //初始化栈 
int DestroyStack(STACK *S); //销毁栈 
int StackLength(STACK *S); //返回栈中当前元素数量
int ClearStack(STACK *S); //清空栈 
int Push(Stack *S,SDataType SData); //数据压栈 
int StackEmpty(Stack *S); //判断栈是否为空 
int Pop(Stack *S,SDataType &SData); //栈头数据弹出栈 
int GetTop(Stack *S,SDataType &SData); //获取栈头元素 
/*栈操作函数声明*/

int InitStack(STACK *S) //初始化栈 
{
      S->top=S->base=(SDataType *)malloc(STACK_INIT_SIZE*sizeof(SDataType));
    if(S->base==NULL) return FAILURE;
    S->STACK_SIZE=STACK_INIT_SIZE; 
      return SUCCEED; 
} 

int DestroyStack(STACK *S) //销毁栈 
{
    free(S->base);
    return SUCCEED;
}
 
int StackLength(STACK *S) //返回栈中当前元素数量 
{
 return S->top-S->base;    
} 

int ClearStack(STACK *S) //清空栈 
{
  S->top=S->base;
  return SUCCEED;    
} 

int Push(STACK *S,SDataType SData) //数据压栈 
{
   if(S->top-S->base==S->STACK_SIZE)
   {
      SDataType *NewP=(SDataType *)realloc(S->base,(S->STACK_SIZE+STACK_SIZE_INCREMENT)*sizeof(SDataType));
      if(NewP==NULL) 
      return FAILURE;    
      S->base=NewP; 
      S->STACK_SIZE=S->STACK_SIZE+STACK_SIZE_INCREMENT;
   }    
   *S->top++=SData;
   return SUCCEED;
} 

int StackEmpty(STACK *S) //判断栈是否为空 
{
    if(S->base==S->top)
    return YES;
    else
    return NO;
}

int Pop(Stack *S,SDataType &SData) //栈头数据弹出栈 
{
    if(StackEmpty(S)) return FAILURE;
    SData=*--S->top; return SUCCEED;
}

int GetTop(STACK *S,SDataType &SData) //获取栈头元素 
{
    if(StackEmpty(S)) return FAILURE;
    SData=*(S->top-1); return SUCCEED;
} 

 

备注：第一次发文章，如果有错误和可以改进部分请大家提出，谢谢！