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

Question

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct qnode)
#define MAXSIZE 10
#define ADD 1

struct qnode
{
char data;
struct qnode *next;
};

struct Q
{
struct qnode *top;
struct qnode *base;
};

char creat()
{
struct Q s;
s.base=s.top=(struct qnode *)malloc(LEN);
s.top->next=NULL;
if(!s.top){printf("内存分配失败！");}
return s.top;
}

char input()
{
char ch;
ch=getchar();
while(ch!='\n')
{
ch=getchar();
}
return 1;
}

char Output()
{
printf("栈中的数据：\n");
do
{
printf("%c",*--Q.top);
}while(Q.top!=Q.base);
putchar(10);
return 1;
}

char dele()
{
qnode *p;
p=Q.top->next;
Q.top->next=p->next;
printf("被删除的节点是：");
printf("%c",p);
}

char insert()
{

}

char jugde()
{
struct Q a;
if(a.top==a.base) exit(0);
else Output();
return 1;
}

int main()
{
creat();
printf("请输入字符数据：\n");
input();
jugde();
dele();
insert();
return 0;
}

能否帮我改一下？要求是建立一个链栈实现入栈、出栈，删除top->next，再插入一个数据到栈中。
满意的话有追加分~

Answer 1

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

2、例程：

#include <stdio.h>
#include <stdlib.h>
#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<Max;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;
}

Answer 2

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

#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<S.top;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);
}
这是我写的，可以看看追问

太复杂了，而且调试有error