1. c语言静态分配的顺序栈的销毁，清空如何实现
楼上说得对
代码里有两个问题
1、if (S.elem){ free(S.elem)} // 空指针不释放
2、S.top = 0; // NULL是对应于指针的
2. 关于栈的清空 C语言 求大神
你这个栈是一个顺序栈，base是其所占内存的首地址，当然free(s->base)会把整个栈所占内存都释放，栈不仅仅是空了（象杯子中没有了水），而且变没了（连杯子都只剩下个底座了）。可以这样做，但是一定注意：对应的结构体中stacksize要置为0。
3. C语言销毁栈和队列问题
你这里“栈”是用一个单独的结构变量Stack①来存储的，其成员之一为栈顶的指针top。清空栈指的是把把栈里的元素都清除掉，但栈本身还在（此时栈为空栈）。而销毁栈则把①也给销毁掉了。对队列的操作也类似。
4. C语言顺序栈的销毁算法怎么写
#include<stdio.h>
#include<stdlib.h>
typedefstructNode
{
intdata;
structNode*Next;
}NODE;
typedefstructStack
{
NODE*ptop;
NODE*pBottom;
}STACK;
voidinit(STACK*pS);//初始化
voidpush(STACK*pS,intnum);//圧栈
voidtraverse(STACK*pS);//遍历栈
voidclear(STACK*pS);//清空
intempty(STACK*pS);//判断是否为空
intpop(STACK*pS,int*tmp);//出栈
intmain(void)
{
STACKS;
intt=0;
init(&S);
push(&S,1);
push(&S,8);
push(&S,6);
push(&S,2);
push(&S,3);
traverse(&S);
if(pop(&S,&t))
{
printf("出栈成功!本次出栈元素为[%d] ",t);
}
else
{
printf("出栈失败! ");
exit(1);
}
traverse(&S);
clear(&S);
traverse(&S);
return0;
}
voidinit(STACK*pS)//初始化
{
pS->ptop=(NODE*)malloc(sizeof(NODE));
if(NULL==pS)
{
printf("内存分配失败! ");
exit(1);
}
else
{
pS->pBottom=pS->ptop;
pS->ptop->Next=NULL;
}
return;
}
voidpush(STACK*pS,intnum)//圧栈
{
NODE*ptmp=(NODE*)malloc(sizeof(NODE));
if(NULL==ptmp)
{
printf("内存分配失败! ");
exit(1);
}
else
{
ptmp->data=num;
ptmp->Next=pS->ptop;
pS->ptop=ptmp;
}
return;
}
voidtraverse(STACK*pS)//遍历栈
{
if(empty(pS))
{
printf("栈为空! ");
exit(1);
}
else
{
NODE*p=NULL;
p=pS->ptop;
while(p!=pS->pBottom)
{
printf("%d",p->data);
p=p->Next;
}
printf(" ");
}
return;
}
intempty(STACK*pS)
{
if(pS->ptop==pS->pBottom)
{
return1;
}
else
{
return0;
}
}
intpop(STACK*pS,int*tmp)
{
NODE*r=NULL;
if(empty(pS))
{
return0;
}
else
{
r=pS->ptop;
*tmp=r->data;
pS->ptop=r->Next;
free(r);
r=NULL;
return1;
}
}
voidclear(STACK*pS)//清空
{
NODE*q=NULL,*p=NULL;
if(empty(pS))
{
printf("栈为空! ");
exit(1);
}
else
{
while(q!=pS->pBottom)
{
q=pS->ptop;
p=q;
pS->ptop=q->Next;
free(q);
q=p;
}
pS->ptop=pS->pBottom;
//printf("[%p][%p] ",pS->pBottom,pS->ptop);
}
return;
}
[email protected] 一起学习，C语言爱好者。
5. C语言堆栈中如何 创建 销毁 压栈 弹栈 判空 置空 计数
栈（stack）又名堆栈，它是一种运算受限的线性表。
其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
这里是C++源码，供参考。
#include<iostream>
usingnamespacestd;
constintMax=100;
template<classT>
classMyStack
{
private:
T*aa;
unsignedintp;
public:
voidinit();
boolisEmpty();
Tpop();
voidpush(constTa);
unsignedintsize();
voiddestroy();
};
template<classT>
voidMyStack<T>::init()
{
aa=newT[Max+1];
p=0;
return;
};
template<classT>
boolMyStack<T>::isEmpty()
{
if(p==0)returntrue;
elsereturnfalse;
};
template<classT>
unsignedintMyStack<T>::size()
{
returnp;
};
template<classT>
voidMyStack<T>::push(constTa)
{
p=p+1;
aa[p]=a;
};
template<classT>
TMyStack<T>::pop()
{
chart=aa[p];
p=p-1;
cout<<t<<endl;
returnt;
};
template<classT>
voidMyStack<T>::destroy()
{
delete[]aa;
};
intmain()
{
MyStack<char>st;
st.init();
if(st.isEmpty())cout<<"MyStackisempty"<<endl;
elsecout<<"MyStackisnotempty"<<endl;
st.push('a');
st.push('b');
st.push('c');
st.push('d');
st.push('e');
cout<<st.size()<<endl;
while(!st.isEmpty())st.pop();
st.destroy();
system("pause");
return0;
}
6. 用顺序表实现栈的基本操作（基于C语言）求解答
/顺序栈
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACK_INIT_SIZE 100;
#define STACKINCREMENT 10;
typedef struct
{
int *base;
int *top;
int stacksize;
}SqStack;
typedef int ElemType;
int InitStack(SqStack &S) //为栈S分配存储空间，并置S为空栈
{
int size = STACK_INIT_SIZE;
S.base=(int *)malloc(size*sizeof(ElemType));
if(!S.base)
return 0;
S.top=S.base; //置栈S为空栈
S.stacksize=STACK_INIT_SIZE;
return 1;
}
int GetTop(SqStack S,int &e) //若栈不空，则用e返回S的栈顶元素
{
if(S.top==S.base) return 0;
e=*(S.top-1);
return 1;
}
int Push(SqStack &S, int e) /*进栈函数,将e插入栈S中,并使之成为栈顶元素*/
{ if(S.top-S.base>=S.stacksize) /*栈满，追加存储空间*/
{
int stackinvrement = STACKINCREMENT;
S.base=(ElemType *) realloc(S.base,(S.stacksize+stackinvrement)*sizeof(ElemType));
if(!S.base)
return 0; /*存储分配失败*/
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return 1;
}
int Pop(SqStack &S,int &e)/*出栈函数,若栈S不空,则删除S的栈顶元素,用e返回其值*/
{ if(S.top==S.base) return 0;
e=*--S.top;
return 1;
}
void OutputStack(SqStack &S)
{int *q;
q=S.top-1;
for(int i=0;i<S.top-S.base;i++)
{
printf("%3d ",*q);q--;}
}
void main()
{
int a,b,c ;
char m;
SqStack s;
InitStack(s);
printf("请输入要进栈的元素个数是:");
scanf("%d",&a);
printf("\n请输入要进栈的%d个元素:",a);
for(b=0;b<a;b++) {
scanf("%d",&c);
Push(s,c); }
do { printf("\n");
printf("*********** 1.输出栈的元素**********\n");
printf("*********** 2.取栈顶元素************\n");
printf("*********** 3.删除栈顶元素**********\n");
printf("*********** 4.退出程序**********\n");
printf("\n请选择一个字符:");
getchar();
scanf("%c",&m);
switch(m) {
case '1': printf("\n输出的栈为:");
OutputStack(s);
break;
case '2': GetTop(s,c);
printf("\n栈顶元素为:%d",c);
printf("\n输出的栈为:");
OutputStack(s);
break;
case '3': Pop(s,c);
printf("\n删除的栈顶元素:%d",c);
printf("\n输出的栈为:");
OutputStack(s);
printf("\n");
break;
case '4':break;
default: printf("输入的数字有错，请重新选择!\n"); break;
}
}while(m!='4');
}
//链栈
#include<stdio.h>
#include<stdlib.h>
typedef struct SNode
{
int data;
struct SNode *next;
}SNode,*LinkStack;
LinkStack top;
LinkStack PushStack(LinkStack top,int x) //入栈
{
LinkStack s;
s=(LinkStack)malloc(sizeof(SNode));
s->data=x;
s->next=top;
top=s;
return top;
}
LinkStack PopStack(LinkStack top) //退栈
{
LinkStack p;
if(top!=NULL)
{
p=top;
top=top->next;
free(p);
printf("退栈已完成\n");
return top;
}
else printf("栈是空的，无法退栈！\n"); return 0;
}
int GetStackTop(LinkStack top) //取栈顶元素
{
return top->data;
}
bool IsEmpty()//bool取值false和true，是0和1的区别,bool只有一个字节,BOOL为int型,bool为布尔型
{
return top==NULL ? true:false;
}
void Print()
{
SNode *p;
p=top;
if(IsEmpty())
{
printf("The stack is empty!\n");
return;
}
while(p)
{
printf("%d ", p->data);
p=p->next;
}
printf("\n");
}
void main()
{
int x,a,b;
char m;
do { printf("\n");
printf("###############链栈的基本操作##################\n");
printf("××××××××1.置空栈××××××××××\n");
printf("××××××××2.进栈×××××××××××\n");
printf("××××××××3.退栈×××××××××××\n");
printf("××××××××4.取栈顶元素××××××××\n");
printf("××××××××5.退出程序×××××××××\n");
printf("##############################################\n");
printf("\n请选择一个字符:");
scanf("%c",&m);
switch(m){
case '1':
top=NULL;
printf("\n栈已置空!");
break;
case '2':
printf("\n请输入要进栈的元素个数是:");
scanf("%d",&a);
printf("\n请输入要进栈的%d个元素:",a);
for(b=0;b<a;b++) {
scanf("%d",&x);
top=PushStack(top,x); }
printf("进栈已完成！\n");
printf("\n输出栈为:");
Print();
break;
case '3':
printf("\n操作之前的输出栈为:");
Print();
top=PopStack(top);
printf("\n操作过后的输出栈为:");
Print();
break;
case '4':
printf("\n输出栈为:");
Print();
if(top!=NULL)
printf("\n栈顶元素是：%d\n",GetStackTop(top));
else
printf("\n栈是空的，没有元素！");
break;
case '5':break;
default:
printf("\n输入的字符不对，请重新输入!");
break;
}
getchar();
}while(m!='5');
}
7. c语言销毁栈的函数。大家看看写的对不
这两个函数一个是销毁栈DestroyStack，一个是清空栈ClearStack
销毁是把整个栈都释放掉，清空只是把栈里元素清除。
因为你的栈元素是int型基本变量，所以栈元素内容是直接存放在栈空间的，并没有另外申请内存保存栈元素，所以在从栈里移除栈元素时，不需要调用free函数。
实际上你的DestroyStack可以很直接的如下：
int DestroyStack(stack &s)
{
free(s.base); //释放栈空间，这里假设s.base是个指针而不是数组
//如果s结构也是动态申请的，也需要执行free(s);
}
至于ClearStack，书上写的是没问题的，清空栈，不是要释放栈空间，而是把栈里的元素都清除，最直接的做法就是把栈顶指针指向栈底指针，栈顶和栈底指针相同时，就表示栈内无元素，栈空间还是保留，下次可以继续把栈元素压栈和弹栈。
8. 栈的清空与销毁
对栈的操作一般应该使用指针,而不是简单的数组~~
如果按楼主这么写一个例子的话对清空可以直接这样简单的定义
void clear( SqStack &tem)
{
int i=0;
for(;i<STACKSIZE;i++)
{
items[i]=0;
}
top=0;
}
销毁栈就直接不用写了~~因为不是指针的话销不销毁没有意义
9. c语言数据结构高手请进，关于顺序栈的基本操作问题。
1. 想通过调用函数改变某个变量的值，必须传递这个变量的地址。也就是在InitStack中申请的内存并没有赋给Main中的s变量，会导致后面的访问出错。改为引用就可以了：
void InitStack(SqStack* &s)//初始化栈
{
s=(SqStack *)malloc(sizeof(SqStack));
s->top=-1;
}
2.在"Pop(s,e);", 这个e并没有内存，导致"*e=s->data[s->top];"出错。
需要给它申请内存：
ElemType *e = (ElemType*)malloc(sizeof(ElemType));
最后"free(e);"一下。
10. c语言 栈的操作
#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<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;
}