⑴ 用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");
}