c語言順序棧
1. 建立順序存儲的棧，並對之進行入棧、出棧、取棧頂元素操作的c語言演算法
#include "process.h"
#include "stdio.h"
#include "assert.h"
const int stackIncreament=20; //棧溢出時擴展空間的增量
class SeqStack
{
private:
int top; //棧頂指針
int MAX; //棧的最大可容納個數
int *elements; //存放棧中元素的棧數組
void overflowProcess(); //棧的溢出處理
public:
SeqStack(int sz=50); //構造函數
~SeqStack() { delete[]elements; } //析構函數
bool pop1(int & x); //元素出棧
void push1(const int & x); //新元素進棧
bool IsEmpty1()const; //判斷棧空與否
bool IsFull1()const; //判斷棧滿與否
void output1(); //輸出元素進棧順序
void output(int x); //輸出x
};
SeqStack::SeqStack(int sz):top(-1),MAX(sz)
{
elements=new int[MAX]; //創建棧的數組空間
assert(elements!=NULL); //斷言：動態存儲分配成功與否
}
bool SeqStack::pop1(int & x) //棧頂元素出棧
{
if(IsEmpty1()==true) return false;//判棧空否，若棧空則函數返回
x=elements[top--]; //棧頂指針退1
return true; //退棧成功
}
void SeqStack::push1(const int & x) //新元素進棧
{
if(IsFull1()==true) overflowProcess(); //棧滿則溢出處理
elements[++top]=x; //棧頂指針先加1,再進棧
}
bool SeqStack::IsEmpty1() const //判斷棧空與否
{
return (top==-1)?true:false;
}
bool SeqStack::IsFull1()const //判斷棧滿與否
{
return (top==MAX-1)?true:false;
}
void SeqStack::overflowProcess() //棧的溢出處理
{
//私有函數，擴充棧的存儲空間。
int *Array=new int[MAX+stackIncreament]; //和課本不一樣 ??????????
if(Array==NULL)
{
printf("存貯分配失敗 ! \n");
exit(1);
}
for(int i=0;i<=top;i++) Array[i]=elements[i];
MAX=MAX+stackIncreament;
delete []elements;
//elements=Array;
}
void SeqStack::output1() //元素入棧順序輸出
{
int n=0;
int t=top;
for(int i=0;i<top;i++)
{
printf(" %d",elements[i]);
n++;
if(n%10==0)
printf("\n");
}
}
void SeqStack::output(int x) //棧內元素輸出
{
printf(" %d",x);
}
//----------------------順序棧函數--------------------------//
void SeqStack1( SeqStack A)
{
int x=-1;
int X;
printf("請輸入要入棧A的元素值,以0結束：\n");
while(x!=0){ //新元素進棧
scanf("%d",&x);
A.push1(x);
}
printf("\n元素進棧順序是 :");
A.output1();
printf("\n\n");
A.pop1(X); //元素出棧
if(!A.pop1(X))
printf("元素出棧失敗 ！\n");
else
{
printf("\n棧頂元素是： ");
A.output(X);
printf("\n");
printf("\n元素出棧的結果是 : ");
A.output(X);
while(A.pop1(X))
A.output(X);
}
}
void main()
{
printf("----------順序棧的調試----------\n");
printf("\n \n");
SeqStack A;
SeqStack1(A);
printf("\n \n");
}
2. 求用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;
}
3. C語言編程：順序棧的入棧與退棧及讀頂元素
舉一個例子說明 《停車場管理》
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#include "stdio.h"
#include "malloc.h"
#define max_stop 5 // 停車場容量//
#define PRICE 8 //停車單價 //
typedef struct//汽車//
{ char *license[20]; //汽車//
}car;
typedef struct //停車場//
{ car stop[max_stop]; //停車場//
int top;
}parking;
void come(car p,parking *tcc)
{
if(tcc->top>=max_stop-1){printf("已滿！！");}
else
{
printf(" 輸入到來汽車的車牌號碼 : ");
scanf("%s",p.license);
printf("\n");
tcc->top++; tcc->stop[tcc->top]=p;//如果停車場沒有滿就入場//
}
}
void display(car p,parking *tcc)
{
int n=0;
if(tcc->top==-1)printf(" 停車場內無汽車！\n"); //指針在-1處 停車場內無車//
else{ // 有車 //
printf("●停車場內的車為：\n");
while(n<=tcc->top)
{
printf("第 %d 輛 %s\n",n+1,tcc->stop[n].license);
n++;
}
}
}
void leave(car p,parking *tcc)
{
car leavecar;
int num,money,time;
printf(" 輸入將要離開的汽車車位號碼：");
scanf("%d",&num);
num--;
if(num>tcc->top||num<0)printf(" 你的輸入有誤 請檢查預備出停車場的車輛號碼\n");
else
{
printf(" 輸入此車停留的時間 : ");
scanf("%d",&time);
if(time<=0)printf(" 你的輸入有誤 請檢查停車時間\n");
else
{
leavecar=tcc->stop[num];
while(num<tcc->top)
{
tcc->stop[num]=tcc->stop[num+1];
num++;
}
tcc->top--;
}
}
if((num<=tcc->top) && (num>=0))
{
money=time*PRICE;
printf("● %s 已經離開停車場 停留%d小時 收費%d元",leavecar.license,time,money);
}
}
void welcome() //歡迎界面//
{
printf(" ●歡迎適用本程序●\n");
printf(" 本程序為停車場的模擬管理程序，有車到來時請按 C 鍵\n");
printf(" 然後根據屏幕提示進行相關操作，有車要走時請按 L 鍵\n");
printf(" 然後根據屏幕提示進行相關操作，若需要幫助請按 H 鍵\n");
printf(" 然後根據屏幕提示進行相關操作，要退出程序請按 Q 鍵\n");
}
void main()
{
char key;
car p;
parking *tcc;
tcc=(parking *)malloc(sizeof(parking));
tcc->top=-1;
while(1)
{
flushall();
printf(" 請輸入您的操作 : ");
scanf("%c",&key);
if(key=='c'||key=='C')come(p,tcc);
else if(key=='l'||key=='L')leave(p,tcc);
else if(key=='d'||key=='D')display(p,tcc);
else if(key=='h'||key=='H')welcome();
else if((key=='q')||(key=='Q'))break;
else printf(" 您的輸入有誤 ! ! 請重新輸入：\n");
}
}
4. 用C語言編寫順序棧的建立，出棧、進棧、取棧頂元素 ，誰幫看看這程序
親..錯的太多了..沒法改了..
給你指出幾個明顯的錯誤吧..
1.函數聲明要加分號.
int Empty_SeqStack()
int Push_SeqStack()
int Pop_SeqStack()
int taPop_SeqSck()
2.主函數中x未定義.
void main()
{
printf("----------順序棧的調試----------\n");
printf("\n \n");
scanf("%s",x);
....
}
3.形參實參數量與類型不符.
int Push_SeqStack(SeqStack *s,datatype *x)
Push_SeqStack(x);
4.datatype類型未定義.
typedef struct
{
datatype data[MAXSIZE];
...
}SeqStack;
5. 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();
}
6. C語言順序棧的銷毀演算法怎麼寫
#include<stdio.h>
#include<stdlib.h>
typedefstructNode
{
intdata;
structNode*Next;
}NODE;
typedefstructStack
{
NODE*ptop;
NODE*pBottom;
}STACK;
voidinit(STACK*pS);//初始化
voidpush(STACK*pS,intnum);//圧棧
voidtraverse(STACK*pS);//遍歷棧
voidclear(STACK*pS);//清空
intempty(STACK*pS);//判斷是否為空
intpop(STACK*pS,int*tmp);//出棧
intmain(void)
{
STACKS;
intt=0;
init(&S);
push(&S,1);
push(&S,8);
push(&S,6);
push(&S,2);
push(&S,3);
traverse(&S);
if(pop(&S,&t))
{
printf("出棧成功!本次出棧元素為[%d] ",t);
}
else
{
printf("出棧失敗! ");
exit(1);
}
traverse(&S);
clear(&S);
traverse(&S);
return0;
}
voidinit(STACK*pS)//初始化
{
pS->ptop=(NODE*)malloc(sizeof(NODE));
if(NULL==pS)
{
printf("內存分配失敗! ");
exit(1);
}
else
{
pS->pBottom=pS->ptop;
pS->ptop->Next=NULL;
}
return;
}
voidpush(STACK*pS,intnum)//圧棧
{
NODE*ptmp=(NODE*)malloc(sizeof(NODE));
if(NULL==ptmp)
{
printf("內存分配失敗! ");
exit(1);
}
else
{
ptmp->data=num;
ptmp->Next=pS->ptop;
pS->ptop=ptmp;
}
return;
}
voidtraverse(STACK*pS)//遍歷棧
{
if(empty(pS))
{
printf("棧為空! ");
exit(1);
}
else
{
NODE*p=NULL;
p=pS->ptop;
while(p!=pS->pBottom)
{
printf("%d",p->data);
p=p->Next;
}
printf(" ");
}
return;
}
intempty(STACK*pS)
{
if(pS->ptop==pS->pBottom)
{
return1;
}
else
{
return0;
}
}
intpop(STACK*pS,int*tmp)
{
NODE*r=NULL;
if(empty(pS))
{
return0;
}
else
{
r=pS->ptop;
*tmp=r->data;
pS->ptop=r->Next;
free(r);
r=NULL;
return1;
}
}
voidclear(STACK*pS)//清空
{
NODE*q=NULL,*p=NULL;
if(empty(pS))
{
printf("棧為空! ");
exit(1);
}
else
{
while(q!=pS->pBottom)
{
q=pS->ptop;
p=q;
pS->ptop=q->Next;
free(q);
q=p;
}
pS->ptop=pS->pBottom;
//printf("[%p][%p] ",pS->pBottom,pS->ptop);
}
return;
}
[email protected] 一起學習，C語言愛好者。
7. 用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;
}
8. c語言 棧的操作
#include
#include
#define Max 100
typedef char T;
typedef struct MyStack
{
T aa[Max];
unsigned int p;
} stack;
//創建空棧
stack* createEmptyStack()
{
stack* st = (stack *)malloc(sizeof(stack));
int i=0;
for(i=0;i<Max;i++)
st->aa[i]=0;
st->p=0;
return st;
};
//棧判空
int isEmpty(const stack* st)
{
if(st->p==0) return 1;
else return 0;
};
//求棧的大小
unsigned int size(const stack* st)
{
return st->p;
};
//push操作
void push(stack* st,const T a)
{
st->p=st->p+1;
if(st->p==Max)
{
printf("棧滿\n");
st->p--;
return;
}
st->aa[st->p]=a;
};
//pop操作
T pop(stack* st)
{
if(isEmpty(st))
{
printf("棧空");
return NULL;
}
char t=st->aa[st->p];
st->p=st->p-1;
printf("%c ",t);
return t;
};
//棧銷毀
void destroy(stack* st)
{
free(st);
};
int main()
{
stack* st = createEmptyStack();
if(isEmpty(st)) printf("MyStack is empty\n");
else printf("MyStack is not empty\n");
push(st,'a');
push(st,'b');
push(st,'c');
push(st,'d');
push(st,'e');
printf("%d\n",size(st));
while(!isEmpty(st)) pop(st);
destroy(st);
system("pause");
return 0;
}
9. C語言數據結構：利用兩個順序棧來實現一個列隊的功能時遇到的問題
假設s1、s2的深度都是3
s1已滿，從棧頂到棧低依次是：5、4、3
s2非空，從棧頂到棧底依次是：1、2
此時要想在入棧一個元素6的話，按照你的想法，
得把s1的數據出棧到一個緩沖區，然後把緩沖區中，在原來s1棧底的3挪動到s2的棧頂，
然後s1的4、5依次壓回棧s1，然後s1就能夠空出棧頂的一個位置了，對吧？
但是，這個放置s1出棧元素的緩沖區。。。也得是一個棧結構吧？否則的話，你怎麼知道s1向緩沖區出棧的u元素
順序呢？
這樣就不是雙棧模擬隊列了，勢必還得用到一個中間棧s3來滿足你這種處理方式~
因此，雙棧模擬隊列時，當棧s1滿，棧s2非空時，棧s1再執行進棧操作。因為雙棧是沒有s3的~
10. c語言函數參數入棧順序
從右向左；
例如：f（int a, int b, int c）
c先入棧，然後b，其次a；