当前位置:首页 » 编程语言 » c语言如何构建一个空栈
扩展阅读
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

c语言如何构建一个空栈

发布时间: 2022-09-14 11:57:46

c语言版数据结构 空栈的构造

#include<stdio.h>
#include<stdlib.h>
typedefstructnode
{
intdata;
structnode*next;
}SNODE;
voidpush(SNODE*top,intx);
intpop(SNODE*top);
intmain()
{
inta,b,c,d;
SNODE*top;
top=(SNODE*)malloc(sizeof(SNODE));
top->next=top;
printf("pleaseinputtheenterelement:a,b,c,d ");
scanf("%d%d%d%d",&a,&b,&c,&d);
push(top,a);
push(top,b);
printf("outelementis:n");
printf("%d ",pop(top));
printf("%d ",pop(top));
push(top,c);
push(top,d);
printf("%d ",pop(top));
printf("%d",pop(top));
return0;
}
voidpush(SNODE*top,intx)
{
SNODE*new;
new=(SNODE*)malloc(sizeof(SNODE));
if(new==NULL)
{
printf("thestackisfull ");
exit(1);
}
else
{
new->data=x;
new->next=top->next;
top->next=new;
}
}
intpop(SNODE*top)
{
intx;
SNODE*p;
if(top->next==top)
{
printf("thestackisempty! ");
exit(1);
}
else
{
p=top->next;
x=p->data;
top->next=p->next;
free(p);
}
//printf("%d ",x);
returnx;
}

② c语言版数据结构 空栈的构造

栈的本意是一个数组,里面存取数据的方式是先进后出。因此,你需要一个cusor来指定当前的栈顶(可能你使用top实现的),你可能还需要当前存放了多少数据进栈了,栈是否空、满,因此你还需要一个int变量计算栈元素个数。没push+1,没pop
-1。你完全不需要成员stacksize,还有你需要一个栈元素个数的计数器。另外你不需要将形参由引用该为指针,反而降低效率!

③ 用C语言实现栈的操作,包括创建空栈,PUSH,和POP。用标准C,就是能在TC上运行的。

#include <stdio.h>
#include <stdlib.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef char SElemtype;
typedef struct
{
SElemtype *base;
SElemtype *top;
int stacksize;
}SqStack;

int InitStack(SqStack &S);
int Push(SqStack &S, SElemtype e);
int GetTop(SqStack S, SElemtype &e);
int Pop(SqStack &S, SElemtype &e);

int main()
{
SElemtype e, f = 0, g = 0;
int c;

SqStack S;
if (!InitStack(S))
return 0;

printf("栈已初始化好,输入一个数据入栈.\n");
scanf("%c", &e);
if (!Push(S, e))
return 0;

if (!GetTop(S, f))
return 0;
printf("栈顶元素是:%c\n", f);

if (!Pop(S, g))
return 0;
printf("栈顶元素出栈,它是:%c\n", g);

scanf("%d", &c);
return 1;
}

int InitStack(SqStack &S)
{
S.base = (SElemtype *)malloc(STACK_INIT_SIZE * sizeof (SElemtype));
if (!S.base)
return 0;
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return 1;
}

int Push(SqStack &S, SElemtype e)
{
if (S.top - S.base == S.stacksize)
{
S.base = (SElemtype *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof (SElemtype));
if (!S.base)
return 0;
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return 1;
}

int GetTop(SqStack S, SElemtype &e)
{
if (S.top == S.base)
return 0;
e = *(S.top - 1);
return 1;
}

int Pop(SqStack &S, SElemtype &e)
{
if (S.top == S.base)
return 0;
e = *--S.top;
return 1;
}

我学这本书时写的,刚好给你。

针对补充问题:
&不是伪代码,是C++的传引用,你看的那本书上都是这样用的。
楼上的顺序栈实质就是一个数组。。
TC不能建C++项目吗? 不能的话你还是装个VC吧,你若听了老师的话就应该知道在这里传引用是什么意思,且看下面:
int InitStack(SqStack &S);
int Push(SqStack &S, SElemtype e);
int GetTop(SqStack S, SElemtype &e);
int Pop(SqStack &S, SElemtype &e);
有没有发现GetTop()的参数没有使用&S,因为它对S只读,不改变S。
如果不使用传引用的话,那么InitStack(),Push()等将要返回一个S,若要保存还要把它赋给另一个SqStack类型的变量S1,这样做浪费时间还浪费空间,且之前的S也就没用了,如果反复地调用Push()的话,这样的浪费可想而知。
所以,为了节省时间跟空间,以及按大多数情况下的需要,我们还是得始终只用一个S保存我们要的数据。
至于传引用是什么意思,跟指针有点像,你若不想翻书就再补充问题吧。。

④ C语言构造空栈为什么要在S前加一个&

这里涉及到C/C++中函数调用时的参数传递。一般来说,都是值得传递,形参的值的改变不影响实参的值。
但在某些情况下,希望函数调用中的形参改变,实参也跟着改变。就像构造一个空栈,此时表示这个栈的数据结构刚被建立起来,原来栈不存在,现在被建立了,改变了,而按通常的方式是不行的。
C++提供了一种被称为引用的参数传递方式,就能实现形参改变实参也跟着改变的效果,也就是问题中说的前面加&的情况。

⑤ 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<conio.h>
#include<stdlib.h>
#include<string.h>

#defineelemTypeint/*元素类型*/
#definestatusint
#defineOVERFLOW-1
#defineERROR0
#defineOK1

typedefstructsNode{
elemTypedata;
structsNode*next;
}sNode;

typedefstruct{
sNode*top;/*栈顶指针*/
intlength;/*栈中元素个数*/
}*SLink;

/*初始化*/
/*操作结果:构造一个空的栈S*/
voidinitStack(SLink*S){
(*S)->top=NULL;/*栈顶指针的初始值为空*/
(*S)->length=0;/*栈中元素个数为0*/
}

/*入栈*/
/*操作结果:栈S插入元素e*/
statuspush(SLinkS,elemTypee){
sNode*p;
p=(sNode*)malloc(sizeof(structsNode));/*建立新节点*/
if(!p)/*内存分配失败*/
exit(OVERFLOW);
p->data=e;
p->next=S->top;/*链接到原来的栈顶*/
S->top=p;/*移动栈顶指针*/
++S->length;/*栈的长度增加*/

returnOK;
}

/*出栈*/
/*操作结果:删除栈S栈顶元素,并由e返回其值*/
statuspop(SLinkS,elemType*e){
sNode*q;
if(!S->top)
returnERROR;
else{
*e=S->top->data;/*返回栈顶元素*/
q=S->top;
S->top=S->top->next;/*修改栈顶指针*/
--S->length;/*栈的长度减少*/
free(q);/*释放被删除的元素空间*/
returnOK;
}
}

/*输出栈*/
statusstackPrint(SLinkS){
sNode*p=S->top;/*p指向栈顶*/
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
putchar(' ');
returnOK;
}

intmain(void){
SLinkS;
elemTypee;
elemTypea=1,b=2,c=3,d=4;

initStack(&S);

/*入栈若干元素*/
push(S,a);
push(S,b);
push(S,c);
push(S,d);

puts("入栈4个元素,此时栈内容为:");
stackPrint(S);

/*出栈*/
pop(S,&e);

puts("出栈1个元素,此时栈内容为:");
stackPrint(S);

getch();/*屏幕暂留*/
return0;
}

运行结果

⑦ C语言中如何初始化栈 每个元素均为空

<1>如果顺序栈的定义如下
typedef struct
{datatype data[stacksize];
int top;
}SeqStack;
---则置空栈的操作如下
void InitStack(seqstack *s)
{s->top=-1;
}

<2>如果链栈的定义如下
typedef struct node
{datatype data;
struct node *next;
}LinkStack;
---则置空栈的操作如下
void InitStack(linkstack *s)
{s->top=null;
}

⑧ c语言建栈

#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0

typedef char ElemType;
typedef int Status;

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量

typedef struct
{
ElemType *base; //在栈构造和销毁之后,base的值为NULL
ElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间,以元素为单位
}SqStack;

// 构造一个空栈S

Status InitStack(SqStack &S)
{
S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!S.base) //存储分配失败
exit (OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack

/////////////////// 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR /////

Status GetTop(SqStack S,ElemType &e)
{
if(S.top==S.base)
return ERROR;
e=*(S.top-1);
return OK;
}//GetTop

////////////////// 插入元素e为新的栈顶元素 /////////////////////////////////////

Status Push(SqStack &S,ElemType e)
{
if(S.top-S.base>=S.stacksize) //栈满,追加存储空间
{
S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT) * sizeof(ElemType));
if(!S.base)
exit (OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//Push

////////////////// 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR

Status Pop(SqStack &S,ElemType &e)
{
if(S.top==S.base)
return ERROR;
e=*--S.top;
return OK;
}//Pop

////////// main() //////////////////////////////
void main()
{
int i;
char ch,e,c;
SqStack S;
InitStack(S);
printf("1.Push\t2.Pop\t3.GetTop\t4.exit\n");
while(1)
{
printf("请选择:");
scanf("%d",&i);
c=getchar(); //*****接受回车符******
switch (i)
{
case 1:
printf("请输入要插入的元素:");
scanf("%c",&ch);
Push(S,ch);
break;
case 2:
printf("弹出栈顶元素:");
Pop(S,e);
printf("%c\n",e);
break;
case 3:
printf("取栈顶元素:");
GetTop(S,e);
printf("%c\n",e);
break;
case 4:
exit(0);
default:
printf("ERROR!Please Reput A Number\n");
}
}
}

⑨ 求教:C语言怎么申请一个栈,栈的容量有多大

栈可以直接用数组实现的,也可以用链表实现,本质上就是可以在一端点插入和删除的数据结构
数组和链表都是非常适合的媒介
数组实现就用malloc申请一块内存,当数组用即可
链表就是头插和头删两种操作,每次也用malloc申请一个节点的内存
(频繁malloc是非常有失效率的,建议一般情况用数组版,或者合理使用内存池)

⑩ 用c语言实现栈的建立

#include <stdio.h>
#include <stdlib.h>

typedef struct _stack {
int size;
int* base;
int* sp;
} stack;

void init(stack* s, int n)
{
s->base = (int*)malloc(sizeof(int)*n);
s->size = n;
s->sp = s->base;
}

int push(stack* s, int val)
{
if(s->sp - s->base == s->size) {
puts("overflow");
exit(1);
}
return *s->sp++ = val;
}

int pop(stack* s)
{
if(s->sp == s->base) {
puts("underflow");
exit(2);
}
return *--s->sp;
}

int empty(stack* s)
{
return s->sp == s->base;
}

void clean(stack* s)
{
if(s->base)
free(s->base);
}

int main(void)
{
stack s;
int i;
init(&s, 100);
for(i = 0; i < 10; ++i)
printf("%d ", push(&s, i));
putchar('\n');
while(!empty(&s))
printf("%d ", pop(&s));
clean(&s);
return 0;
}