⑴ c語言中的出棧是什麼意思
可以去查看數據結構中的棧結構，FILF
先進後出。
出棧的意思是彈出棧頂的元素，
彈出的意思從內存中拷貝出來，刪除原有元素！
⑵ c語言的簡單的進棧出棧
就用這堆函數就可以了，不懂再追問
#include
<string.h>
#define
MaxSize
100
int
mystack[MaxSize];/*
第0個單元保存現在的長度
*/
/*
初始化函數
*/
void
init_stack(int*
stack){
memset(stack,0,sizeof(stack));
}
/*
入棧函數
*/
void
push_back(int*
stack,int&
num){
if(stack[0]<MaxSize-1){
++stack[0];
stack[
stack[0]
]
=
num;
}
else{
printf("ERORR!\n");
}
}
/*
返回棧空間
*/
int
size(int*
stack){
return
stack[0];
}
/*
返回棧頂函數
*/
int
top(int*
stack){
if(stack[0]>0){
return
stack[
stack[0]
];
}
else{
printf("ERORR!\n");
return
-1;
}
}
/*
出棧函數
*/
void
pop(int*
stack){
if(stack[0]>0){
--stack[0];
}
else{
printf("ERORR!\n");
}
}
⑶ 用C語言實現入棧出棧
#include
<stdio.h>
int
stack[100];
/*100個棧空間*/
int*
sp
=
stack;
/*棧指針指向棧底*/
#define
push(
i
)
{
*sp++
=
i;
}
/*push一個數*/
#define
pop()
(*--sp)
/*pop一個數並返回*/
int
main()
{
int
i;
for
(
i
=
0;
i
<
10;
++i
)/*push
0~9*/
push(
i
);
for
(
i
=
0;
i
<
10;
++i
)/*輸出9~0*/
printf(
"%d
",
pop()
)
;
}
⑷ C語言 進棧和出棧：
閑得沒事干，跟你詳細講講吧。
首先要弄明白一點，棧的結構是「先進後出「的，就像你堆積木一樣，第一根放在最底層的地面上，然後一根一根往上堆。前一個放上去的總是被後一個放上去的壓在底下。那我當我再想裡面放一根的時候，總不能放中間或者放底下吧（除非你很無聊 很寂寞 閑的蛋疼了 先一根根把堆在上面的全部拿出來 然後把要放進去的那根放上去 最後又把剛才搬下來的有重新搬上去......此處省去幾萬字)所以要往上面加東西的時候，就得放在最上面。
以上就是進棧的原理，怎麼出棧呢，很簡單，直接從」積木"的最頂端取下來就行了。
ok，以上比喻完了，希望你能看得明白。接下來講程序不說積木了：），由上面的分析 我們可以知道一個道理，對於棧的操作，棧頂的元素很重要（也就是積木最上面的那根）。為什麼呢。無論是出棧還是進棧，都跟那哥們有直接的聯系。你想啊，如果要是有元素要進棧的話，那麼它就不能當「老頂」了，那老頂之位就要交給壓在它上頭那位了；如果出棧呢，它也不能當老頂了，老頂之位就要交到原來壓在它底下的那個。
ok,所以一般的棧都將棧頂的那個元素所在的位置（內存地址--數組類型的，或者指針---節點類型的）視為棧的棧頂~！通過它來對棧進出進行操作。
一般來說（或者在我出生以來看到過的）棧有兩種內存結構（注意是是內存結構，有的書說是存儲結構，都一樣一樣滴），一種是連續的，一種是不連續的，連續的基本上就是數組了，不連續的基本上就是鏈表類型的啦。你上面的程序就是鏈表類型的，每個節點都有個指針指向它「底下」的節點（我覺得「底下」比下一個更容易理解）。通過這種你鏈我 我鏈它的方式，把一組數據連在一起。
進棧：
int Push(STACK *S,int e)//進棧
{
SNode *p; //step1:這個編程習慣不好，沒定義一個指針就應該把它指向NULL
p=(SNode *)malloc(sizeof(SNode)); //step2:為你的節點分配內存
if(!p)
return ERROR;
p->data=e; //step3：當然了，你那個傳進來的e是相當於temp，用來傳值的，ok，那就把它的 數據給p咯，p實際指向的是一塊內存塊，用來裝節點的
p->next=S->top; //step4:回到上面積木問題，進棧的時候，原來的老頂要給新來的讓位，但是如果這時候的top節點直接賦給新來的元素的話，那麼那個原來的老頂是不是從此以後都找不到它了？所以，先把新來的元素的next指針指向當前的老頂，這樣的話，以後通過next指針就可以找到它了。
S->top=p; //當然，都已經處理好以前老頂的身後事了（就是以後可以通過p的next指針找到它了）那麼「讓位」就可以進行了，這時，p便戴上了 老頂 之帽了
S->length++; //既然人數都增加了，那就到公安局登記入戶口吧
return OK; //一切over，現在這個棧stack的棧頂位置就是你剛才新加進來的p了，通過stock.top指針就可以訪問到棧頂，然後出棧也是同理的，ok，all over
}
⑸ C語言入棧出棧操作的程序，希望有人為我解答
您好：
你是在學習數據結構方面的知識吧。
首先呢，你學習棧，要了解棧的定義，明白它是怎麼一回事，就是去理解他的思想。
最後才去用代碼來體現出來。
棧是先進後出，其實是用代碼控制的，
其實你要他先進先出也可以。
你只要明白他的原理就行。
代碼，你可以理解為跟計算的一種對話的語言。
不用想的那麼復雜。
就好比說話，你只要知道你要說什麼就行（演算法），而不用刻意明白要怎麼說（語法）。
下面給我出我以前寫的代碼，關於棧的，順序棧，其實還有鏈棧。
/*數據結構-棧*/
/*異常的細節處理還沒弄好*/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#definelen_chu_shi50//初始空間大小
#definelen_zeng_jia10//額外增加空間大小
#defineOK0//正確
#defineOVER-2//
#defineERROR-1//
usingnamespacestd;
typedefintelem_type;//元素類型
typedefintfunction_type;//函數類型
typedefstructzhan
{
elem_type*top;//棧頂
elem_type*base;//棧底
intlen;//當前空間大小
}zhan;//棧結構
function_typeInit_zhan(zhan*exam);//初始化棧
function_typeGet_top(zhan*exam,elem_type*e);//獲取棧頂元素
function_typeAdd_top(zhan*exam,elem_type*e);//增加棧頂元素
function_typeDelete_top(zhan*exam,elem_type*e);//刪除棧頂元素
intmain(intargc,char*argv[])
{
zhan*example=(zhan*)malloc(sizeof(zhan));
Init_zhan(example);
returnOK;
}
function_typeInit_zhan(zhan*exam)
{
exam->base=(elem_type*)malloc(len_chu_shi*sizeof(elem_type));
if(!exam->base)//分配失敗
exit(OVER);
exam->top=exam->base;
exam->len=len_chu_shi;
returnOK;
}//--end
function_typeGet_top(zhan*exam,elem_type*e)
{
if(!exam->base)
exit(OVER);
*e=*(exam->top-1);//不能用自減運算符，那樣會改變棧頂指針的值
returnOK;
}//--end
function_typeAdd_top(zhan*exam,elem_type*e)
{
if(exam->len<=exam->top-exam->base)//我個人覺得，如果已經"<"，就已經數據溢出了，就應該報錯
exam->base=(elem_type*)realloc(exam->base,(exam->len+len_zeng_jia)*sizeof(elem_type));
if(!exam->base)//分配失敗
exit(OVER);
*(exam->top++)=*e;//應該是先改變棧頂指針的內容，然後棧頂指針再自增
exam->len+=len_zeng_jia;
returnOK;
}//--end
function_typeDelete_top(zhan*exam,elem_type*e)
{
if(!exam->base)//空棧
exit(OVER);
*e=*(--exam->top);//應該是棧頂指針先自減，然後獲取棧頂指針的內容
returnOK;
}//--end
⑹ C語言中什麼是出棧
棧是一種數據結構，一個棧相當於一個盒子，把東西（數據）放入盒子里的過程叫做入棧，把東西從盒子里取出來的過程叫做出棧。棧還有一個特殊的規則，就是先進後出，即盒子里的東西只能疊加擺放，放進去的下一件東西只能堆在前一件東西的上面，取出時只能先取出盒子最上面的一件東西。出棧也就是將棧指針所指的數據從棧中彈出的過程，每一次出棧的一定是棧頂元素，出棧後棧指針向下移動一位指向下一個元素。習慣上入棧用PUSH表示，出棧用POP表示。
⑺ C語言出棧是什麼意思
棧 是c中一個容器，先進先出， 出棧就是把數據取出來。輸出棧的值就是把出棧的數據列印出來。看一下書就明白的。
⑻ C語言 進棧出棧
#include <stdio.h>
#include <malloc.h>
#define max 10
typedef struct
{
char a[max];
int top;
}qstype;
void init(qstype *s)
{
s->top =-1;
}
int push(qstype *s,char x)
{
if(s->top >= max)
{
return 0;
}
else
{
s->top ++;
s->a[s->top] = x;
return 1;
}
}
char pop(qstype *s)
{
if(s->top < 0)
{
return 0;
}
else
{
return s->a[s->top];
s->top --;
}
}
void print(qstype *s)
{
int i;
for(i=0;i<s->top;i++)
printf("%c",s->a[i]);
}
int main(void)
{
char ch;
qstype *A,*B;
A=(qstype *)malloc(sizeof(qstype));
B=(qstype *)malloc(sizeof(qstype));//指針沒有初始化
init(A);
init(B);
scanf("%c",&ch);
while(ch!='\n')
{
if(push(A,ch) == 0)
break;
scanf("%c",&ch);
}
print(A);
return 0;
}
⑼ 關於c語言出棧問題
pop函數需要向外界傳遞兩個信息：①出棧操作成功與否；②出棧的元素的值。①可以通過返回值傳遞給外界，那麼②呢？C語言中函數只能有一個返回值，不可能既返回a又返回b，當然你可以通過返回一個結構體當中封裝了這兩者來實現，但這太麻煩不符合函數初衷，所以②就通過函數的第二個參數傳遞給外界，即出棧的元素的值保存在參數2中。既然如此，參數2必然要做到能夠修改外界實參的值，而如果使用ElemType類型，在函數中修改形參的值不可能影響到外部實參，所以必須使用ElemType*指針類型，並傳遞外部實參的地址作為參數，然後通過指向實參的指針去修改實參的值。
⑽ 一個C語言編程題
這個問題可以分為3部分
1、輸入一個字元串，將其格式化的儲存在一個數組中，以方便的記錄表達式中數和各個符號的出現順序
約定在數組中記錄時，每個數或符號用兩個整數來記錄
第一個整數記錄該位是什麼東西，0表示是一個數，1表示是括弧，2表示反括弧，3、4、5、6分別表示乘除加減號
如果該位是一個數，那麼第二個整數記錄著個數的具體取值，否則記錄該位的符號的ASCII碼
比如字元串"(1-23)"會被轉化成二位數組{ {1,'('} , {0,1} , {6,'-'} , {0,23} , {2,')'}}
這個轉化過程每什麼技巧性，對原字元串各位順次判斷並處理即可
原先的字元串中可能出現一元運算符正號'+'和負號'-'，為了處理方便，一律在其前面加個0，改寫成"0+..."或者"0-..."
另外為了之後轉化逆波蘭表達式方便，處理過程中會在轉化出的數組的首尾一律添加一對括弧
2、將之前所提到的格式數組轉化為逆波蘭表達式
約定依然用二位數組記錄一個逆波蘭表達式，並且格式與之前的數組相同，除了沒有括弧以外
比如逆波蘭表達式 1 2 - 35 +，會被記錄成{ {0,1} , {0,2} , {6,'-'} , {0,35} , {5,+}}
轉化時，需要用一個棧
具體轉化操作如下：
順次處理格式數組的每一位，對其作判斷
如果該位是一個數或者是括弧'('，，將其入棧
如果該位是乘號'*'或者除號'/'，不斷進行出棧操作直到棧頂元素是個括弧'('或者加號'+'或者減號'-'，然後將這個乘號或者除號入棧
如果該位是加號'+'或者減號'-'，不斷進行出棧操作直到棧頂元素是個括弧'('，然後將這個加號或者減號入棧
如果該位是反括弧')'，那麼不斷進行出棧操作直到有一個括弧'('出棧
在上述操作中，所有的出棧元素，除了括弧'('以外，都被順次添加到所要生成的逆波蘭表達式的末尾
這樣就轉化出了一條逆波蘭表達式
3、對逆波蘭表達式求值
求值時，也需要用到一個棧
求值步驟如下：
順次處理逆波蘭表達式的每一位，對其作判斷
如果該位是一個數，將這個數入棧
如果該位是一個運算符，那麼連續進行兩次出棧操作，可以得到棧頂的兩個元素，對這兩個元素用該位的運算符做運算，將所得的結果入棧
比如，如果當時棧頂元素是3，次棧頂的元素是2，運算符是減號'-'，那麼連續兩次出棧得到3和2兩個元素，再將2-3的運算結果1入棧
注意有些運算符(減號和除號)不符合交換律，因此運算時必須是次棧頂元素在前、棧頂元素在後，順序不能反
當每一位都處理完了之後，只要輸入的是一個合法的逆波蘭表達式，必然棧中只剩下一個元素，這個元素就是逆波蘭表達式求值的結果
源代碼如下：
#include <stdio.h>
#include <ctype.h>
void transform(char *str,int a[][2],int *n)
//將輸入的字元串轉化為格式化的數組以記錄輸入的表達式，str為輸入的字元串，a為目標數組，n記錄數組a的大小
{
int i;
*n=1;
a[0][0]=1;
a[0][1]='(';//在表達式首添加一個括弧
for (i=0;str[i];)
{
if (isdigit(str[i]))
{
a[*n][0]=0;
a[*n][1]=0;
while (isdigit(str[i]))
{
a[*n][1]=a[*n][1]*10+str[i]-'0';
i++;
}
}
else
{
if (str[i]=='(') a[*n][0]=1;
else if (str[i]==')') a[*n][0]=2;
else if (str[i]=='*') a[*n][0]=3;
else if (str[i]=='/') a[*n][0]=4;
else if (str[i]=='+' || str[i]=='-')
{
if (i==0 || (!isdigit(str[i-1]) && str[i-1]!=')'))
{
a[*n][0]=0;
a[*n][1]=0;
(*n)++;
}
if (str[i]=='+') a[*n][0]=5;
else a[*n][0]=6;
}
a[*n][1]=str[i];
i++;
}
(*n)++;
}
a[*n][0]=2;
a[*n][1]=')';//在表達式尾添加一個反括弧
(*n)++;
}
void poland(int a[][2],int n,int p[][2],int *m)
//將格式化數組轉化為逆波蘭表達式，a為輸入的數組，n為其長度，p為輸出逆波蘭表達式的目標，m記錄逆波蘭表達式的長度
{
int i;
int stack[1000];//轉化所用的棧
int depth;//棧的深度
depth=0;
*m=0;
for (i=0;i<n;i++)
{
if (a[i][0]==0) stack[depth++]=i;
else if (a[i][0]==1) stack[depth++]=i;
else if (a[i][0]==2)
{
while (a[stack[depth-1]][0]!=1)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
depth--;
}
else if (a[i][0]==3 || a[i][0]==4)
{
while (a[stack[depth-1]][0]==0 || a[stack[depth-1]][0]==3 || a[stack[depth-1]][0]==4)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
stack[depth++]=i;
}
else if (a[i][0]==5 || a[i][0]==6)
{
while (a[stack[depth-1]][0]!=1)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
stack[depth++]=i;
}
}
}
void print_poland(int p[][2],int m)
//列印逆波蘭表達式，p為逆波蘭表達式，m為表達式長度
{
int i;
for (i=0;i<m;i++)
{
if (p[i][0]==0) printf("%d",p[i][1]);
else printf("%c",p[i][1]);
}
putchar('\n');
}
double evaluate(int p[][2],int m)
//對逆波蘭表達式求值，p為逆波蘭表達式，m為表達式長度
{
double stack[1000];//求值所用的棧
int depth;//棧的深度
int i;
depth=0;
for (i=0;i<m;i++)
{
if (p[i][0]==0) stack[depth++]=p[i][1];
else
{
double a,b;
b=stack[--depth];
a=stack[--depth];
if (p[i][0]==3) stack[depth++]=a*b;
else if (p[i][0]==4) stack[depth++]=a/b;
else if (p[i][0]==5) stack[depth++]=a+b;
else stack[depth++]=a-b;
}
}
return stack[0];
}
int a[1000][2];
int n;
int p[1000][2];
int m;
main()
{
transform("5*(8-2)+9",a,&n);
poland(a,n,p,&m);
print_poland(p,m);
printf("The result of the expression is %lf\n",evaluate(p,m));
return;
}