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;
}