当前位置：首页 » 编程语言 » 顺序栈c语言
扩展阅读
提分平台的账号密码是什么 2023-08-31 22:07:10
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

顺序栈c语言

发布时间: 2022-07-17 02:48:41

❶ 求用c语言编写一个程序实现顺序栈初始化，出栈，入栈，判栈空，判栈满，急需，谢谢

#define STACK_SIZE 100
#define PUSH_POP_SUCCESS 1
#define PUSH_POP_ERROR 0
struct _stackbuf {
int _collection[STACK_SIZE];
int _top;
};
typedef struct _stackbuf S_STACK;
typedef unsigned int u_int_f;
// 入栈
u_int_f push(S_STACK *stack, int d){
if (stack->_top >= STACK_SIZE) return PUSH_POP_ERROR;
stack->_collection[stack->_top++] = d;
return PUSH_POP_SUCCESS;
}
// 出栈
u_int_f pop(S_STACK *stack, int *e){
if (!stack->_top) return PUSH_POP_ERROR;
*e=stack->_collection[--(stack->_top)];
return PUSH_POP_SUCCESS;
}
int main(){
S_STACK stack = { {0},0 };
push(&stack, 1);
push(&stack, 2);
push(&stack, 3);
int gv = 0;
pop(&stack, &gv);
printf("%d\n", gv);
system("PAUSE");
return 0;
}

❷ 用c语言编写一个程序实现顺序栈的初始化，出栈和入栈。急需，谢谢

#defineSTACK_SIZE100
#definePUSH_POP_SUCCESS1
#definePUSH_POP_ERROR0

struct_stackbuf{
	int_collection[STACK_SIZE];
	int_top;
};
typedefstruct_stackbufS_STACK;
typedefunsignedintu_int_f;

//入栈
u_int_fpush(S_STACK*stack,intd){
	if(stack->_top>=STACK_SIZE)returnPUSH_POP_ERROR;
	stack->_collection[stack->_top++]=d;
	returnPUSH_POP_SUCCESS;
}

//出栈
u_int_fpop(S_STACK*stack,int*e){
	if(!stack->_top)returnPUSH_POP_ERROR;
	*e=stack->_collection[--(stack->_top)];
	returnPUSH_POP_SUCCESS;
}


intmain(){
	S_STACKstack={{0},0};
	push(&stack,1);
	push(&stack,2);
	push(&stack,3);

	intgv=0;
	pop(&stack,&gv);
	printf("%d
",gv);

	system("PAUSE");
	return0;
}

❸ 用C语言编写函数实现顺序栈的进栈、退栈、取栈顶的算法。

#include<stdio.h>
#define stacksize 100 //假定预分配的栈空间最多为100 个元素
typedef char elementtype; //假定栈元素的数据类型为字符 ,在此处可以自行设置
typedef struct
{
elementtype data[stacksize];
int top;
}seqstack;
// 置空栈
void initstack(seqstack *s)
{
s->top=-1;
//解释一下，s->top 指向的是当前栈顶元素的位置
//当要向栈中添加一个新元素时，要先将s->top增加1，
//此时s->top 指向的就是新元素要添加的位置了。
//所以当栈为空时，填加第一元素时，top加1 后
//s->top的值就变为0，也就是第一个元素的位置了。
}
//判栈空
int stackempty(seqstack *s)
{
if(s->top==-1)
return 1; //若相等就返回1，否则为0
else return 0;
}
//入栈
void push(seqstack *s,elementtype x)
{
if(s->top==stacksize -1 ) //进栈前判断栈是否已经满了
printf(" stack overflow\n");
else
{
s->top= s->top + 1;
s->data[s->top]=x;
}
}
//出栈
elementtype pop(seqstack *s)
{
if(stackempty(s)) //出栈前先判断当前栈中是否有内容
printf("stack is empty\n");
else
{
return s->data[s->top--]; //出栈后s->top的值会自减1
}
}
//取栈顶元素（只是想知道栈顶的值，并没有出栈）
elementtype gettop(seqstack *s)
{
if(stackempty(s))
{
printf("stack already empty.\n");
}
else return s->data[s->top];
}
int main()
{
elementtype x;
seqstack *s; //定义一个栈，用指针的方式定义的
initstack(s); //想初始化定义好的栈
//当栈为空时调用出栈操作
pop(s);

//向栈中添加一个元素a
push(s,'a');

//观察此时的栈顶元素
x=gettop(s);
printf("%c\n",x);

//再添加一个元素b
push(s,'b');

//观察此时的栈顶元素
x=gettop(s);
printf("%c\n",x);

//弹出栈顶的元素
x=pop(s);
printf("%c\n",x);

//观察弹出后栈顶元素的变化情况
x=gettop(s);
printf("%c\n",x);
return 0;
}

❹ 请用C语言给出的顺序栈（栈的顺序储存结构）的类型定义

#include<stdio.h>
#include<stdlib.h>
int IsEmpty(int p)/*判断是否为空*/
{
if(p==0)
return 1;
else
return 0;
}
int Push(int p)/*入栈*/
{
p++;
return(p);
}
int Pop(int p)/*出栈*/
{
p--;
return(p);
}
void create()
{
char expression[20];
int i=0,p=0;
printf("please scan your expression which length less than 20,scan # to stop:\n");
scanf("%s",expression);
while(expression[i]!='#')
{
if(expression[i]=='(')/*如果遇到'('入栈*/
p=Push(p);
if(expression[i]==')')/*如果遇到')'且栈不为空'('出栈*/
{
if(IsEmpty(p))
{
printf("ERROR!\n");
exit(0);
}
else
p=Pop(p);
}
i++;
}
if(IsEmpty(p))
printf("OK!\n");
else
printf("ERROR!\n");
}
void main()
{
int i=0;
while(i!=-1)/*按-1退出程序运行*/
{
create();
printf("go on scan any number excepet for -1:\n");
scanf("%d",&i);
}
}

❺ 建立顺序存储的栈，并对之进行入栈、出栈、取栈顶元素操作的c语言算法

#include "process.h"
#include "stdio.h"
#include "assert.h"

const int stackIncreament=20; //栈溢出时扩展空间的增量

class SeqStack
{
private:
int top; //栈顶指针
int MAX; //栈的最大可容纳个数
int *elements; //存放栈中元素的栈数组
void overflowProcess(); //栈的溢出处理
public:
SeqStack(int sz=50); //构造函数
~SeqStack() { delete[]elements; } //析构函数
bool pop1(int & x); //元素出栈
void push1(const int & x); //新元素进栈
bool IsEmpty1()const; //判断栈空与否
bool IsFull1()const; //判断栈满与否
void output1(); //输出元素进栈顺序
void output(int x); //输出x

};

SeqStack::SeqStack(int sz):top(-1),MAX(sz)
{
elements=new int[MAX]; //创建栈的数组空间
assert(elements!=NULL); //断言：动态存储分配成功与否
}

bool SeqStack::pop1(int & x) //栈顶元素出栈
{
if(IsEmpty1()==true) return false;//判栈空否，若栈空则函数返回
x=elements[top--]; //栈顶指针退1
return true; //退栈成功
}

void SeqStack::push1(const int & x) //新元素进栈
{
if(IsFull1()==true) overflowProcess(); //栈满则溢出处理
elements[++top]=x; //栈顶指针先加1,再进栈
}

bool SeqStack::IsEmpty1() const //判断栈空与否
{
return (top==-1)?true:false;
}

bool SeqStack::IsFull1()const //判断栈满与否
{
return (top==MAX-1)?true:false;
}

void SeqStack::overflowProcess() //栈的溢出处理
{
//私有函数，扩充栈的存储空间。
int *Array=new int[MAX+stackIncreament]; //和课本不一样 ??????????
if(Array==NULL)
{
printf("存贮分配失败 ! \n");
exit(1);
}
for(int i=0;i<=top;i++) Array[i]=elements[i];
MAX=MAX+stackIncreament;
delete []elements;
//elements=Array;
}

void SeqStack::output1() //元素入栈顺序输出
{
int n=0;
int t=top;
for(int i=0;i<top;i++)
{
printf(" %d",elements[i]);
n++;
if(n%10==0)
printf("\n");
}
}

void SeqStack::output(int x) //栈内元素输出
{
printf(" %d",x);
}

//----------------------顺序栈函数--------------------------//
void SeqStack1( SeqStack A)
{
int x=-1;
int X;
printf("请输入要入栈A的元素值,以0结束：\n");
while(x!=0){ //新元素进栈
scanf("%d",&x);
A.push1(x);
}
printf("\n元素进栈顺序是 :");
A.output1();
printf("\n\n");

A.pop1(X); //元素出栈
if(!A.pop1(X))
printf("元素出栈失败 ！\n");
else
{
printf("\n栈顶元素是： ");
A.output(X);
printf("\n");
printf("\n元素出栈的结果是 : ");
A.output(X);
while(A.pop1(X))
A.output(X);
}
}

void main()
{
printf("----------顺序栈的调试----------\n");
printf("\n \n");
SeqStack A;
SeqStack1(A);
printf("\n \n");
}

❻ C语言编程：顺序栈的入栈与退栈及读顶元素

举一个例子说明
《停车场管理》
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#include
"stdio.h"
#include
"malloc.h"
#define
max_stop
5
//
停车场容量//
#define
PRICE
8
//停车单价
//
typedef
struct//汽车//
{
char
*license[20];
//汽车//
}car;
typedef
struct
//停车场//
{
car
stop[max_stop];
//停车场//
int
top;
}parking;
void
come(car
p,parking
*tcc)
{
if(tcc->top>=max_stop-1){printf("已满！！");}
else
{
printf("
输入到来汽车的车牌号码
:
");
scanf("%s",p.license);
printf("\n");
tcc->top++;
tcc->stop[tcc->top]=p;//如果停车场没有满就入场//
}
}
void
display(car
p,parking
*tcc)
{
int
n=0;
if(tcc->top==-1)printf("
停车场内无汽车！\n");
//指针在-1处
停车场内无车//
else{
//
有车
//
printf("●停车场内的车为：\n");
while(n<=tcc->top)
{
printf("第
%d
辆
%s\n",n+1,tcc->stop[n].license);
n++;
}
}
}
void
leave(car
p,parking
*tcc)
{
car
leavecar;
int
num,money,time;
printf("
输入将要离开的汽车车位号码：");
scanf("%d",&num);
num--;
if(num>tcc->top||num<0)printf("
你的输入有误
请检查预备出停车场的车辆号码\n");
else
{
printf("
输入此车停留的时间
:
");
scanf("%d",&time);
if(time<=0)printf("
你的输入有误
请检查停车时间\n");
else
{
leavecar=tcc->stop[num];
while(numtop)
{
tcc->stop[num]=tcc->stop[num+1];
num++;
}
tcc->top--;
}
}
if((num<=tcc->top)
&&
(num>=0))
{
money=time*PRICE;
printf("●
%s
已经离开停车场
停留%d小时
收费%d元",leavecar.license,time,money);
}
}
void
welcome()
//欢迎界面//
{
printf("
●欢迎适用本程序●\n");
printf("
本程序为停车场的模拟管理程序，有车到来时请按
C
键\n");
printf("
然后根据屏幕提示进行相关操作，有车要走时请按
L
键\n");
printf("
然后根据屏幕提示进行相关操作，若需要帮助请按
H
键\n");
printf("
然后根据屏幕提示进行相关操作，要退出程序请按
Q
键\n");
}
void
main()
{
char
key;
car
p;
parking
*tcc;
tcc=(parking
*)malloc(sizeof(parking));
tcc->top=-1;
while(1)
{
flushall();
printf("
请输入您的操作
:
");
scan

❼ C语言编程实现顺序栈的初始化,入栈,出栈,取栈顶元素,显示操作

#define STACKSIZE 100
int mstack[STACKSIZE],top,bottom;
void mInitStack() { top=bottom=0; }
void mPush(int x) { if ( top-bottom<=STACKSIZE ) { mstack[top]=x; top++; } }
int mPop() { int r=0; if ( top>bottom ) { r=mstack[top]; top--; } return r; }
void mShowStack() { int i; printf("["); for ( i=bottom;i<top;i++ ) printf("%d ",mstack[i]); printf("] "); }
void main()
{
int i,n,x,loop=1,s;
char buffer[80];
mInitStack();
scanf("%d",&n); for ( i=0;i<n;i++ ) { scanf("%d",&x); mPush(x); }
mShowStack();
while ( loop )
{ buffer[1]=0; gets(buffer); s=1;
switch ( buffer[1] )
{ case 'O':
case 'o': x=mPop(); break;
case 'U':
case 'u': x=atoi(buffer+5); mPush(x); break;
case 'n':
case 'N': loop=0; break;
default: s=0; break;
}
mShowStack();
}
mShowStack();

}

❽ 求顺序栈的c语言

这是编译错误。。。。。。 醉了

❾ C语言 入栈顺序为什么函数入栈顺序从右往左

C语言函数参数入栈顺序从右到左是为了方便可变参数函数。
一、在函数调用时，函数参数的传递，在C语言中是通过栈数据结构实现的。
在调用函数时，先根据调用函数使用的参数，自右向左依次压入栈中，然后调用函数，在函数开始执行时，将参数再依次弹栈。根据栈数据结构先进后出的特点，在函数中弹栈的顺序就是从左向右的。
二、对于参数固定的函数，无论是从左向右还是从右向左，都没什么区别，最终都是所有参数全部传递。
三、对于可变参数，比如printf，会在第一个参数格式字符串中，指明后续有几个参数，各自是什么类型的。于是在函数中，参数格式字符串必须第一个弹栈，否则无法获取参数类型，也就无法获知后续参数占几个字节，导致无法正确获知参数。
四、理论上来说，如果从左向右压栈，可变参数标记格式字符串的参数放在最后，那么也是可以的。 不过最早设计C语言的人采用了这种方式，后续也就延续下来了。

阅读全文

与顺序栈c语言相关的内容

本站内容整理源于互联网，如有问题请联系解决。
Copyright design: www.gotrillian.com since 2022