A到G的顺序栈C语言

‘壹’ c语言顺序栈问题：顺序栈具有多个数据域，下面程序有什么错误

car_p push_S(car_p *S,int b,int c)
{
S->top->num=b;
S->top->time=c;
return *S;
}
压栈的函数top指针没有增加，这样栈里永远就只有一个元素.

scanf("%d%d%d",&a,&b,&c);

while(a!=0&&b!=0&&c!=0)
{
S=push_S(&S,b,c);

printf("%d %d\n",car_message.num,car_message.time); //还有就是不明白你直接输出这句干嘛，把信息压到栈里了应该从栈中去信息输出啊，不过你没有写pop函数，如果像你这样输出的话，那么就应该一直输出0 0的(初始化的值)

scanf("%d%d%d",&a,&b,&c);//如果没错的话这里面的a应该是结束标志吧，那么如果要连续输入的话就必须加这句啊，不家的话要么就一个输不进去，要么就一直输入一样的bc死循环..
}

‘贰’ 用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语言编程实现顺序栈的初始化,入栈,出栈,取栈顶元素,显示操作

#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语言数据结构高手请进，关于顺序栈的基本操作问题。

1. 想通过调用函数改变某个变量的值，必须传递这个变量的地址。也就是在InitStack中申请的内存并没有赋给Main中的s变量，会导致后面的访问出错。改为引用就可以了：
void InitStack(SqStack* &s)//初始化栈
{
s=(SqStack *)malloc(sizeof(SqStack));
s->top=-1;
}

2.在"Pop(s,e);", 这个e并没有内存，导致"*e=s->data[s->top];"出错。
需要给它申请内存：
ElemType *e = (ElemType*)malloc(sizeof(ElemType));
最后"free(e);"一下。

‘伍’ 帮忙看下C语言的顺序栈

#include<stdio.h>
#include<stdlib.h>
#defineINITSIZE100
#defineNEWSIZE10
#defineOK0
#defineERROR-1
typedefintstatus;
typedefintelemtype;
typedefstruct{
elemtype*top;
elemtype*base;
intstacksize;
}stack;

statusinitstack(stack*s)
{
s->base=(elemtype*)malloc(INITSIZE*sizeof(elemtype));
if(!s->base){
printf("error!
");
returnERROR;
}
s->top=s->base;
s->stacksize=INITSIZE;
returnOK;
}

statuspush(elemtypee,stack*s)
{
if(s->top-s->base==s->stacksize)
s->base=(elemtype*)realloc(s->base,(INITSIZE+NEWSIZE)*sizeof(elemtype));
if(!s->base){
printf("reallocerror!
");
returnERROR;
}
s->stacksize+=NEWSIZE;
*s->top++=e;
returnOK;
}

statuspop(stack*s)
{
if(s->top==s->base)
return0;
--s->top;
returnOK;
}

statusGtop(elemtype*e,stack*s)
{
if(s->top==s->base)returnERROR;
*e=*(s->top-1);
returnOK;
}

intmain(void)
{
stackS;
initstack(&S);
inti,e;
for(i=0;i<5;i++)
{
scanf("%d",&e);
push(e,&S);
}
for(i=0;i<5;i++)
{
Gtop(&e,&S);
pop(&S);
printf("%d",e);
}
printf("
");
}

书上标准的写法。。

‘陆’ 请用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<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语言编写函数实现顺序栈的进栈、退栈、取栈顶的算法。

#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>
#define N 100
//栈的结构定义
typedef struct
{
int elem[N];
int top;//栈顶
}Stack;
//循环队列的结构定义
typedef struct
{
int elem[N];
int front;
int rear;
}Queue;
int Greatstack(Stack*);
int GreatQueue(Queue *);
int pop(Stack *s);
void show(Stack *s);
int push(Stack *s);
int popStack(Stack *s);
int enQueue(Queue *q);
int deQueue(Queue *q);
int printQueue(Queue *q);
void conversion();
void main()
{
char exit='N';
int ch;
int result,data;
int m,e;
Stack s;
Queue q;
s.top=0;//栈顶指向当前栈顶的下一位置
q.front=q.rear=0;
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.创建一个顺序栈 .................(1) *\n");
printf("\t\t* 2.出栈.............................(2) *\n");
printf("\t\t* 3.入栈.............................(3) *\n");
printf("\t\t* 4.顺序栈中元素依次出栈，并显示.....(4) *\n");
printf("\t\t* 5.创建一个循环队列.................(5) *\n");
printf("\t\t* 6.进队.............................(6) *\n");
printf("\t\t* 7.出队.............................(7) *\n");
printf("\t\t* 8.循环队列中元素依次出队，并显示...(8) *\n");
printf("\t\t* 9.十进制数转换为其它进制数.........(9) *\n");
printf("\t\t* 10.退出 ..............(10) *\n");
printf("\t\t********************************************\n");
printf("\n请选择操作代码：");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("创建一个顺序栈\n");
result=Greatstack(&s);
if(result==0)printf("顺序栈创建失败，栈已满!\n");
else printf("顺序栈创建成功!\n");
system("pause");
break;
case 2:
printf("出栈:\n");
m=pop(&s);
if(m==0)printf("出栈失败,栈已空!\n");
else
{
printf("顺序栈出栈成功!\n");
printf("该栈剩余元素为:");
show(&s);
}
//请加入出栈操作的代码或函数调用
system("pause");
break;
case 3:
printf("进栈:\n");
printf("请输入入栈的元素");
scanf("%d",&e);
result=push(&s,e);
if(result==0)printf("栈已满!\n");
else
{
printf("顺序栈入栈成功!\n");
printf("该栈剩余元素为:");
show(&s);
}
//请加入进栈操作的代码或函数调用
system("pause");
break;
case 4:
printf("顺序栈中元素依次出栈，出栈序列为：\n");
popStack(&s);
//请加入依次出栈并显示元素操作的代码或函数调用
system("pause");
break;
case 5:
printf("创建一个循环队列\n");
result=GreatQueue(&q);
if(result==0)printf("循环队列创建失败，循环队列已满!\n");
else printf("循环队列创建成功!\n");
system("pause");
break;
case 6:
printf("入队:\n");
data=enQueue(&q);
if(result=0) printf("队已经满了\n");
else printf("入队成功\n");
//请加入入队操作的代码或函数调用
system("pause");
break;
case 7:
printf("出队:\n");
data=deQueue(&q);
if(data=0) printf("队已经空了\n");
else printf("出队成功\n");
//请加入依次出队操作的代码或函数调用
system("pause");
break;
case 8:
printf("循环队列中元素依次出队，出队序列为：\n");
//请加入依次出队并显示元素操作的代码或函数调用
data=printQueue(&q);
system("pause");
break;
case 9:
printf("十进制数转换为其它进制数：\n");
conversion();
//请加入十进制数转换为其它进制数操作的代码或函数调用
system("pause");
break;
case 10:
getchar();
printf("\n您是否真的要退出程序(Y/N):");
exit=getchar();getchar();
break;
default:
printf("\n无效输入，请重新选择...:");
}
}while(exit!='y'&&exit!='Y');
}
/*从键盘输入一系列整数，当输入值为0时，停止输入，产生顺序栈*/
/*返回0表示生成成功，1表示失败*/
int Greatstack(Stack *s)
{
int e;
s->top=0;//栈顶指向当前栈顶的下一位置
printf("请依次输入需要入栈的元素，以0表示输入结束：");
do
{
scanf("%d",&e);
if(e!=0)
{ if(s->top>=N)return 0;//栈满
s->elem[s->top++]=e;
}
}while(e!=0);
}
/*从键盘输入一系列整数，当输入值为0时，停止输入，产生循环队列*/
/*返回0表示生成成功，1表示失败*/
int GreatQueue(Queue *q)
{
int e;
q->front=q->rear=0;//初始化队列
printf("请依次输入需要入栈的元素，以0表示输入结束：");
do
{
scanf("%d",&e);
if(e!=0)
{ if((q->rear+1)%N==q->front)return 0;//队满
q->elem[q->rear]=e;
q->rear=(q->rear+1)%N;
}
}while(e!=0);
return 1;
}
int pop(Stack *s) //出栈
{
if(s->top==0)
return 0;
--s->top;
}
void show(Stack *s) //显示栈中的元素
{
int i=s->top;
while(i!=0)
{
--i;
printf("%d ",s->elem[i]);
}
}
int push(Stack *s,int e) //入栈
{
if(s->top>=N)return 0;
s->elem[s->top++]=e;
}
int popStack(Stack *s) //顺序栈中元素依次出栈，并显示
{
while(s->top!=0)
{
--s->top;
printf("%3d",s->elem[s->top]);
}
return 0;
}
int enQueue(Queue *q) //入队
{
int e;
printf("请输入入栈的元素:");
scanf("%d",&e);
if((q->rear+1)%N == q->front) return 0;
q->elem[q->rear]=e;
q->rear=(q->rear+1)%N;
return 1;
}
int deQueue(Queue *q) //出队
{
int *e;
if(q->front == q->rear) return 0;
e =q->elem[q->front];
q->front=(q->front+1)%N;
return 1;
}
int printQueue(Queue *q) //循环队列中元素依次出队，并显示
{
if(q->front == q->rear) return 0;
for(;q->front!=q->rear;)
{
printf("%3d",q->elem[q->front]);
q->front++;
}
}
void conversion() //十进制数转换为其它进制数
{
Stack p1;
int n,m;
puts("请输入需要转换的元素:");
scanf("%d",&n);
puts("请输入需要转换的进制:");
scanf("%d",&m);
p1.top=0;
while(n)
{
push(&p1,n%m);
n=n/m;
}
popStack(&p1);
}

‘拾’ 建立顺序存储的栈，并对之进行入栈、出栈、取栈顶元素操作的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");
}