c语言顺序栈
1. 建立顺序存储的栈，并对之进行入栈、出栈、取栈顶元素操作的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");
}
2. 求用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;
}
3. 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(num<tcc->top)
{
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(" 请输入您的操作 : ");
scanf("%c",&key);
if(key=='c'||key=='C')come(p,tcc);
else if(key=='l'||key=='L')leave(p,tcc);
else if(key=='d'||key=='D')display(p,tcc);
else if(key=='h'||key=='H')welcome();
else if((key=='q')||(key=='Q'))break;
else printf(" 您的输入有误 ! ! 请重新输入：\n");
}
}
4. 用C语言编写顺序栈的建立，出栈、进栈、取栈顶元素 ，谁帮看看这程序
亲..错的太多了..没法改了..
给你指出几个明显的错误吧..
1.函数声明要加分号.
int Empty_SeqStack()
int Push_SeqStack()
int Pop_SeqStack()
int taPop_SeqSck()
2.主函数中x未定义.
void main()
{
printf("----------顺序栈的调试----------\n");
printf("\n \n");
scanf("%s",x);
....
}
3.形参实参数量与类型不符.
int Push_SeqStack(SeqStack *s,datatype *x)
Push_SeqStack(x);
4.datatype类型未定义.
typedef struct
{
datatype data[MAXSIZE];
...
}SeqStack;
5. 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();
}
6. C语言顺序栈的销毁算法怎么写
#include<stdio.h>
#include<stdlib.h>
typedefstructNode
{
intdata;
structNode*Next;
}NODE;
typedefstructStack
{
NODE*ptop;
NODE*pBottom;
}STACK;
voidinit(STACK*pS);//初始化
voidpush(STACK*pS,intnum);//圧栈
voidtraverse(STACK*pS);//遍历栈
voidclear(STACK*pS);//清空
intempty(STACK*pS);//判断是否为空
intpop(STACK*pS,int*tmp);//出栈
intmain(void)
{
STACKS;
intt=0;
init(&S);
push(&S,1);
push(&S,8);
push(&S,6);
push(&S,2);
push(&S,3);
traverse(&S);
if(pop(&S,&t))
{
printf("出栈成功!本次出栈元素为[%d] ",t);
}
else
{
printf("出栈失败! ");
exit(1);
}
traverse(&S);
clear(&S);
traverse(&S);
return0;
}
voidinit(STACK*pS)//初始化
{
pS->ptop=(NODE*)malloc(sizeof(NODE));
if(NULL==pS)
{
printf("内存分配失败! ");
exit(1);
}
else
{
pS->pBottom=pS->ptop;
pS->ptop->Next=NULL;
}
return;
}
voidpush(STACK*pS,intnum)//圧栈
{
NODE*ptmp=(NODE*)malloc(sizeof(NODE));
if(NULL==ptmp)
{
printf("内存分配失败! ");
exit(1);
}
else
{
ptmp->data=num;
ptmp->Next=pS->ptop;
pS->ptop=ptmp;
}
return;
}
voidtraverse(STACK*pS)//遍历栈
{
if(empty(pS))
{
printf("栈为空! ");
exit(1);
}
else
{
NODE*p=NULL;
p=pS->ptop;
while(p!=pS->pBottom)
{
printf("%d",p->data);
p=p->Next;
}
printf(" ");
}
return;
}
intempty(STACK*pS)
{
if(pS->ptop==pS->pBottom)
{
return1;
}
else
{
return0;
}
}
intpop(STACK*pS,int*tmp)
{
NODE*r=NULL;
if(empty(pS))
{
return0;
}
else
{
r=pS->ptop;
*tmp=r->data;
pS->ptop=r->Next;
free(r);
r=NULL;
return1;
}
}
voidclear(STACK*pS)//清空
{
NODE*q=NULL,*p=NULL;
if(empty(pS))
{
printf("栈为空! ");
exit(1);
}
else
{
while(q!=pS->pBottom)
{
q=pS->ptop;
p=q;
pS->ptop=q->Next;
free(q);
q=p;
}
pS->ptop=pS->pBottom;
//printf("[%p][%p] ",pS->pBottom,pS->ptop);
}
return;
}
[email protected] 一起学习，C语言爱好者。
7. 用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;
}
8. 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;
}
9. C语言数据结构：利用两个顺序栈来实现一个列队的功能时遇到的问题
假设s1、s2的深度都是3
s1已满，从栈顶到栈低依次是：5、4、3
s2非空，从栈顶到栈底依次是：1、2
此时要想在入栈一个元素6的话，按照你的想法，
得把s1的数据出栈到一个缓冲区，然后把缓冲区中，在原来s1栈底的3挪动到s2的栈顶，
然后s1的4、5依次压回栈s1，然后s1就能够空出栈顶的一个位置了，对吧？
但是，这个放置s1出栈元素的缓冲区。。。也得是一个栈结构吧？否则的话，你怎么知道s1向缓冲区出栈的u元素
顺序呢？
这样就不是双栈模拟队列了，势必还得用到一个中间栈s3来满足你这种处理方式~
因此，双栈模拟队列时，当栈s1满，栈s2非空时，栈s1再执行进栈操作。因为双栈是没有s3的~
10. c语言函数参数入栈顺序
从右向左；
例如：f（int a, int b, int c）
c先入栈，然后b，其次a；