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;
}