栈c语言

Ⅰ c语言中的栈是指什么啊

是一种数据结构.这种结构的存取原则相当于取放盘子的过程,放的时候将盘子一个一个堆起来放,取的时候先取原先最后放入的一个,然后依次类推.即后进先出的原则.
栈有顺序(数组等)和链式(链表)两种存储结构,它的逻辑结构实质是线性表中的一种,只是这种线性表只允许在其中一端进行存取操作.更为详细的解释请参考数据结构一书!

Ⅱ C语言！！！栈

#defineSTACK_SIZE100//定义栈容量为100
intcontents[STACK_SIZE];//定义数组contents用作栈
inttop=0;//定义并初始化栈顶指针为0

//函数作用：清空栈
voidmake_empty(void)
{
top=0;//直接将栈顶指针置0
}

//函数作用：判断栈是否为空
boolis_empty(void)
{
returntop==0;//返回top是否等于0
}

//函数作用：判断栈是否已满
boolis_full(void)
{
returntop==STACK_SIZE;//返回top是否等于STACK_SIZE
}

//函数作用：向栈中压入一个元素i
voidpush(inti)
{
if(is_full())//如果栈已满
stack_overflow();//执行栈上溢操作
else//否则可以入栈
contents[top++]=i;//向栈中压入i，然后将栈顶指针+1
}

//函数作用：弹出栈顶元素并返回
intpop(void)
{
if(is_empty())//如果栈为空
stack_underflow();//执行栈下溢操作
else//否则可以出栈
returncontents[--top];//返回栈顶元素，然后将栈顶指针-1
}

Ⅲ C语言中的栈、堆是什么

C语言中的堆和栈都是一种数据项按序排列的数据结构。

栈就像装数据的桶或箱子

我们先从大家比较熟悉的栈说起吧，它是一种具有后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。

这就如同我们要取出放在箱子里面底下的东西（放入的比较早的物体），我们首先要移开压在它上面的物体（放入的比较晚的物体）。

堆像一棵倒过来的树

而堆就不同了，堆是一种经过排序的树形数据结构，每个结点都有一个值。

通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

由于堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取书。

虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。

(3)栈c语言扩展阅读：

关于堆和栈区别的比喻

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

参考资料来源：网络-堆栈

Ⅳ C语言中，什么是栈，什么是堆

1、栈区(stack):由编译器自动分配释放，存放函数的参数值，局部变量等值。局部变量，任务线程函数之类的是放在（使用）栈里面的，栈利用率高一些。其操作方式类似于数据结构中的栈。特别，栈是属于线程的，每一个线程会有一个自己的栈。

2、堆区(heap):一般由程序员分配释放，若程序员不释放，则可能会引起内存泄漏。注意它和数据结构中的堆是两回事，分配方式倒是类似于链表，常见的就是malloc出来的都是属于堆区，就像固定出来的区域，到free的时候才释放，有点类似全局的，静态的。

(4)栈c语言扩展阅读

栈内存是由编译器自动分配与释放的，它有两种分配方式：静态分配和动态分配。

1、静态分配是由编译器自动完成的，如局部变量的分配（即在一个函数中声明一个int类型的变量i时，编译器就会自动开辟一块内存以存放变量i）。

2、动态分配由alloca函数进行分配，但是栈的动态分配与堆是不同的，它的动态分配是由编译器进行释放，无需任何手工实现。

Ⅳ C语言栈是什么，栈在哪，需要定义吗

栈是一种数据结构，后进先出，即最后进入栈的数据最先弹出。

c语言中没有栈这种数据类型，需要自己编程构建。

Ⅵ 什么是C语言中的栈

栈是一种数据存储的结构，其实跟数组，队列的存储方式是一样的，主要是它有存储的规则，就是先进后出，只在栈定操作。
也就是说数据存入一个栈，取出的是最后一个存入的数据，必须从最后一个开始取。
可参考网络和维基网络

Ⅶ c语言中栈的定义

保存数据之用，先压栈最后出栈，不要与系统关键字同名就OK

Ⅷ 栈的c语言实现基本操作

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#definestack_init_size20
#defineincreasesize10;
typedefintElemType;
typedefstructnode{
	ElemType*base;
	ElemType*top;
	intsize;
}stack;

voidcreat(stack*s)
{
	s->base=(ElemType*)malloc(sizeof(ElemType));
	if(!s->base)
	{
		exit(0);
	}
	s->base=s->top;
	s->size=stack_init_size;
}

voidpush(stack*s,ElemTypee)
{
	if(s->top-s->base>=s->size)
	{
s->base=(ElemType*)realloc(s->base,(s->size+increasesize)*sizeof(ElemType));
		if(!s->base)
		{
			exit(0);
		}
		s->top=s->base+s->size;
		s->size+=increasesize;
	}
	*(s->top)=e;
	s->top++;	
}

voidpop(stack*s,ElemType*e)
{
if(s->top==s->base)
{
	return;
}	
*e=*--(s->top);
}
intstacklen(stacks)
{
	return(s.top-s.base);
}
intmain()
{
	stacks;
	intn;
ElemTypee1,e2,d;
inti=1,j=1;
push(&s,i);
push(&s,j);
scanf("%d",&n);
while(n--)
{
pop(&s,&e1);
	pop(&s,&e2);
	d=e1+e2;
	push(&s,e2);
	push(&s,d);
}
pop(&s,&d);
printf("%d",d);
return0;
}

Ⅸ 栈的基本操作的C语言程序

#include <stdio.h>
#include <stdlib.h>
#define MAX 1024 ///栈使用数组模拟，MAX是最大元素个数
typedef int DataType; ///数据域使用整形

typedef struct _stack
{
DataType data[MAX]; ///存放数据
int top; ///栈顶指针
}stack;

///初始化
int initStack(stack (*s))
{
return emptyStack(s);
}

///数据压栈，成功返回1，失败返回0
int push(stack (*s), DataType d)
{
if ((*s).top >= MAX - 1) //栈已满
{
printf("栈已满，不能压栈\n");
return 0;
}

//数据压栈
(*s).top++;
(*s).data[(*s).top] = d;
return 1;
}

///数据出栈，成功返回1，d指向的区域存储弹出的数据，失败返回0
int pop(stack (*s), DataType *d)
{
if ((*s).top <= -1)
{
printf("栈为空，不能出栈\n");
return 0;
}

//出栈
*d = (*s).data[(*s).top];
(*s).top--;
return 1;
}

///清空栈
int emptyStack(stack (*s))
{
(*s).top = -1;
return 1;
}

int main(int argc, char** argv)
{
stack s;
int i, d;

initStack(&s);

//压栈
for (i = 0; i < 1025; i++)
{
push(&s, i);
}

//清空
emptyStack(&s);

for (i = 0; i < 10; i++)
{
push(&s, i);
}
//出栈
for (i = 0; i < 11; i++)
{
pop(&s, &d);
printf("%d\n", d);
}

return 0;
}

Ⅹ C语言计算栈

#include <stdio.h>
double readnumber(char a[],int *i)//将数字字符转变成相应的数
{
double x=0.0;
int k=0;
while(a[*i]>='0'&&a[*i]<='9')
{
x=x*10+a[*i]-'0';
(*i)++;
}
if(a[*i]=='.')
{
(*i)++;
while(a[*i]>='0'&&a[*i]<='9')
{
x=x*10+a[*i]-'0';
(*i)++;
k++;
}
}
while(k!=0)
{
x=x/10.0;
k=k-1;
}
return x;
}
double yunsuan(char a[])//求一个后缀表达式的值
{
double obst[100],b,c;//操作数栈
int top=0,i=0;
while(a[i]!='\0')
{
if(a[i]>='0'&&a[i]<='9')
obst[top++]=readnumber(a,&i);
else if(a[i]==' ') i++;
else if(a[i]=='+')
{
b=obst[--top];
c=obst[--top];
obst[top++]=b+c;
i++;
}
else if(a[i]=='-')
{
b=obst[--top];
c=obst[--top];
obst[top++]=c-b;
i++;
}
else if(a[i]=='*')
{
b=obst[--top];
c=obst[--top];
obst[top++]=b*c;
i++;
}
else if(a[i]=='/')
{
b=obst[--top];
c=obst[--top];
obst[top++]=c/b;
i++;
}
}
return obst[0];
}
int pd(char op)//判断一个字符是不是运算符
{
switch(op)
{
case '+':
case '-':
case '*':
case '/':return 1;
default :return 0;
}
}
int priority(char op)//求运算符的优先级
{
switch(op)
{
case '\0':return -1;
case '(':return 0;
case '+':
case '-':return 1;
case '*':
case '/':return 2;
default:return -1;
}
}
void charge(char a[],char b[])//将中缀表达式转换等价的后缀表达式
{
int i=0,j=0;
char opst[100];
int top,t;
top=0;
opst[top]='\0';
top++;
while(a[i]!='\0')
{
if(a[i]>='0'&&a[i]<='9'||a[i]=='.')
b[j++]=a[i];//遇到数字和小数点直接写入后缀表达式
else if(a[i]=='(')//遇到左括号进入操作符栈
{
opst[top]=a[i];
top++;
}
else if(a[i]==')')
{
t=top-1;
while(opst[t]!='(')
{//'('之前出栈
b[j++]=opst[--top];
t=top-1;
}
top--;
}
else if(pd(a[i]))//'+','-','*','/'
{
b[j++]=' ';//用空格分开两个操作数
while(priority(opst[top-1])>=priority(a[i]))
b[j++]=opst[--top];
opst[top]=a[i];
top++;
}
i++;
}
while(top) b[j++]=opst[--top];
}
int main()
{
char a[100],b[100];
double jieguo;
printf("\n\t请输入算术表达式:");
scanf("%s",a);
charge(a,b);
jieguo=yunsuan(b);
printf("\t表达式运算的结果为:%lf",jieguo);
return 0;
}