當前位置：首頁 » 編程語言 » c語言入棧

c語言入棧

發布時間: 2021-03-31 04:23:05

⑴ 數據結構用c語言編程實現進棧出棧

希望如下對你有用：
/*棧的基本操作*/
#
define
stacksize
100
/*定義棧的最大存儲空間*/
#
define
LEN
sizeof(struct
stack)
static
size=0;
struct
stack
{
int
data;
int
*top[stacksize];
};
struct
stack
*sqstack;
struct
stack
*s;
static
e;
int
push()
/*將元素壓入棧*/
{
if
(size<=stacksize)
*
sqstack->top[size++]=e;
else
printf
("
the
stack
is
full:");
}
int
pop(struct
stack
*sqstack,int
location)
/*元素出棧*/
{
e=*(sqstack->top[location]);
return
(e);
}
main()
{
int
n,i,t,x=0;
int
element;
printf
(
"\n
create
the
stack
first
:");
scanf
("%d
",&n);
for
(i=1;i<=n;i++)
{
scanf
("%d",&e);
push
(e);
}
s=sqstack;
t=size;
printf
("\n
after
pushed
,
the
sqstack
is
:");
while
(t>=0)
{
*s->top[t]=*sqstack->top[t];
t--;
}
t=size;
while
(t!=0)
{
t--;
e=pop(s,t);
printf
("
%d->",e);
}
printf
("\n
which
element
you
want
to
pop
:");
scanf
("%d",&element);
while
(size!=0)
{
e=pop(sqstack,size--);
if
(element==e)
{
printf
("\n
%d
is
poped",element);
x=1;
}
}
if(x==0)
printf
("\n
%d
is
not
found
in
the
sqstack.\n",element);
}

⑵ c語言中入棧有什麼表示方法啊

棧的特點是先進後出。
你把棧當成一個水桶，把書一本本放進去，然後最先放的書就被壓在最下面，所以最先進去的，最後出來。
壓棧就是入棧就是把書放進水桶，出棧就是把書拿出來。

⑶ c語言出棧入棧實現

1.聲明個數組a[10];
2.編寫入棧函數push(int x)
取得當前棧頂索引，將x存於數組a的索引處，返回成功與內否。
3.編寫容出棧函數pop()
取得當前棧頂索引，將數組a中索引處的值取出，返回給調用函數
4.將上述過程用C語言實現！

⑷ c語言入棧出棧，出隊入隊問題

intpop(seqstack*s,char*x){
	if(s->top==0){//初始化時，s->top=-1，此處以s->top==0判斷棧為空，有矛盾
		專printf("棧空
");
		return-1;
	}
	else{
		*x=s->c[s->top];
		s->top--;
	}
	return1;
}

通常，top指的位置是待壓入屬的空結點，所以top == 0時，棧為空，top ==MAXSIZE時，棧滿，故應該修改初始化函數，建議蟹蓋如下:

seqstack*Initstack(void){
	seqstack*s;
	s=(seqstack*)malloc(sizeof(seqstack));
	s->top=0;
	returns;
}

⑸ 用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語言的「進棧」和「出棧」是什麼意思

棧使用鏈表來實現的.如果你不懂的鏈表,可以先了解一下鏈表.
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
}
出棧是一樣的.

⑺ c語言實現進棧程序的全過程

/**************
sstack.h
***************/
/* 順序棧表示：類型和界面函數聲明 */

enum { MAXNUM = 20 /* 棧中最大元素個數，應根據需要定義 */
};

typedef int DataType; /* 棧中元素類型，應根據需要定義 */

struct SeqStack { /* 順序棧類型定義 */
int t; /* 棧頂位置指示 */
DataType s[MAXNUM];
};

typedef struct SeqStack SeqSack, *PSeqStack; /* 順序棧類型和指針類型 */

/*創建一個空棧;為棧結構申請空間，並將棧頂變數賦值為-1*/
PSeqStack createEmptyStack_seq( void );

/*判斷pastack所指的棧是否為空棧，當pastack所指的棧為空棧時，則返回1，否則返回0*/
int isEmptyStack_seq( PSeqStack pastack );

/* 在棧中壓入一元素x */
void push_seq( PSeqStack pastack, DataType x );

/* 刪除棧頂元素 */
void pop_seq( PSeqStack pastack );

/* 當pastack所指的棧不為空棧時，求棧頂元素的值 */
DataType top_seq( PSeqStack pastack );

/**************
sstack.c
***************/

/* 順序棧表示：函數定義 */

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

#include "sstack.h"

/*創建一個空棧;為棧結構申請空間，並將棧頂變數賦值為-1*/
PSeqStack createEmptyStack_seq( void ) {
PSeqStack pastack = (PSeqStack)malloc(sizeof(struct SeqStack));
if (pastack==NULL)
printf("Out of space!! \n");
else
pastack->t = -1;
return pastack;
}

/*判斷pastack所指的棧是否為空棧，當pastack所指的棧為空棧時，則返回1，否則返回0*/
int isEmptyStack_seq( PSeqStack pastack ) {
return pastack->t == -1;
}

/* 在棧中壓入一元素x */
void push_seq( PSeqStack pastack, DataType x ) {
if( pastack->t >= MAXNUM - 1 )
printf( "Stack Overflow! \n" );
else {
pastack->t++;
pastack->s[pastack->t] = x;
}
}

/* 刪除棧頂元素 */
void pop_seq( PSeqStack pastack ) {
if (pastack->t == -1 )
printf( "Underflow!\n" );
else
pastack->t--;
}

/* 當pastack所指的棧不為空棧時，求棧頂元素的值 */
DataType top_seq( PSeqStack pastack ) {
return pastack->s[pastack->t];
}

⑻ 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
<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語言入棧

與c語言入棧相關的閱讀推薦