當前位置：首頁 » 編程語言 » 進棧和出棧c語言
擴展閱讀
提分平台的賬號密碼是什麼 2023-08-31 22:07:10
webinf下怎麼引入js 2023-08-31 21:54:13
堡壘機怎麼打開web 2023-08-31 21:54:11

進棧和出棧c語言

發布時間: 2023-03-01 00:57:21

A. c語言的「進棧」和「出棧」是什麼意思

棧使用鏈表來實現的.如果你不懂的鏈表,可以先了解一下鏈表.
int Push(STACK *S,int e)//進棧
{
SNode *p;
p=(SNode *)malloc(sizeof(SNode)); // 申請一個節點.這個節點是用來存放入棧的數據的.
if(!p)
return ERROR; // 如果沒有申請成功,返回錯誤.
p->data=e; // 節點的值為e
p->next=S->top; // 放到棧頂
S->top=p; //並修改棧頂為P
S->length++; //長度加一.
return OK; //入棧成功,返回ok
}
出棧是一樣的.

B. 數據結構定義一個棧並實現入棧和出棧操作的程序c語言完整版

如下：

#include"stdio.h"
structstackNode{
intdata;
structstackNode*nextPtr;
};
;
typedefLISTSTACK*STACKNODEPTR;
voidpush(STACKNODEPTR*,int);
intpop(STACKNODEPTR*);
intisEmpty(STACKNODEPTR);
voidprintStack(STACKNODEPTR);
voidinstruct();
intmain()
{
intitem;
intchoice;
STACKNODEPTRsPtr=NULL;
instruct();
printf("chooseyourchoice
");
scanf("%d",&choice);
while(choice!=3)
{
switch(choice)
{
case1:
printf("pleaseinputaninteger!
");
scanf("%d",&item);
//printf("%d
",item);
push(&sPtr,item);
printStack(sPtr);
break;
case2:
if(!isEmpty(sPtr))
{
printf("deletingelementoftopstack
");
pop(&sPtr);
printStack(sPtr);
}
else{
printf("noelementinthestack
");
}
break;
default:
printf("invalidinput,checkyourinput!
");
break;
}
printf("pleacechooseyourchoice");
instruct();
scanf("%d",&choice);
}
}
voidinstruct()
{
printf("Followingtheinstructionbelow:
"
"1:insertnewelmentintothestack
"
"2:deletethetopelementofthestack
"
"3:toendofrun
");
}
intisEmpty(STACKNODEPTRsPtr)
{
returnsPtr==NULL;
}
voidprintStack(STACKNODEPTRsPtr)
{
if(sPtr==NULL)
{
printf("Thestackisempty!
");
}
else{
printf("Theelementsofthestack:
");
while(sPtr!=NULL)
{
printf("%d-->",sPtr->data);
sPtr=sPtr->nextPtr;
}
printf("NULL

");
}
}
voidpush(STACKNODEPTR*topPtr,intvalue)
{
STACKNODEPTRnewPtr;
newPtr=malloc(sizeof(STACKNODEPTR));
if(newPtr!=NULL)
{
newPtr->data=value;
newPtr->nextPtr=*topPtr;
*topPtr=newPtr;
}
else
{
printf("%disnotinsertedintostack.Nomemoryisavailiable
");
}
}
intpop(STACKNODEPTR*topPtr)
{
STACKNODEPTRnewPtr;
inttopValue;
newPtr=*topPtr;
*topPtr=(*topPtr)->nextPtr;
free(newPtr);
topValue=(*topPtr)->data;
printf("deleting---%d
",topValue);
returntopValue;
}

C. 求解C語言進棧出棧問題

結果：stack

D. 用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()
)
;
}

E. C語言數據結構實現鏈棧的入棧、出棧、刪除與插入

1、棧（stack）又名堆棧，它是一種運算受限的線性表。
其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。

2、常式：

#include<stdio.h>
#include<stdlib.h>
#defineMax100
typedefcharT;


typedefstructMyStack
{
Taa[Max];
unsignedintp;

}stack;

//創建空棧
stack*createEmptyStack()
{
stack*st=(stack*)malloc(sizeof(stack));
inti=0;
for(i=0;i<Max;i++)
st->aa[i]=0;
st->p=0;
returnst;
};

//棧判空
intisEmpty(conststack*st)
{
if(st->p==0)return1;
elsereturn0;
};

//求棧的大小
unsignedintsize(conststack*st)
{
returnst->p;
};

//push操作
voidpush(stack*st,constTa)
{
st->p=st->p+1;
if(st->p==Max)
{
printf("棧滿
");
st->p--;
return;
}
st->aa[st->p]=a;
};

//pop操作
Tpop(stack*st)
{
if(isEmpty(st))
{
printf("棧空");
returnNULL;
}
chart=st->aa[st->p];
st->p=st->p-1;
printf("%c",t);
returnt;
};

//棧銷毀
voiddestroy(stack*st)
{
free(st);
};

intmain()
{


stack*st=createEmptyStack();
if(isEmpty(st))printf("MyStackisempty
");
elseprintf("MyStackisnotempty
");
push(st,'a');
push(st,'b');
push(st,'c');
push(st,'d');
push(st,'e');
printf("%d
",size(st));
while(!isEmpty(st))pop(st);
destroy(st);
system("pause");
return0;
}

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

G. 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
}

H. 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語言相關的內容

本站內容整理源於互聯網，如有問題請聯系解決。
Copyright design: www.gotrillian.com since 2022