C语言数据结构实现链栈的入栈、出栈、删除与插入

1、栈（stack）又名堆栈，它是一种运算受限的线性表。
其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

2、例程：

#include 
#include 
#define Max 100
typedef char T;
 
 
typedef struct MyStack
{
    T aa[Max];
    unsigned int p;
               
} stack;
 
//创建空栈
stack* createEmptyStack()
{
      stack* st = (stack *)malloc(sizeof(stack));
      int i=0;
      for(i=0;i         st->aa[i]=0;
      st->p=0;
      return st;    
};
 
//栈判空
int isEmpty(const stack* st)
{
      if(st->p==0) return 1;
      else     return 0;
};
  
//求栈的大小
unsigned int size(const stack* st)
{
      return st->p;
};
 
//push操作
void push(stack* st,const T a)
{
      st->p=st->p+1;
      if(st->p==Max)
      {
          printf("栈满\n");
          st->p--;
          return;
      }
      st->aa[st->p]=a;    
};
 
//pop操作
T pop(stack* st)
{
      if(isEmpty(st))
      {
          printf("栈空");
          return NULL;
      }
      char t=st->aa[st->p];
      st->p=st->p-1; 
      printf("%c ",t);
      return t;     
};
 
//栈销毁
void destroy(stack* st)
{
    free(st);
};
 
int main()
{
     
    
    stack* st = createEmptyStack();
    if(isEmpty(st)) printf("MyStack is empty\n");
    else printf("MyStack is not empty\n");
    push(st,'a');
    push(st,'b');
    push(st,'c');
    push(st,'d');
    push(st,'e'); 
    printf("%d\n",size(st));
    while(!isEmpty(st)) pop(st);
    destroy(st);
    system("pause");
    return 0;
}

#include
#include

#define OK 1
#define TURE 1
#define NULL 0
#define ERROR 0
#define OVERFLOW-2

#defineSTACK_INIT_SIZE 100
#defineSTACKINCREMENT 10

typedef intStatus;
typedef intSElemType;

typedef struct
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

StatusInitStack(SqStack &S);//初始化
StatusPush(SqStack &S, SElemType e);//入栈
Status Pop(SqStack&S, SElemType &e);//出栈
intStackEmpty(SqStack S);//判空
voidconversion();//转化
voidStackTraverse(SqStack S);
void main()
{
conversion();
}

StatusInitStack(SqStack &S)
{
S.base=(SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
StatusPush(SqStack &S, SElemType e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
Status Pop(SqStack&S, SElemType &e)
{
if(S.top==S.base)
return ERROR;
e=*--S.top;
return OK;
}
voidStackTraverse(SqStack S)
{
SElemType *p;
p=S.base;
for(;p printf("%d\n",*p);
}
intStackEmpty(SqStack S)
{
if(S.top==S.base)
return 1;
else
return 0;
}
void conversion()
{
SqStack s;
int n,e;
InitStack(s);
scanf("%d",&n);
while(n)
{
Push(s,n%8);
n=n/8;
}
while(!StackEmpty(s))
{
Pop(s,e);
printf("%d",e);
}
这是我写的，可以看看