⑴ c语言中的出栈是什么意思
可以去查看数据结构中的栈结构,FILF
先进后出。
出栈的意思是弹出栈顶的元素,
弹出的意思从内存中拷贝出来,删除原有元素!
⑵ c语言的简单的进栈出栈
就用这堆函数就可以了,不懂再追问
#include
<string.h>
#define
MaxSize
100
int
mystack[MaxSize];/*
第0个单元保存现在的长度
*/
/*
初始化函数
*/
void
init_stack(int*
stack){
memset(stack,0,sizeof(stack));
}
/*
入栈函数
*/
void
push_back(int*
stack,int&
num){
if(stack[0]<MaxSize-1){
++stack[0];
stack[
stack[0]
]
=
num;
}
else{
printf("ERORR!\n");
}
}
/*
返回栈空间
*/
int
size(int*
stack){
return
stack[0];
}
/*
返回栈顶函数
*/
int
top(int*
stack){
if(stack[0]>0){
return
stack[
stack[0]
];
}
else{
printf("ERORR!\n");
return
-1;
}
}
/*
出栈函数
*/
void
pop(int*
stack){
if(stack[0]>0){
--stack[0];
}
else{
printf("ERORR!\n");
}
}
⑶ 用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语言 进栈和出栈:
闲得没事干,跟你详细讲讲吧。
首先要弄明白一点,栈的结构是“先进后出“的,就像你堆积木一样,第一根放在最底层的地面上,然后一根一根往上堆。前一个放上去的总是被后一个放上去的压在底下。那我当我再想里面放一根的时候,总不能放中间或者放底下吧(除非你很无聊 很寂寞 闲的蛋疼了 先一根根把堆在上面的全部拿出来 然后把要放进去的那根放上去 最后又把刚才搬下来的有重新搬上去......此处省去几万字)所以要往上面加东西的时候,就得放在最上面。
以上就是进栈的原理,怎么出栈呢,很简单,直接从”积木"的最顶端取下来就行了。
ok,以上比喻完了,希望你能看得明白。接下来讲程序不说积木了:),由上面的分析 我们可以知道一个道理,对于栈的操作,栈顶的元素很重要(也就是积木最上面的那根)。为什么呢。无论是出栈还是进栈,都跟那哥们有直接的联系。你想啊,如果要是有元素要进栈的话,那么它就不能当“老顶”了,那老顶之位就要交给压在它上头那位了;如果出栈呢,它也不能当老顶了,老顶之位就要交到原来压在它底下的那个。
ok,所以一般的栈都将栈顶的那个元素所在的位置(内存地址--数组类型的,或者指针---节点类型的)视为栈的栈顶~!通过它来对栈进出进行操作。
一般来说(或者在我出生以来看到过的)栈有两种内存结构(注意是是内存结构,有的书说是存储结构,都一样一样滴),一种是连续的,一种是不连续的,连续的基本上就是数组了,不连续的基本上就是链表类型的啦。你上面的程序就是链表类型的,每个节点都有个指针指向它“底下”的节点(我觉得“底下”比下一个更容易理解)。通过这种你链我 我链它的方式,把一组数据连在一起。
进栈:
int Push(STACK *S,int e)//进栈
{
SNode *p; //step1:这个编程习惯不好,没定义一个指针就应该把它指向NULL
p=(SNode *)malloc(sizeof(SNode)); //step2:为你的节点分配内存
if(!p)
return ERROR;
p->data=e; //step3:当然了,你那个传进来的e是相当于temp,用来传值的,ok,那就把它的 数据给p咯,p实际指向的是一块内存块,用来装节点的
p->next=S->top; //step4:回到上面积木问题,进栈的时候,原来的老顶要给新来的让位,但是如果这时候的top节点直接赋给新来的元素的话,那么那个原来的老顶是不是从此以后都找不到它了?所以,先把新来的元素的next指针指向当前的老顶,这样的话,以后通过next指针就可以找到它了。
S->top=p; //当然,都已经处理好以前老顶的身后事了(就是以后可以通过p的next指针找到它了)那么“让位”就可以进行了,这时,p便戴上了 老顶 之帽了
S->length++; //既然人数都增加了,那就到公安局登记入户口吧
return OK; //一切over,现在这个栈stack的栈顶位置就是你刚才新加进来的p了,通过stock.top指针就可以访问到栈顶,然后出栈也是同理的,ok,all over
}
⑸ 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语言中什么是出栈
栈是一种数据结构,一个栈相当于一个盒子,把东西(数据)放入盒子里的过程叫做入栈,把东西从盒子里取出来的过程叫做出栈。栈还有一个特殊的规则,就是先进后出,即盒子里的东西只能叠加摆放,放进去的下一件东西只能堆在前一件东西的上面,取出时只能先取出盒子最上面的一件东西。出栈也就是将栈指针所指的数据从栈中弹出的过程,每一次出栈的一定是栈顶元素,出栈后栈指针向下移动一位指向下一个元素。习惯上入栈用PUSH表示,出栈用POP表示。
⑺ C语言出栈是什么意思
栈 是c中一个容器,先进先出, 出栈就是把数据取出来。输出栈的值就是把出栈的数据打印出来。看一下书就明白的。
⑻ C语言 进栈出栈
#include <stdio.h>
#include <malloc.h>
#define max 10
typedef struct
{
char a[max];
int top;
}qstype;
void init(qstype *s)
{
s->top =-1;
}
int push(qstype *s,char x)
{
if(s->top >= max)
{
return 0;
}
else
{
s->top ++;
s->a[s->top] = x;
return 1;
}
}
char pop(qstype *s)
{
if(s->top < 0)
{
return 0;
}
else
{
return s->a[s->top];
s->top --;
}
}
void print(qstype *s)
{
int i;
for(i=0;i<s->top;i++)
printf("%c",s->a[i]);
}
int main(void)
{
char ch;
qstype *A,*B;
A=(qstype *)malloc(sizeof(qstype));
B=(qstype *)malloc(sizeof(qstype));//指针没有初始化
init(A);
init(B);
scanf("%c",&ch);
while(ch!='\n')
{
if(push(A,ch) == 0)
break;
scanf("%c",&ch);
}
print(A);
return 0;
}
⑼ 关于c语言出栈问题
pop函数需要向外界传递两个信息:①出栈操作成功与否;②出栈的元素的值。①可以通过返回值传递给外界,那么②呢?C语言中函数只能有一个返回值,不可能既返回a又返回b,当然你可以通过返回一个结构体当中封装了这两者来实现,但这太麻烦不符合函数初衷,所以②就通过函数的第二个参数传递给外界,即出栈的元素的值保存在参数2中。既然如此,参数2必然要做到能够修改外界实参的值,而如果使用ElemType类型,在函数中修改形参的值不可能影响到外部实参,所以必须使用ElemType*指针类型,并传递外部实参的地址作为参数,然后通过指向实参的指针去修改实参的值。
⑽ 一个C语言编程题
这个问题可以分为3部分
1、输入一个字符串,将其格式化的储存在一个数组中,以方便的记录表达式中数和各个符号的出现顺序
约定在数组中记录时,每个数或符号用两个整数来记录
第一个整数记录该位是什么东西,0表示是一个数,1表示是括号,2表示反括号,3、4、5、6分别表示乘除加减号
如果该位是一个数,那么第二个整数记录着个数的具体取值,否则记录该位的符号的ASCII码
比如字符串"(1-23)"会被转化成二位数组{ {1,'('} , {0,1} , {6,'-'} , {0,23} , {2,')'}}
这个转化过程每什么技巧性,对原字符串各位顺次判断并处理即可
原先的字符串中可能出现一元运算符正号'+'和负号'-',为了处理方便,一律在其前面加个0,改写成"0+..."或者"0-..."
另外为了之后转化逆波兰表达式方便,处理过程中会在转化出的数组的首尾一律添加一对括号
2、将之前所提到的格式数组转化为逆波兰表达式
约定依然用二位数组记录一个逆波兰表达式,并且格式与之前的数组相同,除了没有括号以外
比如逆波兰表达式 1 2 - 35 +,会被记录成{ {0,1} , {0,2} , {6,'-'} , {0,35} , {5,+}}
转化时,需要用一个栈
具体转化操作如下:
顺次处理格式数组的每一位,对其作判断
如果该位是一个数或者是括号'(',,将其入栈
如果该位是乘号'*'或者除号'/',不断进行出栈操作直到栈顶元素是个括号'('或者加号'+'或者减号'-',然后将这个乘号或者除号入栈
如果该位是加号'+'或者减号'-',不断进行出栈操作直到栈顶元素是个括号'(',然后将这个加号或者减号入栈
如果该位是反括号')',那么不断进行出栈操作直到有一个括号'('出栈
在上述操作中,所有的出栈元素,除了括号'('以外,都被顺次添加到所要生成的逆波兰表达式的末尾
这样就转化出了一条逆波兰表达式
3、对逆波兰表达式求值
求值时,也需要用到一个栈
求值步骤如下:
顺次处理逆波兰表达式的每一位,对其作判断
如果该位是一个数,将这个数入栈
如果该位是一个运算符,那么连续进行两次出栈操作,可以得到栈顶的两个元素,对这两个元素用该位的运算符做运算,将所得的结果入栈
比如,如果当时栈顶元素是3,次栈顶的元素是2,运算符是减号'-',那么连续两次出栈得到3和2两个元素,再将2-3的运算结果1入栈
注意有些运算符(减号和除号)不符合交换律,因此运算时必须是次栈顶元素在前、栈顶元素在后,顺序不能反
当每一位都处理完了之后,只要输入的是一个合法的逆波兰表达式,必然栈中只剩下一个元素,这个元素就是逆波兰表达式求值的结果
源代码如下:
#include <stdio.h>
#include <ctype.h>
void transform(char *str,int a[][2],int *n)
//将输入的字符串转化为格式化的数组以记录输入的表达式,str为输入的字符串,a为目标数组,n记录数组a的大小
{
int i;
*n=1;
a[0][0]=1;
a[0][1]='(';//在表达式首添加一个括号
for (i=0;str[i];)
{
if (isdigit(str[i]))
{
a[*n][0]=0;
a[*n][1]=0;
while (isdigit(str[i]))
{
a[*n][1]=a[*n][1]*10+str[i]-'0';
i++;
}
}
else
{
if (str[i]=='(') a[*n][0]=1;
else if (str[i]==')') a[*n][0]=2;
else if (str[i]=='*') a[*n][0]=3;
else if (str[i]=='/') a[*n][0]=4;
else if (str[i]=='+' || str[i]=='-')
{
if (i==0 || (!isdigit(str[i-1]) && str[i-1]!=')'))
{
a[*n][0]=0;
a[*n][1]=0;
(*n)++;
}
if (str[i]=='+') a[*n][0]=5;
else a[*n][0]=6;
}
a[*n][1]=str[i];
i++;
}
(*n)++;
}
a[*n][0]=2;
a[*n][1]=')';//在表达式尾添加一个反括号
(*n)++;
}
void poland(int a[][2],int n,int p[][2],int *m)
//将格式化数组转化为逆波兰表达式,a为输入的数组,n为其长度,p为输出逆波兰表达式的目标,m记录逆波兰表达式的长度
{
int i;
int stack[1000];//转化所用的栈
int depth;//栈的深度
depth=0;
*m=0;
for (i=0;i<n;i++)
{
if (a[i][0]==0) stack[depth++]=i;
else if (a[i][0]==1) stack[depth++]=i;
else if (a[i][0]==2)
{
while (a[stack[depth-1]][0]!=1)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
depth--;
}
else if (a[i][0]==3 || a[i][0]==4)
{
while (a[stack[depth-1]][0]==0 || a[stack[depth-1]][0]==3 || a[stack[depth-1]][0]==4)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
stack[depth++]=i;
}
else if (a[i][0]==5 || a[i][0]==6)
{
while (a[stack[depth-1]][0]!=1)
{
depth--;
p[*m][0]=a[stack[depth]][0];
p[*m][1]=a[stack[depth]][1];
(*m)++;
}
stack[depth++]=i;
}
}
}
void print_poland(int p[][2],int m)
//打印逆波兰表达式,p为逆波兰表达式,m为表达式长度
{
int i;
for (i=0;i<m;i++)
{
if (p[i][0]==0) printf("%d",p[i][1]);
else printf("%c",p[i][1]);
}
putchar('\n');
}
double evaluate(int p[][2],int m)
//对逆波兰表达式求值,p为逆波兰表达式,m为表达式长度
{
double stack[1000];//求值所用的栈
int depth;//栈的深度
int i;
depth=0;
for (i=0;i<m;i++)
{
if (p[i][0]==0) stack[depth++]=p[i][1];
else
{
double a,b;
b=stack[--depth];
a=stack[--depth];
if (p[i][0]==3) stack[depth++]=a*b;
else if (p[i][0]==4) stack[depth++]=a/b;
else if (p[i][0]==5) stack[depth++]=a+b;
else stack[depth++]=a-b;
}
}
return stack[0];
}
int a[1000][2];
int n;
int p[1000][2];
int m;
main()
{
transform("5*(8-2)+9",a,&n);
poland(a,n,p,&m);
print_poland(p,m);
printf("The result of the expression is %lf\n",evaluate(p,m));
return;
}