⑴ 用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語言 用數組實現棧的進出
#include <stdio.h>
#include<string.h>
void main()
{
char behavior[10];
int stack[100];
int i,n,cnt;
scanf("%d",&n);
for(i=n-1;i>=0;i--)
{
scanf("%d",&stack[i]);
}
scanf("%d",&cnt);
while(cnt--)
{
memset(behavior,0,5);
scanf("%s",behavior);
if(!strcmp(behavior,"PUSH"))
{
for(i=n++;i>0;i--)
{
stack[i]=stack[i-1];
}
scanf("%d",&stack[0]);
continue;
}
if(!strcmp(behavior,"POP"))
{
for(i=0;i<n;i++)
{
stack[i]=stack[i+1];
}
n--;
}
}
for(i=n-1;i>=0;i--)
{
printf("%d ",stack[i]);
}
printf("\n");
}
程序輸入的時候沒有提示（可以加），不知道你習不習慣。
⑶ 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語言編寫函數實現順序棧的進棧、退棧、取棧頂的演算法。
#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;
}
⑸ C語言寫 棧隊列(先進先出的)
#include<stdio.h>
#include<malloc.h>typedef struct node /*定義新類型結構體結點*/
{
int data;/*數據成員可以是多個不同類型的數據*/
struct node *next;/*指針變數成員只能是一個*/
}NODE;/*節點結束*/typedef struct qnode /*定義結點類型的變數名*/
{
NODE *front;/*設定結點頭指針變數*/
NODE *rear;/* 設定結點尾指針變數*/
}QNODE; /* 鏈隊列的結點定義 */ void InitQueue(QNODE *Q)/*定義指針Q*/
{
NODE *p;/*定義指針p*/
p=(NODE *)malloc(sizeof(NODE));/*分配結點位元組的容量*/
Q->front=p; /*指定頭指針p*/
Q->front->next=NULL;/*建立空隊列*/
Q->rear=Q->front;/*改變Q的值*/
printf("The init is complete!");}
void *QueuePush(QNODE *Q)
{
NODE *p;
p=(NODE *)malloc(sizeof(NODE));/*分配結點位元組的容量*/
printf("Please input a number :");/*請輸入一個數*/
scanf("%d",&p->data);/*給第一個結點賦值*/
p->next=NULL;/*指定尾結點*/
Q->rear->next=p;/*指定尾新結點p的地址*/
Q->rear=p;/*指定隊尾結束*/
printf("The %d has been pushed into the Queue!",p->data);/*顯示數據成員*/
return 0;/*程序結束*/
}
void *QueuePop(QNODE *Q)
{
NODE *p;/*定義結點指針*/
if(Q->front->next==NULL) return 0;/*判斷對前是否為空，如果是就結束*/
p=Q->front->next;/*指向下以個成員*/
Q->front->next=p->next;/*依次向下循環*/
if(Q->rear==p) Q->rear=Q->front;/*隊尾與對頭相同*/
printf("The %d has been pop from the queue! \n",p->data);/*顯示隊列成員*/
free(p);
return 0;
}
void *PrintQueue(QNODE *Q)
{
NODE *p;/*定義鏈結點*/
p=Q->front->next;/*指定對頭*/
while(p!=NULL)/*如不為空*/
{
printf("%5d",p->data);/*顯示數據成員*/
p=p->next;/*指定第二個成員*/
}
return 0;
} void main()
{
QNODE *T;
int i=0;/*取值*/
printf("1.InitQueue 2.QueuePush 3.QueuePop 4.PrintQueue 5.Quit \n");
while(i!=5)
{
printf("Please choose the gongneng:");
scanf("%d",&i);
printf("\n");
switch(i)
{
case 1: InitQueue(T); printf("\n"); break;
case 2: QueuePush(T); printf("\n"); break;
case 3: QueuePop(T); printf("\n"); break;
case 4: printf("The queue's numbers are:");
PrintQueue(T); printf("\n"); break;
case 5: printf("\n"); break;}
}
}
⑹ c語言，我想學習堆棧，先進後出的規則我懂，我想知道具體過程，可以舉個例子最好，謝謝
下面是一個棧的例子：
#include <stdio.h>
#define STACK_SIZE 100
class Stack {
private:
int *buf;
int top;
public:
Stack(){
buf = new int[STACK_SIZE];
top = 0;
}
void push(int val) {
buf[top++] = val;
}
bool isEmpty() {
return top == 0;
}
int pop() {
if(!isEmpty() ) {
top --;
return buf[top];
}
printf("The STACK is empty now...");
return -1;
}
~Stack() {
delete buf;
}
};
int main()
{
Stack stack;
int a[5] = {2, 4, 5, 1, 7};
for(int i=0; i<5; i++)
stack.push(a[i]);
while(! stack.isEmpty() ) {
printf("%d ", stack.pop());
}
printf("\n");
}
⑺ 棧是先進先出還是先進後出
棧是先進後出。
棧作為一種數據結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底，最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。
棧是允許在同一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱為棧頂(top)，另一端為棧底(bottom)；棧底固定，而棧頂浮動；棧中元素個數為零時稱為空棧。插入一般稱為進棧（PUSH），刪除則稱為退棧（POP）。棧也稱為先進後出表。
順序：
1、入棧即先入後出順序;隊，則是先入先出ABCDEFG順序入棧，出棧順序是GFEDCBA，倒序出棧，先入的後出，後入的先出ABCDEFG順序入隊，出隊順序是ABCDEFG，就是入隊順序。
2、入棧的順序規律是排在前面的先進，排在後面的後進。入棧順序: a、b、c、d。
3、出棧的順序規律是排在前面的先出，排在後面的後出。出棧順序可以是:d、c、b、a;a、b、c、d;b、a、c、d等很多。
⑻ 用c語言編寫一個程序實現順序棧的初始化，出棧和入棧。急需，謝謝
#defineSTACK_SIZE100
#definePUSH_POP_SUCCESS1
#definePUSH_POP_ERROR0
struct_stackbuf{
int_collection[STACK_SIZE];
int_top;
};
typedefstruct_stackbufS_STACK;
typedefunsignedintu_int_f;
//入棧
u_int_fpush(S_STACK*stack,intd){
if(stack->_top>=STACK_SIZE)returnPUSH_POP_ERROR;
stack->_collection[stack->_top++]=d;
returnPUSH_POP_SUCCESS;
}
//出棧
u_int_fpop(S_STACK*stack,int*e){
if(!stack->_top)returnPUSH_POP_ERROR;
*e=stack->_collection[--(stack->_top)];
returnPUSH_POP_SUCCESS;
}
intmain(){
S_STACKstack={{0},0};
push(&stack,1);
push(&stack,2);
push(&stack,3);
intgv=0;
pop(&stack,&gv);
printf("%d ",gv);
system("PAUSE");
return0;
}
⑼ 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();
}
⑽ 建立順序存儲的棧，並對之進行入棧、出棧、取棧頂元素操作的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");
}