c語言鏈棧的基本操作

① 數據結構實驗（用c語言寫） 棧的基本操作

//順序棧
#include

#include

#include

#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

#include

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

評論
0

0

載入更多

② 計算機c語言中 什麼是棧和隊列

棧(Stack)是僅限制在表的一端進行插入和刪除運算的線性表，稱插入、刪除這一端為棧頂，另一端稱為棧底。表中無元素時為空棧。棧 的修改是按後進先出的原則進行的，我們又稱棧為LIFO表(Last In First Out)。通常棧有順序棧和鏈棧兩種存儲結構。 棧的基本運算有六種： ·構造空棧：InitStack(S) ·判棧空: StackEmpty(S) ·判棧滿： StackFull(S) ·進棧： Push(S,x) ·退棧： Pop(S) ·取棧頂元素：StackTop(S) 在順序棧中有"上溢"和"下溢"的現象。 ·"上溢"是棧頂指針指出棧的外面是出錯狀態。 ·"下溢"可以表示棧為空棧,因此用來作為控制轉移的條件。 順序棧中的基本操作有六種：·構造空棧·判棧空·判棧滿·進棧·退棧·取棧頂元素 鏈棧則沒有上溢的限制，因此進棧不要判棧滿。鏈棧不需要在頭部附加頭結點，只要有鏈表的頭指針就可以了。 鏈棧中的基本操作有五種：·構造空棧·判棧空·進棧·退棧·取棧頂元素 隊列(Queue)是一種運算受限的線性表，插入在表的一端進行，而刪除在表的另一端進行，允許刪除的一端稱為隊頭(front)，允許插入的 一端稱為隊尾(rear) ,隊列的操作原則是先進先出的，又稱作FIFO表(First In First Out) 。隊列也有順序存儲和鏈式存儲兩種存儲結 構。 隊列的基本運算有六種： ·置空隊：InitQueue(Q) ·判隊空：QueueEmpty(Q) ·判隊滿：QueueFull(Q) ·入隊：EnQueue(Q,x) ·出隊：DeQueue(Q) ·取隊頭元素：QueueFront(Q) 順序隊列的"假上溢"現象：由於頭尾指針不斷前移，超出向量空間。這時整個向量空間及隊列是空的卻產生了"上溢"現象。 為了克服"假上溢"現象引入循環向量的概念，是把向量空間形成一個頭尾相接的環形，這時隊列稱循環隊列。 判定循環隊列是空還是滿，方法有三種： ·一種是另設一個布爾變數來判斷； ·第二種是少用一個元素空間，入隊時先測試（(rear+1)%m = front）? 滿：空； ·第三種就是用一個計數器記錄隊列中的元素的總數。 隊列的鏈式存儲結構稱為鏈隊列，一個鏈隊列就是一個操作受限的單鏈表。為了便於在表尾進行插入(入隊)的操作，在表尾增加一個尾指 針，一個鏈隊列就由一個頭指針和一個尾指針唯一地確定。鏈隊列不存在隊滿和上溢的問題。在鏈隊列的出隊演算法中，要注意當原隊中只 有一個結點時，出隊後要同進修改頭尾指針並使隊列變空。

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

④ 在C語言中該怎樣建立棧具體代碼是什麼

1.棧空間（stack段）用來存放函數中的局部變數和函數調用時的上下文。
2.
全局變數和靜態變數存放於進程的數據段。
3.
windows下進程的棧空間會自動增長，一般不會出現空間不足的問題；
4。如果變數實在太大，甚至大於棧可增長的范圍，如數百兆，則會編譯出錯。

⑤ 求計算機C語言中「棧」的基本概念，希望各個方面都有，全一點。最好和教科書介紹的一樣詳細

棧，是硬體。主要作用表現為一種數據結構，是只能在某一端插入和刪除的特殊線性表。它按照後進先出的原則存儲數據，先進入的數據被壓入棧底，最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。 棧是允許在同一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱為棧頂(top)，另一端為棧底(bottom)；棧底固定，而棧頂浮動；棧中元素個數為零時稱為空棧。插入一般稱為進棧（PUSH），刪除則稱為退棧（POP）。 棧也稱為先進後出表。 棧可以用來在函數調用的時候存儲斷點，做遞歸時要用到棧！ 以上定義是在經典計算機科學中的解釋。 在計算機系統中，棧則是一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。 棧在程序的運行中有著舉足輕重的作用。最重要的是棧保存了一個函數調用時所需要的維護信息，這常常稱之為堆棧幀或者活動記錄。堆棧幀一般包含如下幾方面的信息： 1. 函數的返回地址和參數 2. 臨時變數：包括函數的非靜態局部變數以及編譯器自動生成的其他臨時變數。
二、基本演算法
1、進棧（PUSH）演算法 ①若TOP≥n時，則給出溢出信息，作出錯處理（進棧前首先檢查棧是否已滿，滿則溢出；不滿則作②）； ②置TOP=TOP+1（棧指針加1，指向進棧地址）； ③S(TOP)=X，結束（X為新進棧的元素）； 2、退棧（POP）演算法 ①若TOP≤0，則給出下溢信息，作出錯處理(退棧前先檢查是否已為空棧， 空則下溢；不空則作②)； ②X=S(TOP)，（退棧後的元素賦給X）： ③TOP=TOP-1，結束（棧指針減1，指向棧頂）。
三、棧的實現
棧分順序棧和鏈式棧，下面程序介紹了順序棧的實現。
#include<stdio.h> #include<malloc.h> #define DataType int #define MAXSIZE 1024 typedef struct { DataType data[MAXSIZE]; int top; }SeqStack; SeqStack *Init_SeqStack()//棧初始化 { SeqStack *s; s=(SeqStack *)malloc(sizeof(SeqStack)); if(!s) { printf("空間不足\n"); return NULL; } else { s->top=-1; return s; } } int Empty_SeqStack(SeqStack *s)//判棧空 { if(s->top==-1) return 1; else return 0; } int Push_SeqStack(SeqStack *s,DataType x)//入棧 { if(s->top==MAXSIZE-1) return 0;//棧滿不能入棧 else { s->top++; s->data[s->top]=x; return 1; } } int Pop_SeqStack(SeqStack *s,DataType *x)//出棧 { if(Empty_SeqStack(s)) return 0;//棧空不能出棧 else { *x=s->data[s->top]; s->top--; return 1; }//棧頂元素存入*x，返回 } DataType Top_SeqStack(SeqStack *s)//取棧頂元素 { if(Empty_SeqStack(s)) return 0;//棧空 else return s->data[s->top]; } int Print_SeqStack(SeqStack *s) { int i; printf("當前棧中的元素:\n"); for(i=s->top;i>=0;i--) printf("%3d",s->data[i]); printf("\n"); return 0; } int main() { SeqStack *L; int n,num,m; int i; L=Init_SeqStack(); printf("初始化完成\n"); printf("棧空：%d\n",Empty_SeqStack(L)); printf("請輸入入棧元素個數:\n"); scanf("%d",&n); printf("請輸入要入棧的%d個元素：\n",n); for(i=0;i<n;i++) { scanf("%d",&num); Push_SeqStack(L,num); } Print_SeqStack(L); printf("棧頂元素:%d\n",Top_SeqStack(L)); printf("請輸入要出棧的元素個數（不能超過%d個）:\n",n); scanf("%d",&n); printf("依次出棧的%d個元素:\n",n); for(i=0;i<n;i++) { Pop_SeqStack(L,&m); printf("%3d",m); } printf("\n"); Print_SeqStack(L); printf("棧頂元素:%d\n",Top_SeqStack(L)); return 0; }

⑥ 棧的c語言實現基本操作

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#definestack_init_size20
#defineincreasesize10;
typedefintElemType;
typedefstructnode{
	ElemType*base;
	ElemType*top;
	intsize;
}stack;

voidcreat(stack*s)
{
	s->base=(ElemType*)malloc(sizeof(ElemType));
	if(!s->base)
	{
		exit(0);
	}
	s->base=s->top;
	s->size=stack_init_size;
}

voidpush(stack*s,ElemTypee)
{
	if(s->top-s->base>=s->size)
	{
s->base=(ElemType*)realloc(s->base,(s->size+increasesize)*sizeof(ElemType));
		if(!s->base)
		{
			exit(0);
		}
		s->top=s->base+s->size;
		s->size+=increasesize;
	}
	*(s->top)=e;
	s->top++;	
}

voidpop(stack*s,ElemType*e)
{
if(s->top==s->base)
{
	return;
}	
*e=*--(s->top);
}
intstacklen(stacks)
{
	return(s.top-s.base);
}
intmain()
{
	stacks;
	intn;
ElemTypee1,e2,d;
inti=1,j=1;
push(&s,i);
push(&s,j);
scanf("%d",&n);
while(n--)
{
pop(&s,&e1);
	pop(&s,&e2);
	d=e1+e2;
	push(&s,e2);
	push(&s,d);
}
pop(&s,&d);
printf("%d",d);
return0;
}

⑦ 鏈棧如何構造，鏈棧新結點如何進棧

鏈式棧就是用鏈式存儲結構表示一個棧，也就是指針域。
根據棧的性質，知道棧是先進後出，所以只需要設置一個棧頂指針，還是說點C++吧
先構造一個結構模板
template<class
ElemType>
typedef
struct
Node
//建立
{
ElemType
data;//數據成員，用於存儲
struct
Node*next;//指針成員，用於連接邏輯結構
}LNode;
1.構造一個空棧，只需要：
LNode*head;//定義棧頂指針
head=(LNode*)malloc(sizeof(LNode));//分配空間
head->next=NULL;//下一個為空
2.新節點：比如新節點數據位1
入棧操作：
LNode*p;
p->data=1;
p->next=head;
head=p;
總之有點類似C語言里的鏈表
還有什麼不清楚的可以追問
希望對你有所幫助！！！

⑧ 用順序表實現棧的基本操作（基於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');

}

⑨ 急！用c語言實現鏈棧的操作

typedef struct node
{ ElemType data;
struct node *next;
} LinkStack;
⑴置空棧
void InitLinkStack（ LinkStack * & s）
{ s=NULL;
}
⑵判棧空
int IsEmptyLinkStack（LinkStack *s ）
{ if（s==NULL）
return 1;
else
return 0;
}
⑶ 入棧/*將元素x插入鏈棧top的棧頂*/
void PushLinkStack（LinkStack* &s , ElemType x）
{ LinkStack *p;
p=malloc(sizeof(LinkStack)); /*生成新結點*s */
p->data=x;
p->next=s;
s=p;

}
⑷出棧/*刪除鏈棧top的棧頂結點*/
int PopLinkStack (LinkStack* & s, ElemType &x)
{ LinkStack *p;
if（s==NULL） return 0;
x = s->data; /*將棧頂數據存入*x */
p = s; /*保存棧頂結點地址*/
s = s->next; /*刪除原棧頂結點*/
free (p); /*釋放原棧頂結點*/
return 1; /*返回新棧頂指針*/
}
（5） 取棧頂元素
int GetLinkStackTop (LinkStack* s, ElemType &x)
{
if（s==NULL） return 0;
x = s->data; /*將棧頂數據存入*x */
return 1; /*返回新棧頂指針*/
}
主函數怎麼寫吧

⑩ 如何用C語言創建一個鏈棧，並進行操作

1 思路: 主要是鏈表的插入和刪除操作

2 代碼

#include<stdio.h>
#include<stdlib.h>
typedefstructnode
{
	intdata;
	structnode*next;
}node_type;

voidpush(node_type*&stack,intelem){
	node_type*node=(node_type*)malloc(sizeof(node_type));
	node->data=elem;
	node->next=stack;
	stack=node;
}
intpop(node_type*&stack){
	intelem=stack->data;
	node_type*node=stack;
	stack=stack->next;
	free(node);
	returnelem;
}
boolIsEmpty(node_type*stack){
	returnstack==NULL;
}
voiddisplay(node_type*stack){
	while(stack){
		printf("%d",stack->data);
		stack=stack->next;
	}
	puts("");
}
voiddestroy(node_type*stack){
	while(!IsEmpty(stack)){
		pop(stack);
	}
}
intmain(){
	puts("(1)建立空鏈棧");
	node_type*stack=NULL;
	puts("
(2)調用進棧函數，將從鍵盤輸入的數據元素逐個進棧，輸入0結束；");
	intnum;
	scanf("%d",&num);
	while(num!=0){
		push(stack,num);
		scanf("%d",&num);
	}
	puts("
(3)顯示進棧後的數據元素");
	display(stack);
	puts("
(4)調用兩次出棧函數，顯示出棧後的數據元素");
	if(!IsEmpty(stack))
		printf("%d
",pop(stack));
	if(!IsEmpty(stack))
		printf("%d
",pop(stack));

	destroy(stack);
	getchar();
	getchar();
	return0;
}

3 運行效果