c语言写栈切换

❶ c语言 栈的应用 数制转换

#include "stdafx.h"
#include <iostream.h>
#include <stdio.h>
#define MaxSize 100

//用栈的方法
typedef struct {
int data[MaxSize];
int top;
}Stack;//顺序栈，也可用链栈

void InitStack(Stack &S)//初始化栈
{
S.top=-1;
}

int push(Stack &S,int x)//入栈
{
if(S.top==MaxSize)
return 0; //栈满
else{
S.top++;
S.data[S.top]=x;
return 1;
}
}

int pop(Stack &S,int &x)//出栈
{
if(S.top==-1)
return 0; //栈空
else{
x=S.data[S.top];
S.top--;
return 1;
}
}

void display(Stack &S)
{
int x;
while(S.top!=-1)
{
pop(S,x);
printf("%x",x);
}

}
void func(int n,int m)//n为十进制数，m为2，8，或16
{
Stack S;
InitStack(S);
while(n!=0)
{
push(S,n%m);
n=n/m;
}
display(S);
}

int main(int argc, char* argv[])
{
int n;
printf("\n请输入一个数:");
scanf("%d",&n);
int m=2;
func(n,m);
m=8;
func(n,m);
m=16;
func(n,m);
return 0;
}

❷ C语言中的栈实现进制转换

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

#define MAXSIZE 100

typedef int DataType;
typedef struct{
DataType data[MAXSIZE];
int top;
}SeqStack,*PSeqStack;

PSeqStack Init_SeqStack(void)
{
PSeqStack S;
S=(PSeqStack)malloc(sizeof(SeqStack));
if(S)
S->top=-1;
return S;
}

int Push_SeqStack(PSeqStack S,DataType x)
{
if (S->top==MAXSIZE-1)
return 0;
else
{
S->top++;
S->data[S->top]=x;
return 1;
}
}

int Empty_SeqStack(PSeqStack S)
{
if(S->top==-1)
return 1;
else
return 0;
}

int Pop_SeqStack(PSeqStack S,DataType *x)
{
if(Empty_SeqStack(S))
return 0;
else
{
*x=S->data[S->top];
S->top--;
return -1;
}
}

void Destory_SeqStack(PSeqStack *S)
{
if(*S)
free(*S);
*S=NULL;
return;
}

typedef int DataType;
int conversation(int n,int r)
{
PSeqStack S;
DataType x;
if(!r)
{
printf("基数不能为0");
return(0);
}
S=Init_SeqStack();
if(!S)
{
printf("栈初始化失败");
return(0);
}
while(n)
{
Push_SeqStack(S,n%r);
n=n/r;
}
while (!Empty_SeqStack(S))
{
Pop_SeqStack(S,&x);
printf("%d",x);
}
Destory_SeqStack(&S);
return 0;
}

void main()
{
int i,a;
printf("输入要转换的进制！！\n");
scanf("%d",&a);
printf("输入要转换的数！！\n");
scanf("%d",&i);
conversation(i,a);
}

❸ C语言数据结构用栈写的进制转换~~~

我试过了，不是无法运行，是运行时出错。你现在要单步调试，仔细检查每一个指针和变量的值。练习单步调试运行时错误是提高你编程技术的好机会，直接答案你就失去了这个机会了。

建议：你的编程习惯不好，你应该给程序加上必要的调试信息，比如像这样的：（多敲几下键盘而已）
#ifdef _DEBUG
printf("Function:%s, Line: %d\n", __FUNCTION__, __LINE__); //若是gcc编译器，请用__func__
#endif

这两个都是系统默认的变量，__FUNCTION__是当前运行的函数, __LINE__是当前运行的行数
至少加在每个函数的开头，这样运行的时候就会告诉你这个程序在哪个函数的第几行出错了。

提示：我在pushstock函数里加了2个printf，运行的时候只打出来一个，现在知道错误在哪里了把？

Status pushstock( SqStack &S, int num )
{
#ifdef _DEBUG
printf("Function:%s, Line: %d\n", __FUNCTION__, __LINE__); //若是gcc编译器，请用__func__
#endif
if( S.top - S.base >= S.stocksize )
{
S.base = ( SElemType * )realloc( S.base,
sizeof(SElemType) * (STOCKINCREASE + S.stocksize) );
if( !S.base )
exit( 0 );
S.top = S.base + S.stocksize;
S.stocksize += STOCKINCREASE;
}
#ifdef _DEBUG
printf("Function:%s, Line: %d\n", __FUNCTION__, __LINE__); //若是gcc编译器，请用__func__
#endif
* (S.top++) = num;
return OK;
}

❹ 用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语言写：利用栈实现十进制数 N和其它 d进制数的转换。

工具／材料：以Microsoft Visual Studio 2010为例。

1、首先在桌面上，点击“Microsoft Visual Studio 2010”图标。

❻ 用C语言栈实现进制转换，十进制转成2,8,16，2,8,16转成十进制，

Problem Description
输入一个十进制数N，将它转换成R进制数输出。
Input
输入数据包含多个测试实例，每个测试实例包含两个整数N(32位整数)和R（2<=R<=16, R<>10）。
Output
为每个测试实例输出转换后的数，每个输出占一行。如果R大于10，则对应的数字规则参考16进制（比如，10用A表示，等等）。
Sample Input
7 2
23 12
-4 3
Sample Output
111
1B
-11

#include<stdio.h>
#include<string.h>
int main()
{
int R,a,i;
long n;
char b[10000];
while(scanf("%d %d",&n,&R)!=EOF)
{
if(n==0)
printf("0\n");
if(n==1)
printf("1\n");
if(n==-1)
printf("-1\n");
if(n>1||n<-1)
{
if(n<0)
printf("-");
n=n>0?n:-n;
i=0;
while(n>0)
{
a=n%R;
n=n/R;
if(a>=10)
b[i]='A'+a-10;
else
b[i]='0'+a;
i++;
}
b[i]='\0';
for(i=strlen(b)-1;i>=0;i--)
printf("%c",b[i]);
printf("\n");
}
}
return 0;
}

❼ 用C语言实现栈的基本操作（数制的转换）

//顺序栈以及基本操作如下：

#include<iostream.h>
enum
{
MAX_SIZE=20
};

typedef struct
{
int* base;
int* top;
int stacksize;
}SqStack;

void InitStack(SqStack& S)
{
S.base=new int[MAX_SIZE];
S.top=S.base;
S.stacksize=MAX_SIZE;
}

bool Push(SqStack& S,int e)
{
if(S.top-S.base>=S.stacksize)
return false;
*S.top=e;
S.top++;
return true;
}

bool Pop(SqStack& S,int& e)
{
if(S.top==S.base)
return false;
S.top--;
e=*S.top;
return true;
}

void DestroyStack(SqStack& S)
{
if(S.base)
delete S.base;
S.top=S.base=NULL;
S.stacksize=0;
}

bool StackEmpty(SqStack S)
{
return (S.top==S.base);
}

void Print(SqStack S)
{
int i=0;

while(i<S.top-S.base)
{

cout<<S.base[i++]<<endl;
}
}

❽ C语言 利用栈实现不同进制数之间的转换。要求输入一个十进制整数N，通过堆栈实现十进制整数到二进制数

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

#defineelemTypeint							/*链栈元素数据类型*/
#defineSNODE_SIZEsizeof(structsNode)		/*链栈结点空间大小*/

#definestatusint	/*状态型变量*/
#defineOVERFLOW-1	/*内存溢出状态码*/
#defineERROR0		/*错误状态码*/
#defineOK1		/*正确状态码*/

/*链栈结点存储结构*/
typedefstructsNode{
	elemTypedata;
	structsNode*next;
}sNode,*sNodePtr;

/*链栈存储结构*/
typedefstructlinkStack{
	sNodePtrtop;/*栈顶指针*/
}linkStack;

/*初始化*/
/*操作结果：构造一个带头结点的空链栈S*/
voidinitStack(linkStack*S){
	S->top=(sNodePtr)malloc(SNODE_SIZE);/*产生头结点，栈顶指针指向此头结点*/
	if(!S->top)/*内存分配失败*/
		exit(OVERFLOW);
	S->top->next=NULL;
}

/*销毁*/
/*初始条件：链栈S已存在。操作结果：销毁链栈S*/
voiddestroyStack(linkStack*S){
	sNodePtrp,q;
	
	p=S->top;/*p指向S的头结点*/
	while(p){
		q=p->next;/*q指向p的下一个结点*/
		free(p);/*回收p指向的结点*/
		p=q;/*p移动到下一个结点*/
	}/*直到没有下一个结点*/
}

/*判断链栈是否为空*/
/*初始条件：链栈S已存在。操作结果：若S为空链栈，则返回TRUE，否则返回FALSE*/
statusstackIsEmpty(linkStack*S){
	returnS->top->next==NULL;
}

/*入栈*/
/*操作结果：在S的栈顶插入新的元素e*/
statuspush(linkStack*S,elemTypee){
	sNodePtrp;
	
	p=(sNodePtr)malloc(SNODE_SIZE);/*产生新结点*/
	if(!p)/*内存分配失败*/
		exit(OVERFLOW);
	
	p->data=e;
	p->next=S->top->next;/*将新结点链接到原栈顶*/
	S->top->next=p;/*栈顶指向新结点*/
}

/*出栈*/
/*操作结果：删除S的栈顶元素，并由e返回其值*/
statuspop(linkStack*S,elemType*e){
	sNodePtrp;
	
	if(stackIsEmpty(S))
		returnERROR;
	
	p=S->top->next;/*p指向链栈的第一个结点*/
	*e=p->data;/*取出数据*/
	S->top->next=p->next;
	free(p);/*删除该结点*/
	
if(S->top==p)/*栈为空*/
	S->top->next=NULL;

returnOK;
}

intmain(void){
	linkStackS;
	elemTypee;
	intN;
	
	initStack(&S);
	
scanf("%d",&N);
	
	/*除基数取余*/
while(N){
	push(&S,N%2);
	N/=2;
}
	
	while(!stackIsEmpty(&S)){
		pop(&S,&e);
		printf("%d",e);
	}
	
	destroyStack(&S);
	
	getch();/*屏幕暂留*/
	return0;
}

如有问题，点击头像联系我

❾ 用C语言写出用数据结构中用栈实现进制间的转换

十进制换二进制，八进制，十六进制
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define LISTINCREMENT 10
#define INFEASIBLE -1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int SElemType;
typedef int Status;
typedef int ElemType;
typedef struct SqStack
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
SqStack S;

Status InitStack();
Status Push(SElemType e);
Status Pop(SElemType *e);
Status StackEmpty();

void main()
{
char *b="0123456789ABCDEF";
int n,N,M,L,e;
SqStack S;
InitStack();
printf("请输入要转换的数字：");
scanf("%d",&n);
N=M=L=n;
while(N)
{
Push(N % 8);
N = N / 8;
}
printf("转换为八进制数为：");
while(!StackEmpty())
{
Pop(&e);
printf("%d",e);
}
printf("\n");
while(M)
{
Push(M % 2);
M = M / 2;
}
printf("转换为二进制数为：");
while(!StackEmpty())
{
Pop(&e);
printf("%d",e);
}
printf("\n");
while(L)
{
Push(L % 16);
L = L / 16;
}
printf("转换为十六进制数为：");
while(!StackEmpty())
{
Pop(&e);
printf("%c", b[e]);
}
printf("\n");
getch();
}

Status InitStack()
{
S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);
S.top = S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}

Status Pop(SElemType *e)
{
if(S.top == S.base)
return ERROR;
*e = *--S.top;
return OK;
}

Status Push(SElemType e)
{
if(S.top - S.base >= S.stacksize)
{
S.base = (ElemType *)realloc(S.base,(S.stacksize + LISTINCREMENT) * sizeof(ElemType));
if(!S.base)
exit(OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}

Status StackEmpty()
{
if(S.top == S.base)
return OK;
else
return ERROR;
}

❿ 栈的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;
}