Ⅰ 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;
}
Ⅱ 栈的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语言中栈的使用啊
堆栈就是先入后出的数据结构。
如果用c语言来实现的话用个struct
先定义一个栈的节点
struct
node;
typedef
strcut
node
*
position;
typedef
position
stack;
stack
creat();
void
push(int,stack);
int
pop(stack);
int
top();
struct
node
{
int
element;
position
next;
}
stack
creat()
{
stack
s;
s=malloc(sizeof(struct
node));
s->next==NULL;
}
void
push(int
a,stack
s)
{
position
temp;
temp=malloc(sizeof(struct
node));
temp->element=a;
temp->next=s->next;:
s->next=temp;
}
int
pop(stack
s)
{
int
res=s->next->element;
position
temp=s->next;
s->next=temp->next;
free
temp;
}
int
top(stack
s)
{
return
s->next->element;
}
好啦，先creat()一个栈，再进行push
pop等。程序中忽略了麻烦的错误检测给出了重点，当然还可以添加其他操作。。对了，头文件也要加上。本人还是习惯用c++弄成一个类^_^
Ⅳ 求大神精简的讲讲c语言中栈的用法
堆栈用于特殊的数据存储，一般用于函数调用，特点是先入后出。
在进行子程序(函数)调用时，它可以存储调用时调用者给出的参数，子程序通过堆栈指针可找到所有传入的参数，即使修改它们由于返回时设置堆栈指针也不会影响参数原型数据；子程序开设的普通变量也会在堆栈中开辟。
在进行中断函数调用时，堆栈用于保护现场，可以将断点处程序执行的关键寄存器压栈保存，执行完后弹栈恢复现场。
堆栈的好处在于，cpu有专用的堆栈地址寄存器，压栈、弹栈有专用语句，对于栈内数据存取以堆栈指针为参照存取方便，利于最后舍弃无需的数据。
Ⅳ c语言怎么调用栈函数
给你个例子：
#include
//写好加法，以便调用
int sum(int x1,int x2)
{
int x3=x1+x2;
return x3;
}
void main()
{
int a=0;
int b=0;
int c=0;
printf("请输入两个整数\n");
scanf("%d%d",&a,&b);
c=sum(a,b);//传递参数给sum（）函数，返回他们的和
printf("%d+%d的和是：%d\n",a,b,c);
}
总之：就是你把一种方法写到单独的块，这里就是sum()函数，执行一个单一的功能，在main函数调用就是了！
Ⅵ C语言关于栈操作
/*
这是关于栈的操作
那么应该定义一个栈类型
栈中包含两个元素
栈顶指针
栈底指针
以下是修改后的，供参考
*/
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
struct link
{
char name[40];
int age;
struct link * next;
};
typedef struct link Node;
typedef Node * List;
typedef struct Stack
{
List pTop;
List pBottom;
}STACK,* PSTACK;
void init(PSTACK pS)//初始化栈
{
pS->pTop = (Node *)malloc(sizeof(Node));
if (NULL == pS->pTop)
{
printf("动态内存分配失败!\n");
exit(-1);
}
else
{
pS->pBottom = pS->pTop ;
pS->pTop->next = NULL;
}
return;
}
/*入栈*/
void push(PSTACK pS,char * name,int age)
{
List p;
p=(Node*)malloc(sizeof(Node));/*申请新节点*/
if(p==NULL)
{
printf("error\n");
exit(1);
}
strcpy(p->name,name);/*将数据传入新节点*/
p->age=age;
p->next=pS->pTop;
pS->pTop=p;
return ;
}
//遍历栈，只是访问栈中元素的值，
//遍历完成后，栈中的元素个数是不会改变的
void traverse(PSTACK pS)
{
List p = pS->pTop;
while (p != pS->pBottom)
{
printf("%s%5d\n",p->name,p->age);
p = p->next ;
}
printf("\n");
return;
}
bool empty(PSTACK pS)
{
if (pS->pTop == pS->pBottom)
{
return true;
}
else
return false;
}
//出栈，将栈顶元素弹出，
//弹出后，栈中元素个数减少
//注意与 遍历栈 的区别
bool pop(PSTACK pS)
{
if (empty(pS))
{
return false;
}
else
{
List r = pS->pTop;
char * name = r->name;
printf("本次出栈元素的\nname=%s",name);
int age = r->age;
printf("\nage=%d",age);
pS->pTop = r->next;
free(r);
r = NULL;
return true;
}
}
void main()
{
STACK s;
printf("栈初始化操作\n");
init(&s);
printf("开始压栈操作\n");
int len;
printf("请输入需要压入栈中的元素的个数：");
scanf("%d",&len);
int i;
for (i=0; i<len; ++i)
{
printf("第%d个\n",(i+1));
printf("name:\t");
char name[40];
scanf("%s",name);
printf("age:\t");
int age;
scanf("%d",&age);
push(&s,name,age);
}
printf("遍历栈......\n");
traverse(&s);
printf("弹出栈顶元素\n");
pop(&s);
printf("\n弹出后重新遍历栈\n");
traverse(&s);
}
/*
----
栈初始化操作
开始压栈操作
请输入需要压入栈中的元素的个数：3
第1个
name: 许褚
age: 55
第2个
name: 徐晃
age: 66
第3个
name: 张辽
age: 22
遍历栈......
张辽 22
徐晃 66
许褚 55
弹出栈顶元素
本次出栈元素的
name=张辽
age=22
弹出后重新遍历栈
徐晃 66
许褚 55
-----
*/
Ⅶ 数据结构实验（用c语言写） 栈的基本操作
//顺序栈
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACK_INIT_SIZE 100;
#define STACKINCREMENT 10;
typedef struct
{
int *base;
int *top;
int stacksize;
}SqStack;
typedef int ElemType;
int InitStack(SqStack &S) //为栈S分配存储空间，并置S为空栈
{
int size = STACK_INIT_SIZE;
S.base=(int *)malloc(size*sizeof(ElemType));
if(!S.base)
return 0;
S.top=S.base; //置栈S为空栈
S.stacksize=STACK_INIT_SIZE;
return 1;
}
int GetTop(SqStack S,int &e) //若栈不空，则用e返回S的栈顶元素
{
if(S.top==S.base) return 0;
e=*(S.top-1);
return 1;
}
int Push(SqStack &S, int e) /*进栈函数,将e插入栈S中,并使之成为栈顶元素*/
{ if(S.top-S.base>=S.stacksize) /*栈满，追加存储空间*/
{
int stackinvrement = STACKINCREMENT;
S.base=(ElemType *) realloc(S.base,(S.stacksize+stackinvrement)*sizeof(ElemType));
if(!S.base)
return 0; /*存储分配失败*/
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return 1;
}
int Pop(SqStack &S,int &e)/*出栈函数,若栈S不空,则删除S的栈顶元素,用e返回其值*/
{ if(S.top==S.base) return 0;
e=*--S.top;
return 1;
}
void OutputStack(SqStack &S)
{int *q;
q=S.top-1;
for(int i=0;i<S.top-S.base;i++)
{
printf("%3d ",*q);q--;}
}
void main()
{
int a,b,c ;
char m;
SqStack s;
InitStack(s);
printf("请输入要进栈的元素个数是:");
scanf("%d",&a);
printf("\n请输入要进栈的%d个元素:",a);
for(b=0;b<a;b++) {
scanf("%d",&c);
Push(s,c); }
do { printf("\n");
printf("*********** 1.输出栈的元素**********\n");
printf("*********** 2.取栈顶元素************\n");
printf("*********** 3.删除栈顶元素**********\n");
printf("*********** 4.退出程序**********\n");
printf("\n请选择一个字符:");
getchar();
scanf("%c",&m);
switch(m) {
case '1': printf("\n输出的栈为:");
OutputStack(s);
break;
case '2': GetTop(s,c);
printf("\n栈顶元素为:%d",c);
printf("\n输出的栈为:");
OutputStack(s);
break;
case '3': Pop(s,c);
printf("\n删除的栈顶元素:%d",c);
printf("\n输出的栈为:");
OutputStack(s);
printf("\n");
break;
case '4':break;
default: printf("输入的数字有错，请重新选择!\n"); break;
}
}while(m!='4');
}
//链栈
#include<stdio.h>
#include<stdlib.h>
typedef struct SNode
{
int data;
struct SNode *next;
}SNode,*LinkStack;
LinkStack top;
LinkStack PushStack(LinkStack top,int x) //入栈
{
LinkStack s;
s=(LinkStack)malloc(sizeof(SNode));
s->data=x;
s->next=top;
top=s;
return top;
}
LinkStack PopStack(LinkStack top) //退栈
{
LinkStack p;
if(top!=NULL)
{
p=top;
top=top->next;
free(p);
printf("退栈已完成\n");
return top;
}
else printf("栈是空的，无法退栈！\n"); return 0;
}
int GetStackTop(LinkStack top) //取栈顶元素
{
return top->data;
}
bool IsEmpty()//bool取值false和true，是0和1的区别,bool只有一个字节,BOOL为int型,bool为布尔型
{
return top==NULL ? true:false;
}
void Print()
{
SNode *p;
p=top;
if(IsEmpty())
{
printf("The stack is empty!\n");
return;
}
while(p)
{
printf("%d ", p->data);
p=p->next;
}
printf("\n");
}
void main()
{
int x,a,b;
char m;
do { printf("\n");
printf("###############链栈的基本操作##################\n");
printf("××××××××1.置空栈××××××××××\n");
printf("××××××××2.进栈×××××××××××\n");
printf("××××××××3.退栈×××××××××××\n");
printf("××××××××4.取栈顶元素××××××××\n");
printf("××××××××5.退出程序×××××××××\n");
printf("##############################################\n");
printf("\n请选择一个字符:");
scanf("%c",&m);
switch(m){
case '1':
top=NULL;
printf("\n栈已置空!");
break;
case '2':
printf("\n请输入要进栈的元素个数是:");
scanf("%d",&a);
printf("\n请输入要进栈的%d个元素:",a);
for(b=0;b<a;b++) {
scanf("%d",&x);
top=PushStack(top,x); }
printf("进栈已完成！\n");
printf("\n输出栈为:");
Print();
break;
case '3':
printf("\n操作之前的输出栈为:");
Print();
top=PopStack(top);
printf("\n操作过后的输出栈为:");
Print();
break;
case '4':
printf("\n输出栈为:");
Print();
if(top!=NULL)
printf("\n栈顶元素是：%d\n",GetStackTop(top));
else
printf("\n栈是空的，没有元素！");
break;
case '5':break;
default:
printf("\n输入的字符不对，请重新输入!");
break;
}
getchar();
}while(m!='5');
}