c语言链栈的基本操作

① 数据结构实验（用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

加载更多

② 计算机c语言中 什么是栈和队列

栈(Stack)是仅限制在表的一端进行插入和删除运算的线性表，称插入、删除这一端为栈顶，另一端称为栈底。表中无元素时为空栈。栈 的修改是按后进先出的原则进行的，我们又称栈为LIFO表(Last In First Out)。通常栈有顺序栈和链栈两种存储结构。 栈的基本运算有六种： ·构造空栈：InitStack(S) ·判栈空: StackEmpty(S) ·判栈满： StackFull(S) ·进栈： Push(S,x) ·退栈： Pop(S) ·取栈顶元素：StackTop(S) 在顺序栈中有"上溢"和"下溢"的现象。 ·"上溢"是栈顶指针指出栈的外面是出错状态。 ·"下溢"可以表示栈为空栈,因此用来作为控制转移的条件。 顺序栈中的基本操作有六种：·构造空栈·判栈空·判栈满·进栈·退栈·取栈顶元素 链栈则没有上溢的限制，因此进栈不要判栈满。链栈不需要在头部附加头结点，只要有链表的头指针就可以了。 链栈中的基本操作有五种：·构造空栈·判栈空·进栈·退栈·取栈顶元素 队列(Queue)是一种运算受限的线性表，插入在表的一端进行，而删除在表的另一端进行，允许删除的一端称为队头(front)，允许插入的 一端称为队尾(rear) ,队列的操作原则是先进先出的，又称作FIFO表(First In First Out) 。队列也有顺序存储和链式存储两种存储结 构。 队列的基本运算有六种： ·置空队：InitQueue(Q) ·判队空：QueueEmpty(Q) ·判队满：QueueFull(Q) ·入队：EnQueue(Q,x) ·出队：DeQueue(Q) ·取队头元素：QueueFront(Q) 顺序队列的"假上溢"现象：由于头尾指针不断前移，超出向量空间。这时整个向量空间及队列是空的却产生了"上溢"现象。 为了克服"假上溢"现象引入循环向量的概念，是把向量空间形成一个头尾相接的环形，这时队列称循环队列。 判定循环队列是空还是满，方法有三种： ·一种是另设一个布尔变量来判断； ·第二种是少用一个元素空间，入队时先测试（(rear+1)%m = front）? 满：空； ·第三种就是用一个计数器记录队列中的元素的总数。 队列的链式存储结构称为链队列，一个链队列就是一个操作受限的单链表。为了便于在表尾进行插入(入队)的操作，在表尾增加一个尾指 针，一个链队列就由一个头指针和一个尾指针唯一地确定。链队列不存在队满和上溢的问题。在链队列的出队算法中，要注意当原队中只 有一个结点时，出队后要同进修改头尾指针并使队列变空。

③ C语言数据结构实现链栈的入栈、出栈、删除与插入

1、栈（stack）又名堆栈，它是一种运算受限的线性表。
其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

2、例程：

#include<stdio.h>
#include<stdlib.h>
#defineMax100
typedefcharT;


typedefstructMyStack
{
Taa[Max];
unsignedintp;

}stack;

//创建空栈
stack*createEmptyStack()
{
stack*st=(stack*)malloc(sizeof(stack));
inti=0;
for(i=0;i<Max;i++)
st->aa[i]=0;
st->p=0;
returnst;
};

//栈判空
intisEmpty(conststack*st)
{
if(st->p==0)return1;
elsereturn0;
};

//求栈的大小
unsignedintsize(conststack*st)
{
returnst->p;
};

//push操作
voidpush(stack*st,constTa)
{
st->p=st->p+1;
if(st->p==Max)
{
printf("栈满
");
st->p--;
return;
}
st->aa[st->p]=a;
};

//pop操作
Tpop(stack*st)
{
if(isEmpty(st))
{
printf("栈空");
returnNULL;
}
chart=st->aa[st->p];
st->p=st->p-1;
printf("%c",t);
returnt;
};

//栈销毁
voiddestroy(stack*st)
{
free(st);
};

intmain()
{


stack*st=createEmptyStack();
if(isEmpty(st))printf("MyStackisempty
");
elseprintf("MyStackisnotempty
");
push(st,'a');
push(st,'b');
push(st,'c');
push(st,'d');
push(st,'e');
printf("%d
",size(st));
while(!isEmpty(st))pop(st);
destroy(st);
system("pause");
return0;
}

④ 在C语言中该怎样建立栈具体代码是什么

1.栈空间（stack段）用来存放函数中的局部变量和函数调用时的上下文。
2.
全局变量和静态变量存放于进程的数据段。
3.
windows下进程的栈空间会自动增长，一般不会出现空间不足的问题；
4。如果变量实在太大，甚至大于栈可增长的范围，如数百兆，则会编译出错。

⑤ 求计算机C语言中“栈”的基本概念，希望各个方面都有，全一点。最好和教科书介绍的一样详细

栈，是硬件。主要作用表现为一种数据结构，是只能在某一端插入和删除的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。 栈也称为先进后出表。 栈可以用来在函数调用的时候存储断点，做递归时要用到栈！ 以上定义是在经典计算机科学中的解释。 在计算机系统中，栈则是一个具有以上属性的动态内存区域。程序可以将数据压入栈中，也可以将数据从栈顶弹出。在i386机器中，栈顶由称为esp的寄存器进行定位。压栈的操作使得栈顶的地址减小，弹出的操作使得栈顶的地址增大。 栈在程序的运行中有着举足轻重的作用。最重要的是栈保存了一个函数调用时所需要的维护信息，这常常称之为堆栈帧或者活动记录。堆栈帧一般包含如下几方面的信息： 1. 函数的返回地址和参数 2. 临时变量：包括函数的非静态局部变量以及编译器自动生成的其他临时变量。
二、基本算法
1、进栈（PUSH）算法 ①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）； ②置TOP=TOP+1（栈指针加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2、退栈（POP）算法 ①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作②)； ②X=S(TOP)，（退栈后的元素赋给X）： ③TOP=TOP-1，结束（栈指针减1，指向栈顶）。
三、栈的实现
栈分顺序栈和链式栈，下面程序介绍了顺序栈的实现。
#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; }

⑥ 栈的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++吧
先构造一个结构模板
template<class
ElemType>
typedef
struct
Node
//建立
{
ElemType
data;//数据成员，用于存储
struct
Node*next;//指针成员，用于连接逻辑结构
}LNode;
1.构造一个空栈，只需要：
LNode*head;//定义栈顶指针
head=(LNode*)malloc(sizeof(LNode));//分配空间
head->next=NULL;//下一个为空
2.新节点：比如新节点数据位1
入栈操作：
LNode*p;
p->data=1;
p->next=head;
head=p;
总之有点类似C语言里的链表
还有什么不清楚的可以追问
希望对你有所帮助！！！

⑧ 用顺序表实现栈的基本操作（基于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');

}

⑨ 急！用c语言实现链栈的操作

typedef struct node
{ ElemType data;
struct node *next;
} LinkStack;
⑴置空栈
void InitLinkStack（ LinkStack * & s）
{ s=NULL;
}
⑵判栈空
int IsEmptyLinkStack（LinkStack *s ）
{ if（s==NULL）
return 1;
else
return 0;
}
⑶ 入栈/*将元素x插入链栈top的栈顶*/
void PushLinkStack（LinkStack* &s , ElemType x）
{ LinkStack *p;
p=malloc(sizeof(LinkStack)); /*生成新结点*s */
p->data=x;
p->next=s;
s=p;

}
⑷出栈/*删除链栈top的栈顶结点*/
int PopLinkStack (LinkStack* & s, ElemType &x)
{ LinkStack *p;
if（s==NULL） return 0;
x = s->data; /*将栈顶数据存入*x */
p = s; /*保存栈顶结点地址*/
s = s->next; /*删除原栈顶结点*/
free (p); /*释放原栈顶结点*/
return 1; /*返回新栈顶指针*/
}
（5） 取栈顶元素
int GetLinkStackTop (LinkStack* s, ElemType &x)
{
if（s==NULL） return 0;
x = s->data; /*将栈顶数据存入*x */
return 1; /*返回新栈顶指针*/
}
主函数怎么写吧

⑩ 如何用C语言创建一个链栈，并进行操作

1 思路: 主要是链表的插入和删除操作

2 代码

#include<stdio.h>
#include<stdlib.h>
typedefstructnode
{
	intdata;
	structnode*next;
}node_type;

voidpush(node_type*&stack,intelem){
	node_type*node=(node_type*)malloc(sizeof(node_type));
	node->data=elem;
	node->next=stack;
	stack=node;
}
intpop(node_type*&stack){
	intelem=stack->data;
	node_type*node=stack;
	stack=stack->next;
	free(node);
	returnelem;
}
boolIsEmpty(node_type*stack){
	returnstack==NULL;
}
voiddisplay(node_type*stack){
	while(stack){
		printf("%d",stack->data);
		stack=stack->next;
	}
	puts("");
}
voiddestroy(node_type*stack){
	while(!IsEmpty(stack)){
		pop(stack);
	}
}
intmain(){
	puts("(1)建立空链栈");
	node_type*stack=NULL;
	puts("
(2)调用进栈函数，将从键盘输入的数据元素逐个进栈，输入0结束；");
	intnum;
	scanf("%d",&num);
	while(num!=0){
		push(stack,num);
		scanf("%d",&num);
	}
	puts("
(3)显示进栈后的数据元素");
	display(stack);
	puts("
(4)调用两次出栈函数，显示出栈后的数据元素");
	if(!IsEmpty(stack))
		printf("%d
",pop(stack));
	if(!IsEmpty(stack))
		printf("%d
",pop(stack));

	destroy(stack);
	getchar();
	getchar();
	return0;
}

3 运行效果