順序棧的c語言實現

A. c語言編程實現順序棧的初始化,入棧,出棧,取棧頂元素,顯示操作

#define STACKSIZE 100
int mstack[STACKSIZE],top,bottom;
void mInitStack() { top=bottom=0; }
void mPush(int x) { if ( top-bottom<=STACKSIZE ) { mstack[top]=x; top++; } }
int mPop() { int r=0; if ( top>bottom ) { r=mstack[top]; top--; } return r; }
void mShowStack() { int i; printf("["); for ( i=bottom;i<top;i++ ) printf("%d ",mstack[i]); printf("] "); }
void main()
{
int i,n,x,loop=1,s;
char buffer[80];
mInitStack();
scanf("%d",&n); for ( i=0;i<n;i++ ) { scanf("%d",&x); mPush(x); }
mShowStack();
while ( loop )
{ buffer[1]=0; gets(buffer); s=1;
switch ( buffer[1] )
{ case 'O':
case 'o': x=mPop(); break;
case 'U':
case 'u': x=atoi(buffer+5); mPush(x); break;
case 'n':
case 'N': loop=0; break;
default: s=0; break;
}
mShowStack();
}
mShowStack();

}

B. 數據結構實驗（用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. 用C語言編寫函數實現順序棧的進棧、退棧、取棧頂的演算法。

#include<stdio.h>
#define stacksize 100 //假定預分配的棧空間最多為100 個元素
typedef char elementtype; //假定棧元素的數據類型為字元 ,在此處可以自行設置
typedef struct
{
elementtype data[stacksize];
int top;
}seqstack;
// 置空棧
void initstack(seqstack *s)
{
s->top=-1;
//解釋一下，s->top 指向的是當前棧頂元素的位置
//當要向棧中添加一個新元素時，要先將s->top增加1，
//此時s->top 指向的就是新元素要添加的位置了。
//所以當棧為空時，填加第一元素時，top加1 後
//s->top的值就變為0，也就是第一個元素的位置了。
}
//判棧空
int stackempty(seqstack *s)
{
if(s->top==-1)
return 1; //若相等就返回1，否則為0
else return 0;
}
//入棧
void push(seqstack *s,elementtype x)
{
if(s->top==stacksize -1 ) //進棧前判斷棧是否已經滿了
printf(" stack overflow\n");
else
{
s->top= s->top + 1;
s->data[s->top]=x;
}
}
//出棧
elementtype pop(seqstack *s)
{
if(stackempty(s)) //出棧前先判斷當前棧中是否有內容
printf("stack is empty\n");
else
{
return s->data[s->top--]; //出棧後s->top的值會自減1
}
}
//取棧頂元素（只是想知道棧頂的值，並沒有出棧）
elementtype gettop(seqstack *s)
{
if(stackempty(s))
{
printf("stack already empty.\n");
}
else return s->data[s->top];
}
int main()
{
elementtype x;
seqstack *s; //定義一個棧，用指針的方式定義的
initstack(s); //想初始化定義好的棧
//當棧為空時調用出棧操作
pop(s);

//向棧中添加一個元素a
push(s,'a');

//觀察此時的棧頂元素
x=gettop(s);
printf("%c\n",x);

//再添加一個元素b
push(s,'b');

//觀察此時的棧頂元素
x=gettop(s);
printf("%c\n",x);

//彈出棧頂的元素
x=pop(s);
printf("%c\n",x);

//觀察彈出後棧頂元素的變化情況
x=gettop(s);
printf("%c\n",x);
return 0;
}

D. 求用C語言編寫一個程序實現順序棧初始化，出棧，入棧，判棧空，判棧滿，急需，謝謝

#define STACK_SIZE 100
#define PUSH_POP_SUCCESS 1
#define PUSH_POP_ERROR 0
struct _stackbuf {
int _collection[STACK_SIZE];
int _top;
};
typedef struct _stackbuf S_STACK;
typedef unsigned int u_int_f;
// 入棧
u_int_f push(S_STACK *stack, int d){
if (stack->_top >= STACK_SIZE) return PUSH_POP_ERROR;
stack->_collection[stack->_top++] = d;
return PUSH_POP_SUCCESS;
}
// 出棧
u_int_f pop(S_STACK *stack, int *e){
if (!stack->_top) return PUSH_POP_ERROR;
*e=stack->_collection[--(stack->_top)];
return PUSH_POP_SUCCESS;
}
int main(){
S_STACK stack = { {0},0 };
push(&stack, 1);
push(&stack, 2);
push(&stack, 3);
int gv = 0;
pop(&stack, &gv);
printf("%d\n", gv);
system("PAUSE");
return 0;
}

E. 關於C語言的順序棧的操作

這是我以前寫的，今天不想砍代碼，就發這個了
#include<stdio.h>
#include<stdlib.h>
#define N 100
//棧的結構定義
typedef struct
{
int elem[N];
int top;//棧頂
}Stack;
//循環隊列的結構定義
typedef struct
{
int elem[N];
int front;
int rear;
}Queue;
int Greatstack(Stack*);
int GreatQueue(Queue *);
int pop(Stack *s);
void show(Stack *s);
int push(Stack *s);
int popStack(Stack *s);
int enQueue(Queue *q);
int deQueue(Queue *q);
int printQueue(Queue *q);
void conversion();
void main()
{
char exit='N';
int ch;
int result,data;
int m,e;
Stack s;
Queue q;
s.top=0;//棧頂指向當前棧頂的下一位置
q.front=q.rear=0;
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.創建一個順序棧 .................(1) *\n");
printf("\t\t* 2.出棧.............................(2) *\n");
printf("\t\t* 3.入棧.............................(3) *\n");
printf("\t\t* 4.順序棧中元素依次出棧，並顯示.....(4) *\n");
printf("\t\t* 5.創建一個循環隊列.................(5) *\n");
printf("\t\t* 6.進隊.............................(6) *\n");
printf("\t\t* 7.出隊.............................(7) *\n");
printf("\t\t* 8.循環隊列中元素依次出隊，並顯示...(8) *\n");
printf("\t\t* 9.十進制數轉換為其它進制數.........(9) *\n");
printf("\t\t* 10.退出 ..............(10) *\n");
printf("\t\t********************************************\n");
printf("\n請選擇操作代碼：");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("創建一個順序棧\n");
result=Greatstack(&s);
if(result==0)printf("順序棧創建失敗，棧已滿!\n");
else printf("順序棧創建成功!\n");
system("pause");
break;
case 2:
printf("出棧:\n");
m=pop(&s);
if(m==0)printf("出棧失敗,棧已空!\n");
else
{
printf("順序棧出棧成功!\n");
printf("該棧剩餘元素為:");
show(&s);
}
//請加入出棧操作的代碼或函數調用
system("pause");
break;
case 3:
printf("進棧:\n");
printf("請輸入入棧的元素");
scanf("%d",&e);
result=push(&s,e);
if(result==0)printf("棧已滿!\n");
else
{
printf("順序棧入棧成功!\n");
printf("該棧剩餘元素為:");
show(&s);
}
//請加入進棧操作的代碼或函數調用
system("pause");
break;
case 4:
printf("順序棧中元素依次出棧，出棧序列為：\n");
popStack(&s);
//請加入依次出棧並顯示元素操作的代碼或函數調用
system("pause");
break;
case 5:
printf("創建一個循環隊列\n");
result=GreatQueue(&q);
if(result==0)printf("循環隊列創建失敗，循環隊列已滿!\n");
else printf("循環隊列創建成功!\n");
system("pause");
break;
case 6:
printf("入隊:\n");
data=enQueue(&q);
if(result=0) printf("隊已經滿了\n");
else printf("入隊成功\n");
//請加入入隊操作的代碼或函數調用
system("pause");
break;
case 7:
printf("出隊:\n");
data=deQueue(&q);
if(data=0) printf("隊已經空了\n");
else printf("出隊成功\n");
//請加入依次出隊操作的代碼或函數調用
system("pause");
break;
case 8:
printf("循環隊列中元素依次出隊，出隊序列為：\n");
//請加入依次出隊並顯示元素操作的代碼或函數調用
data=printQueue(&q);
system("pause");
break;
case 9:
printf("十進制數轉換為其它進制數：\n");
conversion();
//請加入十進制數轉換為其它進制數操作的代碼或函數調用
system("pause");
break;
case 10:
getchar();
printf("\n您是否真的要退出程序(Y/N):");
exit=getchar();getchar();
break;
default:
printf("\n無效輸入，請重新選擇...:");
}
}while(exit!='y'&&exit!='Y');
}
/*從鍵盤輸入一系列整數，當輸入值為0時，停止輸入，產生順序棧*/
/*返回0表示生成成功，1表示失敗*/
int Greatstack(Stack *s)
{
int e;
s->top=0;//棧頂指向當前棧頂的下一位置
printf("請依次輸入需要入棧的元素，以0表示輸入結束：");
do
{
scanf("%d",&e);
if(e!=0)
{ if(s->top>=N)return 0;//棧滿
s->elem[s->top++]=e;
}
}while(e!=0);
}
/*從鍵盤輸入一系列整數，當輸入值為0時，停止輸入，產生循環隊列*/
/*返回0表示生成成功，1表示失敗*/
int GreatQueue(Queue *q)
{
int e;
q->front=q->rear=0;//初始化隊列
printf("請依次輸入需要入棧的元素，以0表示輸入結束：");
do
{
scanf("%d",&e);
if(e!=0)
{ if((q->rear+1)%N==q->front)return 0;//隊滿
q->elem[q->rear]=e;
q->rear=(q->rear+1)%N;
}
}while(e!=0);
return 1;
}
int pop(Stack *s) //出棧
{
if(s->top==0)
return 0;
--s->top;
}
void show(Stack *s) //顯示棧中的元素
{
int i=s->top;
while(i!=0)
{
--i;
printf("%d ",s->elem[i]);
}
}
int push(Stack *s,int e) //入棧
{
if(s->top>=N)return 0;
s->elem[s->top++]=e;
}
int popStack(Stack *s) //順序棧中元素依次出棧，並顯示
{
while(s->top!=0)
{
--s->top;
printf("%3d",s->elem[s->top]);
}
return 0;
}
int enQueue(Queue *q) //入隊
{
int e;
printf("請輸入入棧的元素:");
scanf("%d",&e);
if((q->rear+1)%N == q->front) return 0;
q->elem[q->rear]=e;
q->rear=(q->rear+1)%N;
return 1;
}
int deQueue(Queue *q) //出隊
{
int *e;
if(q->front == q->rear) return 0;
e =q->elem[q->front];
q->front=(q->front+1)%N;
return 1;
}
int printQueue(Queue *q) //循環隊列中元素依次出隊，並顯示
{
if(q->front == q->rear) return 0;
for(;q->front!=q->rear;)
{
printf("%3d",q->elem[q->front]);
q->front++;
}
}
void conversion() //十進制數轉換為其它進制數
{
Stack p1;
int n,m;
puts("請輸入需要轉換的元素:");
scanf("%d",&n);
puts("請輸入需要轉換的進制:");
scanf("%d",&m);
p1.top=0;
while(n)
{
push(&p1,n%m);
n=n/m;
}
popStack(&p1);
}