c语言栈的基本操作
❶ 栈的基本操作的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
#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
#include
#include
#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
#include
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
评论
0
0
加载更多
❹ 栈的基本操作
1、栈是一种先进后出的线性表，是最基本的一种数据结构
2、栈是限制插入和删除只能在一个位置上进行的线性表
3、由于栈是线性表，所以可以使用链表或顺序表实现
4、链栈（动态栈）：使用单链表实现栈。通过单链表的头插法来实现入栈操作；通过删除首节点来实现出栈操作；动态栈具有链表的部分特性，即元素与元素之间在物理存储上可以不连续，但是功能有些受限制，动态栈只能在栈顶处进行插入和删除操作，不能在栈尾或者栈中进行插入和删除操作
5、顺序栈（静态栈）：每个栈都有一个topOfStack，用来表示栈顶在数组中的下标；需要注意的是对空栈的pop操作和对满栈的push操作都会产生数组越界并引起程序crash
❺ 那位大神能讲下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语言)，高手速来！！
/*程序错误太多*/ #include"stdio.h"
#include"stdlib.h"
#include"time.h"
#include"malloc.h"
#define
STACK_INIT_SIZE
10
//栈容量 typedef
struct
SqStack
{
int
top;
//栈顶当前指针
int
*base;
//栈空间数组
}SqStack; void
InitStack(SqStack
&S);
//构造空栈S
int
Push(SqStack
&S,int
e);
//入栈（栈地址，入栈数据）
返回0对，-1错
int
Pop(SqStack
&S);
//出栈
（栈地址）返回栈顶数据
int
StackLength(SqStack
S);
//返回站的元素个数，即求栈长
void
Print_S(SqStack
S);
//显示栈内数据 int
main()
{
SqStack
S;
int
i=0;
int
a,e;
InitStack(S);
srand((unsigned)time(NULL));
//srand((unsigned)time(NULL))以time函数值(当前时间)作为种子
printf("随机填充5个元素为:
");
while(
i<5)
{
a
=
rand()%100;
printf("%d
",
a);
Push(S,a);
i++;
}
Print_S(S);
printf("请输入要插入栈顶的元素:");
scanf("%d",&e);
Push(S,e);
Print_S(S);
printf("再弹出的栈顶元素为:%d
\n",Pop(S));
printf("栈的长度为:%d
\n",StackLength(S));
Print_S(S);
return
0;
} void
InitStack(SqStack
&S)
//构造空栈S
{
S.base
=
(int
*)malloc(STACK_INIT_SIZE
*
sizeof(int));
//分配组数空间，长度STACK_INIT_SIZE
if
(S.base==NULL)
{
printf("内存分配失败!\n");
return;
}
S.top=-1;
} int
Push(SqStack
&S,int
e)
{
if(S.top>=STACK_INIT_SIZE)
{
printf("栈空间已满，入栈失败!\n");
return
-1;
}
else
{
S.base[++S.top]=e;
return
0;
}
} int
Pop(SqStack
&S)
//返回栈顶数据
{
if
(S.top>=0)
//栈内有数据
{
return
S.base[S.top--];
}
else
{
printf("空栈，无数据弹出!\n");
return
-1;
}
} int
StackLength(SqStack
S)
{
return
S.top+1;
} void
Print_S(SqStack
S)
{
printf("\n出栈显示：");
if(S.top
==
-1)
printf("栈内无数据!\n");
else
{
while(S.top>=0
)
printf("%d
",Pop(S));
putchar('\n');
}
}
❼ 栈的操作，用c语言急！
#include <stdio.h>
#define MAXSIZE 100
#define ERROR -1
typedef struct
{
int element[MAXSIZE];
int top;
}stack;
void InitStack(stack *s)
{
s->top=0;
}
bool IsEmpty(stack s)
{
if(s.top==0)
return true;
return false;
}
bool IsFull(stack s)
{
if(s.top==MAXSIZE)
return true;
return false;
}
void push(stack *s,int x)
{
if(!IsFull(*s))
{
s->element[s->top]=x;
s->top++;
}
else
printf("stack overflow\n");
}
int pop(stack *s)
{
if(!IsEmpty(*s))
{
s->top--;
return s->element[s->top];
}
else
{
printf("stack flow\n");
return ERROR;
}
}
int getTop(stack *s)
{
if(!IsEmpty(*s))
return s->element[s->top];
else
{
printf("stack empty\n");
return ERROR;
}
}
void empty(stack *s)
{
InitStack(s);
}
int measureStack(stack s)
{
return s.top;
}
int main(int argc,char *argv[])
{
stack s;
InitStack(&s);
push(&s,1);
push(&s,2);
push(&s,3);
printf("%d\n",pop(&s));
while(s.top!=0)
printf("%d\n",s.element[--s.top]);
return 0;
}
❽ 栈的操作，用c语言急！
#include<stdio.h>
#include<malloc.h>
#define DataType int
#define MAXSIZE 1024
typedef struct
{
DataType data[MAXSIZE];
int top;
}SeqStack;
SeqStack *Init_SeqStack()//栈初始化
{
SeqStack *s;
s=(SeqStack *)malloc(sizeof(SeqStack));
if(!s)
{
printf("空间不足\n");
return NULL;
}
else
{
s->top=-1;
return s;
}
}
int Empty_SeqStack(SeqStack *s)//判栈空
{
if(s->top==-1)
return 1;
else
return 0;
}
int Push_SeqStack(SeqStack *s,DataType x)//入栈
{
if(s->top==MAXSIZE-1)
return 0;//栈满不能入栈
else
{
s->top++;
s->data[s->top]=x;
return 1;
}
}
int Pop_SeqStack(SeqStack *s,DataType *x)//出栈
{
if(Empty_SeqStack(s))
return 0;//栈空不能出栈
else
{
*x=s->data[s->top];
s->top--;
return 1;
}//栈顶元素存入*x，返回
}
DataType Top_SeqStack(SeqStack *s)//取栈顶元素
{
if(Empty_SeqStack(s))
return 0;//栈空
else
return s->data[s->top];
}
int Print_SeqStack(SeqStack *s)
{
int i;
printf("当前栈中的元素:\n");
for(i=s->top;i>=0;i--)
printf("%3d",s->data[i]);
printf("\n");
return 0;
}
int main()
{
SeqStack *L;
int n,num,m;
int i;
L=Init_SeqStack();
printf("初始化完成\n");
printf("栈空：%d\n",Empty_SeqStack(L));
printf("请输入入栈元素个数：\n");
scanf("%d",&n);
printf("请输入要入栈的%d个元素：\n",n);
for(i=0;i<n;i++)
{
scanf("%d",&num);
Push_SeqStack(L,num);
}
Print_SeqStack(L);
printf("栈顶元素：%d\n",Top_SeqStack(L));
printf("请输入要出栈的元素个数（不能超过%d个）：\n",n);
scanf("%d",&n);
printf("依次出栈的%d个元素：\n",n);
for(i=0;i<n;i++)
{
Pop_SeqStack(L,&m);
printf("%3d",m);
}
printf("\n");
Print_SeqStack(L);
printf("栈顶元素：%d\n",Top_SeqStack(L));
return 0;
}