当前位置：首页 » 编程语言 » c语言入栈

c语言入栈

发布时间: 2021-03-31 04:23:05

⑴ 数据结构用c语言编程实现进栈出栈

希望如下对你有用：
/*栈的基本操作*/
#
define
stacksize
100
/*定义栈的最大存储空间*/
#
define
LEN
sizeof(struct
stack)
static
size=0;
struct
stack
{
int
data;
int
*top[stacksize];
};
struct
stack
*sqstack;
struct
stack
*s;
static
e;
int
push()
/*将元素压入栈*/
{
if
(size<=stacksize)
*
sqstack->top[size++]=e;
else
printf
("
the
stack
is
full:");
}
int
pop(struct
stack
*sqstack,int
location)
/*元素出栈*/
{
e=*(sqstack->top[location]);
return
(e);
}
main()
{
int
n,i,t,x=0;
int
element;
printf
(
"\n
create
the
stack
first
:");
scanf
("%d
",&n);
for
(i=1;i<=n;i++)
{
scanf
("%d",&e);
push
(e);
}
s=sqstack;
t=size;
printf
("\n
after
pushed
,
the
sqstack
is
:");
while
(t>=0)
{
*s->top[t]=*sqstack->top[t];
t--;
}
t=size;
while
(t!=0)
{
t--;
e=pop(s,t);
printf
("
%d->",e);
}
printf
("\n
which
element
you
want
to
pop
:");
scanf
("%d",&element);
while
(size!=0)
{
e=pop(sqstack,size--);
if
(element==e)
{
printf
("\n
%d
is
poped",element);
x=1;
}
}
if(x==0)
printf
("\n
%d
is
not
found
in
the
sqstack.\n",element);
}

⑵ c语言中入栈有什么表示方法啊

栈的特点是先进后出。
你把栈当成一个水桶，把书一本本放进去，然后最先放的书就被压在最下面，所以最先进去的，最后出来。
压栈就是入栈就是把书放进水桶，出栈就是把书拿出来。

⑶ c语言出栈入栈实现

1.声明个数组a[10];
2.编写入栈函数push(int x)
取得当前栈顶索引，将x存于数组a的索引处，返回成功与内否。
3.编写容出栈函数pop()
取得当前栈顶索引，将数组a中索引处的值取出，返回给调用函数
4.将上述过程用C语言实现！

⑷ c语言入栈出栈，出队入队问题

intpop(seqstack*s,char*x){
	if(s->top==0){//初始化时，s->top=-1，此处以s->top==0判断栈为空，有矛盾
		专printf("栈空
");
		return-1;
	}
	else{
		*x=s->c[s->top];
		s->top--;
	}
	return1;
}

通常，top指的位置是待压入属的空结点，所以top == 0时，栈为空，top ==MAXSIZE时，栈满，故应该修改初始化函数，建议蟹盖如下:

seqstack*Initstack(void){
	seqstack*s;
	s=(seqstack*)malloc(sizeof(seqstack));
	s->top=0;
	returns;
}

⑸ 用C语言实现入栈出栈

#include
<stdio.h>
int
stack[100];
/*100个栈空间*/
int*
sp
=
stack;
/*栈指针指向栈底*/
#define
push(
i
)
{
*sp++
=
i;
}
/*push一个数*/
#define
pop()
(*--sp)
/*pop一个数并返回*/
int
main()
{
int
i;
for
(
i
=
0;
i
<
10;
++i
)/*push
0~9*/
push(
i
);
for
(
i
=
0;
i
<
10;
++i
)/*输出9~0*/
printf(
"%d
",
pop()
)
;
}

⑹ C语言的“进栈”和“出栈”是什么意思

栈使用链表来实现的.如果你不懂的链表,可以先了解一下链表.
int Push(STACK *S,int e)//进栈
{
SNode *p;
p=(SNode *)malloc(sizeof(SNode)); // 申请一个节点回.这个节点是用来存放入栈的数据的答.
if(!p)
return ERROR; // 如果没有申请成功,返回错误.
p->data=e; // 节点的值为e
p->next=S->top; // 放到栈顶
S->top=p; //并修改栈顶为P
S->length++; //长度加一.
return OK; //入栈成功,返回ok
}
出栈是一样的.

⑺ c语言实现进栈程序的全过程

/**************
sstack.h
***************/
/* 顺序栈表示：类型和界面函数声明 */

enum { MAXNUM = 20 /* 栈中最大元素个数，应根据需要定义 */
};

typedef int DataType; /* 栈中元素类型，应根据需要定义 */

struct SeqStack { /* 顺序栈类型定义 */
int t; /* 栈顶位置指示 */
DataType s[MAXNUM];
};

typedef struct SeqStack SeqSack, *PSeqStack; /* 顺序栈类型和指针类型 */

/*创建一个空栈;为栈结构申请空间，并将栈顶变量赋值为-1*/
PSeqStack createEmptyStack_seq( void );

/*判断pastack所指的栈是否为空栈，当pastack所指的栈为空栈时，则返回1，否则返回0*/
int isEmptyStack_seq( PSeqStack pastack );

/* 在栈中压入一元素x */
void push_seq( PSeqStack pastack, DataType x );

/* 删除栈顶元素 */
void pop_seq( PSeqStack pastack );

/* 当pastack所指的栈不为空栈时，求栈顶元素的值 */
DataType top_seq( PSeqStack pastack );

/**************
sstack.c
***************/

/* 顺序栈表示：函数定义 */

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

#include "sstack.h"

/*创建一个空栈;为栈结构申请空间，并将栈顶变量赋值为-1*/
PSeqStack createEmptyStack_seq( void ) {
PSeqStack pastack = (PSeqStack)malloc(sizeof(struct SeqStack));
if (pastack==NULL)
printf("Out of space!! \n");
else
pastack->t = -1;
return pastack;
}

/*判断pastack所指的栈是否为空栈，当pastack所指的栈为空栈时，则返回1，否则返回0*/
int isEmptyStack_seq( PSeqStack pastack ) {
return pastack->t == -1;
}

/* 在栈中压入一元素x */
void push_seq( PSeqStack pastack, DataType x ) {
if( pastack->t >= MAXNUM - 1 )
printf( "Stack Overflow! \n" );
else {
pastack->t++;
pastack->s[pastack->t] = x;
}
}

/* 删除栈顶元素 */
void pop_seq( PSeqStack pastack ) {
if (pastack->t == -1 )
printf( "Underflow!\n" );
else
pastack->t--;
}

/* 当pastack所指的栈不为空栈时，求栈顶元素的值 */
DataType top_seq( PSeqStack pastack ) {
return pastack->s[pastack->t];
}

⑻ C语言进栈和出栈：

闲得没事干，跟你详细讲讲吧。
首先要弄明白一点，栈的结构是“先进后出“的，就像你堆积木一样，第一根放在最底层的地面上，然后一根一根往上堆。前一个放上去的总是被后一个放上去的压在底下。那我当我再想里面放一根的时候，总不能放中间或者放底下吧（除非你很无聊很寂寞闲的蛋疼了先一根根把堆在上面的全部拿出来然后把要放进去的那根放上去最后又把刚才搬下来的有重新搬上去......此处省去几万字)所以要往上面加东西的时候，就得放在最上面。
以上就是进栈的原理，怎么出栈呢，很简单，直接从”积木"的最顶端取下来就行了。
ok，以上比喻完了，希望你能看得明白。接下来讲程序不说积木了：），由上面的分析我们可以知道一个道理，对于栈的操作，栈顶的元素很重要（也就是积木最上面的那根）。为什么呢。无论是出栈还是进栈，都跟那哥们有直接的联系。你想啊，如果要是有元素要进栈的话，那么它就不能当“老顶”了，那老顶之位就要交给压在它上头那位了；如果出栈呢，它也不能当老顶了，老顶之位就要交到原来压在它底下的那个。
ok,所以一般的栈都将栈顶的那个元素所在的位置（内存地址--数组类型的，或者指针---节点类型的）视为栈的栈顶~！通过它来对栈进出进行操作。
一般来说（或者在我出生以来看到过的）栈有两种内存结构（注意是是内存结构，有的书说是存储结构，都一样一样滴），一种是连续的，一种是不连续的，连续的基本上就是数组了，不连续的基本上就是链表类型的啦。你上面的程序就是链表类型的，每个节点都有个指针指向它“底下”的节点（我觉得“底下”比下一个更容易理解）。通过这种你链我我链它的方式，把一组数据连在一起。
进栈：
int Push(STACK *S,int e)//进栈
{
SNode *p; //step1:这个编程习惯不好，没定义一个指针就应该把它指向NULL
p=(SNode *)malloc(sizeof(SNode)); //step2:为你的节点分配内存
if(!p)
return ERROR;
p->data=e; //step3：当然了，你那个传进来的e是相当于temp，用来传值的，ok，那就把它的数据给p咯，p实际指向的是一块内存块，用来装节点的
p->next=S->top; //step4:回到上面积木问题，进栈的时候，原来的老顶要给新来的让位，但是如果这时候的top节点直接赋给新来的元素的话，那么那个原来的老顶是不是从此以后都找不到它了？所以，先把新来的元素的next指针指向当前的老顶，这样的话，以后通过next指针就可以找到它了。
S->top=p; //当然，都已经处理好以前老顶的身后事了（就是以后可以通过p的next指针找到它了）那么“让位”就可以进行了，这时，p便戴上了老顶之帽了
S->length++; //既然人数都增加了，那就到公安局登记入户口吧
return OK; //一切over，现在这个栈stack的栈顶位置就是你刚才新加进来的p了，通过stock.top指针就可以访问到栈顶，然后出栈也是同理的，ok，all over
}

⑼ c语言的简单的进栈出栈

就用这复堆函数就可以了，不懂再制追问
#include
<string.h>
#define
MaxSize
100
int
mystack[MaxSize];/*
第0个单元保存现在的长度
*/
/*
初始化函数
*/
void
init_stack(int*
stack){
memset(stack,0,sizeof(stack));
}
/*
入栈函数
*/
void
push_back(int*
stack,int&
num){
if(stack[0]<MaxSize-1){
++stack[0];
stack[
stack[0]
]
=
num;
}
else{
printf("ERORR!\n");
}
}
/*
返回栈空间
*/
int
size(int*
stack){
return
stack[0];
}
/*
返回栈顶函数
*/
int
top(int*
stack){
if(stack[0]>0){
return
stack[
stack[0]
];
}
else{
printf("ERORR!\n");
return
-1;
}
}
/*
出栈函数
*/
void
pop(int*
stack){
if(stack[0]>0){
--stack[0];
}
else{
printf("ERORR!\n");
}
}

阅读全文

c语言入栈

与c语言入栈相关的阅读推荐