C语言 用栈实现进制转换

（C语言）10进制转换2，8，16进制作者：vinseven#include"stdio.h"#include"conio.h"#include"malloc.h"#include"windows.h"#define ElemType intvoid menu();void TenToTwo();void TenToEight();void TenToSixteen();void InitStack(struct sNode **HS);void Push(struct sNode **HS,ElemType x);ElemType Pop(struct sNode **HS);ElemType Peek(struct sNode **HS);int EmptyStack(struct sNode **HS);void ClearStack(struct sNode **HS);int ten;/*要输入的10进制数*/int x;/*把将要插入到栈中的元素暂时存进 x 中*/struct sNode hs;struct sNode{ElemType data;struct sNode *next;};void main(){menu();getch();}void menu(){char choice;int flag=1;while(1){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 1，10进制转换2进制\n\n\n");printf("\t\t\t 2，10进制转换8进制\n\n\n");printf("\t\t\t 3，10进制转换16进制\n\n\n");printf("\t\t\t 0，退出\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入编号：");while(flag){fflush(stdin);choice=getch();switch(choice){case '1':{system("cls");TenToTwo();flag=0;break;}case '2':{system("cls");TenToEight();flag=0;break;}case '3':{system("cls");TenToSixteen();flag=0;break;}case '0':{printf("\n\t\t\t按任意键退出");getch();exit(0);}default:{printf("\n\t\t\t无此选项可选！请重新输入！\n");flag=1;break;}}}system("cls");flag=1;}}/*10进制转换2进制界面*/void TenToTwo(){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换2进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%2;Push(&hs,x);ten=ten/2;}printf("\t\t\t二进制数为：");while(!EmptyStack(&hs))printf("%d",Pop(&hs));getch();}/*10进制转换8进制界面*/void TenToEight(){printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换8进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%8;Push(&hs,x);ten=ten/8;}printf("\t\t\t八进制数为：");while(!EmptyStack(&hs))printf("%d",Pop(&hs));getch();}/*10进制转换16进制界面*/void TenToSixteen(){int temp;printf("\n\t\t\t________________________\n\n\n");printf("\t\t\t 10进制转换16进制界面\n\n\n");printf("\t\t\t________________________\n\n");printf("\t\t\t请输入10进制数：");scanf("%d",&ten);while(ten!=0){x=ten%16;Push(&hs,x);ten=ten/16;}printf("\t\t\t十六进制数为：");while(!EmptyStack(&hs)){temp=Pop(&hs);switch(temp){case 1:case 2:case 3:case 4:case 5:case 6:case 7:case 8:case 9:printf("%d",temp);break;case 10:printf("A");break;case 11:printf("B");break;case 12:printf("C");break;case 13:printf("D");break;case 14:printf("E");break;case 15:printf("F");break;}}getch();}/*关于栈的函数*//*1，初始化链栈为空*/void InitStack(struct sNode **HS) {*HS=NULL;}/*2，向栈中插入一个元素*/void Push(struct sNode **HS,ElemType x){struct sNode *newp;newp=malloc(sizeof(struct sNode));if(newp==NULL){printf("内存动态空间用完，退出运行！");system("pause");exit(0);}newp->data=x;newp->next=*HS;*HS=newp;}/*3，从栈中删除一个函元素并返回它*/ ElemType Pop(struct sNode **HS){struct sNode *p;ElemType temp;if(*HS==NULL){printf("栈空！无法删除！");system("pause");exit(0);}p=*HS;*HS=p->next;temp=p->data;free(p);return temp;}/*4，读取栈顶元素*/ElemType Peek(struct sNode **HS){if(*HS==NULL){printf("栈空！无法读取栈顶结点！");system("pause");exit(1);}return (*HS)->data;}/*5，检查链栈是否为空,空返回1，否则返回0*/ int EmptyStack(struct sNode **HS){if(*HS==NULL)return 1;elsereturn 0;}/*6，清除链栈为空*/void ClearStack(struct sNode **HS){struct sNode *cp,*np;cp=*HS;while(cp!=NULL){np=cp->next;free(cp);cp=np;}*HS=NULL; }。

c语言进制转换算法在C语言中，可以使用以下算法进行进制转换：1. 将十进制数转换为任意进制数```c#include <stdio.h>void decimalToBase(int n, int base) {char result[32] = {'\0'}; // 用于存储结果的字符数组int i = 0;while (n > 0) {int remainder = n % base;result[i++] = remainder < 10 ? remainder + '0' : remainder - 10 + 'A'; // 将余数转换为对应的字符存储到结果数组中n = n / base;}for (int j = i - 1; j >= 0; j--) {printf("%c", result[j]); // 从后往前输出结果数组中的字符}}int main() {int n = 102; // 十进制数int base = 16; // 目标进制数printf("Base %d: %s\n", base, decimalToBase(n, base)); // 调用函数进行转换并输出结果return 0;}```这个算法的基本思路是不断地将原数除以目标进制的基数，将余数转换为对应的字符存储到结果数组中，直到原数为0为止。

最后从后往前输出结果数组中的字符即可得到转换后的结果。

2. 将任意进制数转换为十进制数这个算法可以使用类似于上面的算法的逆过程实现，即不断地将原数乘以目标进制的基数，取出整数部分作为新的余数，直到原数为0为止。

最后将所有的余数按照从低位到高位的顺序相加即可得到转换后的十进制数。

栈的应⽤-数制转换（C语⾔数据结构）数制转换在计算机中经常⾯对不同数制的转换问题，如将⼀个⼗进制数N转换为d进制B。

数制转换的解决⽅法很多，其中⼀个简单的转换算法是重复下述两步。

直到N等于零为⽌。

x = N mod dN = N div d其中，N为需要转换的⼗进制数，d为转换后的进制，x值为转换后各个数位上的数，div为整除运算，mod为求余运算。

算法的运⾏过程为：第⼀次求出的x值为d进制数的最低位，最后⼀次求出的x值为d进制数的最⾼位，所以上述算法是从低位到⾼位顺序产⽣d进制的各位，然后逆序输出，因为它按“后进先出”的规律进⾏的，所以⽤栈这种结构处理最合适。

根据这个特点，利⽤栈来实现上述数制转换，即将计算过程种⼀次得到的d进制数码按顺序栈进栈。

计算结束后，再返顺序出栈，并按出栈顺序打印输出。

这样即可得到给定的⼗进制数对应的d进制数，由此可以得到数制转换的算法。

实现代码利⽤顺序栈实现数制转换（以⼗进制转换为⼆进制为例）1 #include <stdlib.h>2 #include <stdio.h>3 #define MAXSIZE 102445 /*定义顺序栈*/6 typedef int elemtype;7 typedef struct SequenStack8 {9 elemtype data[MAXSIZE];10 int top;11 }SequenStack;1213 /*判（顺序栈）栈空*/14 SequenStack * Init_SequenStack()15 {16 SequenStack * S;17 S = (SequenStack *)malloc(sizeof(SequenStack));1819 if (S == NULL)20 {21 return S;22 }23 S->top = -1;24 return S;25 }2627 /* 判空栈（顺序栈）*/28 int SequenStack_Empty(SequenStack * S)29 {30 if (S->top == -1)31 {32 return 1;33 }34 else35 {36 return 0;37 }38 }3940 /* ⼊栈（顺序栈） */41 int Push_SequenStack(SequenStack * S, elemtype x)42 {43 if (S->top >= MAXSIZE-1)44 {45 return 0;46 }47 S->top++;48 S->data[S->top] = x;49 return 1;50 }5152 /* 出栈（顺序栈） */53 int Pop_SequenStack(SequenStack * S, elemtype * x)54 {55 if (S->top == -1)56 {57 return 0;58 }59 else60 {61 S->top--;62 *x = S->data[S->top+1];63 return 1;64 }65 }6667 /* 进制转换算法 */68 void SequenStackConversion(int N)69 {70 int x;71 SequenStack * S = Init_SequenStack();72 while (N > 0)73 {74 Push_SequenStack(S, N % 2);75 N = N / 2;76 }77 while (! SequenStack_Empty(S))78 {79 Pop_SequenStack(S, &x);80 printf("%d", x);81 }82 }8384 int main()85 {86 int N;87 printf("Please enter the decimal number you want want to convert:\n");88 scanf("%d", &N);89 printf("The converted binary number is:\n");90 SequenStackConversion(N);91 }实现结果：利⽤链栈栈实现数制转换（以⼗进制转换为⼆进制为例）1 #include <stdio.h>2 #include <stdlib.h>34 /*定义链栈*/5 typedef int elemtype;6 typedef struct LinkedStackNode7 {8 elemtype data;9 struct LinkedStackNode *next;10 }LinkedStackNode, *LinkedStack;11 LinkedStack top;1213 /*链栈的初始化*/14 LinkedStack Init_LinkedStack()15 {16 LinkedStack top = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));1718 if(top != NULL)19 {20 top->next = NULL;21 }22 return top;23 }2425 /*判栈空*/26 int LinkedStack_Empty(LinkedStack top)27 {28 if (top->next == NULL)29 {30 return 1;31 }32 else33 {34 return 0;35 }3637 }3839 /*⼊栈*/40 int Push_LinkedStack(LinkedStack top, elemtype x)41 {42 LinkedStackNode *node;43 node = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));4445 if (node == NULL)46 {47 return 0;48 }49 else50 {51 node->data = x;52 node->next = top->next;53 top->next = node;54 return 1;55 }5657 }5859 /*出栈*/60 int Pop_LinkedStack(LinkedStack top, elemtype * x)61 {62 LinkedStackNode *node;63 if (top->next == NULL)64 {65 return 0;66 }67 else68 {69 node = top->next;70 *x = node->data;71 top->next = node->next;72 free(node);73 return 1;74 }7576 }7778 /*进制转换*/79 void ListStackConversion(int N)80 {81 int x;82 LinkedStack S = Init_LinkedStack();83 while (N > 0)84 {85 Push_LinkedStack(S, N % 2);86 N = N / 2;87 }88 while (! LinkedStack_Empty(S))89 {90 Pop_LinkedStack(S, &x);91 printf("%d", x);92 }9394 }9596 int main()97 {98 int N;99 printf("Please enter the decimal number you want want to convert:\n"); 100 scanf("%d", &N);101 printf("The converted binary number is:\n");102 ListStackConversion(N);103 }实现结果：把顺序栈和链栈两种功能综合在⼀起实现数制转换（以⼗进制转换为⼗六进制为例）1 /* 进制转换 */2 #include <stdlib.h>3 #include <stdio.h>4 #define MAXSIZE 100 /*定义顺序栈的长度*/56 /*定义顺序栈*/7 typedef int elemtype;8 typedef struct SequenStack9 {10 elemtype data[MAXSIZE];11 int top;12 }SequenStack;1314 /*定义链栈*/15 typedef int elemtype;16 typedef struct LinkedStackNode17 {18 elemtype data;19 struct LinkedStackNode *next;20 }LinkedStackNode, *LinkedStack;21 LinkedStack top;2223 /* 顺序栈初始化 */24 SequenStack * Init_SequenStack()25 {26 SequenStack * S;27 S = (SequenStack *)malloc(sizeof(SequenStack));2829 if (S == NULL)30 {31 return S;32 }33 S->top = -1;34 return S;35 }3637 /*链栈的初始化*/38 LinkedStack Init_LinkedStack()39 {40 LinkedStack top = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));4142 if(top != NULL)43 {44 top->next = NULL;45 }46 return top;47 }4849 /*判栈（顺序栈）空*/50 int SequenStack_Empty(SequenStack * S)51 {52 if (S->top == -1)53 {54 return 1;55 }56 else57 {58 return 0;59 }60 }6162 /* 判栈（链栈）空 */63 int LinkedStack_Empty(LinkedStack top)65 if (top->next == NULL)66 {67 return 1;68 }69 else70 {71 return 0;72 }7374 }7576 /* ⼊栈（顺序栈）*/77 int Push_SequenStack(SequenStack * S, elemtype x)78 {79 if (S->top >= MAXSIZE-1)80 {81 return 0;82 }83 S->top++;84 S->data[S->top] = x;85 return 1;86 }8788 /* 出栈（顺序栈） */89 int Pop_SequenStack(SequenStack * S, elemtype * x)90 {91 if (S->top == -1)92 {93 return 0;94 }95 else96 {97 S->top--;98 *x = S->data[S->top+1];99 return 1;100 }101 }102103 /* ⼊栈（链栈） */104 int Push_LinkedStack(LinkedStack top, elemtype x)105 {106 LinkedStackNode *node;107 node = (LinkedStackNode *)malloc(sizeof(LinkedStackNode)); 108109 if (node == NULL)110 {111 return 0;112 }113 else114 {115 node->data = x;116 node->next = top->next;117 top->next = node;118 return 1;119 }120121 }122123 /* 出栈（链栈） */124 int Pop_LinkedStack(LinkedStack top, elemtype * x)125 {126 LinkedStackNode *node;127 if (top->next == NULL)128 {129 return 0;130 }131 else132 {133 node = top->next;134 *x = node->data;135 top->next = node->next;136 free(node);137 return 1;138 }139140 }141142 /* 使⽤顺序⽅式进⾏进制转换的函数 */143 void SequenStackConversion(int N)144 {145 int x;146 SequenStack * S = Init_SequenStack();147 while (N > 0)149 Push_SequenStack(S, N % 16); 150 N = N / 16;151 }152 while (! SequenStack_Empty(S))153 {154 Pop_SequenStack(S, &x);155 switch (x)156 {157 case 10:158 printf("A");159 break;160 case 11:161 printf("B");162 break;163 case 12:164 printf("C");165 break;166 case 13:167 printf("D");168 break;169 case 14:170 printf("E");171 break;172 case 15:173 printf("F");174 break;175 default:176 printf("%d", x);177 break;178 }179 }180 }181182 /* 使⽤链栈⽅式进⾏进制转换的函数 */ 183 void ListStackConversion(int N)184 {185 int x;186 LinkedStack S = Init_LinkedStack(); 187 while (N > 0)188 {189 Push_LinkedStack(S, N % 16);190 N = N / 16;191 }192 while (! LinkedStack_Empty(S))193 {194 Pop_LinkedStack(S, &x);195 switch (x)196 {197 case 10:198 printf("A");199 break;200 case 11:201 printf("B");202 break;203 case 12:204 printf("C");205 break;206 case 13:207 printf("D");208 break;209 case 14:210 printf("E");211 break;212 case 15:213 printf("F");214 break;215 default:216 printf("%d", x);217 break;218 }219220 }221222 }223224 void function()225 {226 printf("-------------------------------------------\n"); 227 }228229 /* 主函数调⽤进制转换函数 */230 int main()231 {232 int N, x;233 printf("Please enter the decimal number you want want to convert:\n");234 scanf("%d", &N);235 function();236 printf("Choose using sequential stack or list stack\n");237 printf("1:Sequential stack 2:list stack:\n");238 function();239 scanf("%d", &x);240 printf("The converted binary number is:\n");241 switch (x)242 {243 case 1:244 SequenStackConversion(N);245 break;246 case 2:247 ListStackConversion(N);248 break;249 default:250 printf("error");251 break;252 }253254 return 0;255 }值得注意的是，当⼗进制转换为⼗六进制的时候，需要考虑输出现实⼤于9的⼗六进制位数，这⾥我们考虑可以使⽤switch开关实现。

数据结构实验报告栈进制转换数据结构实验报告栈进制转换一、实验目的栈是一种常见的数据结构，本实验的目的在于通过实现栈的基本操作，设计并实现一个进制转换的程序，并通过实验验证程序的正确性和效率。

二、实验原理1.栈的定义和基本操作栈是一种后进先出（Last In First Out，简称LIFO）的数据结构。

它可以通过一个指针来标识当前栈顶元素，栈顶指针top的起始值为-1，空栈时top=-1.2.栈的进制转换将一个十进制数转换为其他进制（如二进制、八进制、十六进制）的过程中，可以通过栈来实现。

具体步骤如下：- 初始化一个空栈；- 将十进制数依次除以目标进制的基数，将余数依次入栈，直到商为0；- 依次出栈，将出栈的余数组合起来，得到转换后的目标进制数。

三、实验内容1.实现栈的基本操作（1）定义栈结构，包括元素数组和栈顶指针；（2）实现入栈操作push()，将元素插入到栈顶；（3）实现出栈操作pop()，从栈顶删除一个元素并返回其值；（4）实现获取栈顶元素的操作getTop()，返回栈顶元素的值；（5）实现判断栈是否为空的操作isEmpty()，返回布尔值；（6）实现判断栈是否已满的操作isFull()，返回布尔值。

2.设计并实现进制转换的程序（1）初始化一个空栈用于存放转换后的数字；（2）输入十进制数num和目标进制target；（3）通过栈的操作将num转换为target进制数；（4）输出转换后的结果。

四、实验步骤1.实现栈的基本操作（1）定义栈的结构和相关操作；（2）编写相应的测试代码，验证栈的基本操作是否正确。

2.设计并实现进制转换的程序（1）根据原理部分的步骤，设计转换程序的具体逻辑；（2）编写相应的测试代码，验证转换程序的正确性和效率。

五、实验结果与分析1.给定一个十进制数num=12345，目标进制为二进制（target=2），经过进制转换后得到的结果为.111.2.给定一个十进制数num=456，目标进制为八进制（target=8），经过进制转换后得到的结果为.710.本实验的结果表明，转换程序能够正确地将十进制数转换为目标进制数，并且具有较高的效率。

数据结构c语言版第三版习题解答数据结构 C 语言版第三版习题解答在学习计算机科学与技术的过程中，数据结构是一门非常重要的基础课程。

而《数据结构C 语言版第三版》更是众多教材中的经典之作。

其中的习题对于我们理解和掌握数据结构的概念、原理以及算法实现起着至关重要的作用。

接下来，我将为大家详细解答这本书中的一些典型习题。

首先，让我们来看一道关于线性表的习题。

题目是这样的：设计一个算法，从一个有序的线性表中删除所有其值重复的元素，使表中所有元素的值均不同。

对于这道题，我们可以采用双指针的方法来解决。

定义两个指针 p和 q，p 指向线性表的开头，q 从 p 的下一个位置开始。

当 q 所指向的元素与 p 所指向的元素相同时，我们就将 q 所指向的元素删除，并将 q 向后移动一位。

当 q 所指向的元素与 p 所指向的元素不同时，我们将 p 向后移动一位，并将 q 所指向的元素赋值给 p 所指向的位置，然后再将 q 向后移动一位。

当 q 超出线性表的范围时，算法结束。

下面是用 C 语言实现的代码：｀｀｀cvoid removeDuplicates(int arr, int n) ｛int p ＝ 0, q ＝ 1;while （q ＜ n) ｛if （arrp ＝＝ arrq) ｛for （int i ＝ q; i ＜ n 1; i+＋）｛arri ＝ arri ＋ 1;｝（n)；｝ else ｛p+＋；arrp ＝ arrq;｝q+＋；｝｝｀｀｀再来看一道关于栈的习题。

题目是：利用栈实现将一个十进制数转换为八进制数。

我们知道，将十进制数转换为八进制数可以通过不断除以 8 取余数的方法来实现。

而栈的特点是后进先出，正好适合存储这些余数。

以下是 C 语言实现的代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>define MAX_SIZE 100typedef struct ｛int top;int dataMAX_SIZE;｝ Stack;／／初始化栈void initStack(Stack s) ｛s>top ＝－1;｝／／判断栈是否为空int isEmpty(Stack s) ｛return s>top ＝＝－1;｝／／判断栈是否已满int isFull(Stack s) ｛return s>top ＝＝ MAX_SIZE 1;｝／／入栈操作void push(Stack s, int element) ｛if （isFull(s)）｛printf(＂Stack Overflow!＼n"）；return;｝s>data+＋s>top ＝ element;｝／／出栈操作int pop(Stack s) ｛if （isEmpty(s)）｛printf(＂Stack Underflow!＼n"）；return －1;｝return s>datas>top;｝／／将十进制转换为八进制void decimalToOctal(int decimal) ｛Stack s;initStack(＆s)；while （decimal!＝ 0) ｛push(＆s, decimal ％ 8)；decimal ／＝ 8;｝while （！isEmpty(＆s)）｛printf(＂％d"， pop(＆s)）；｝printf(＂＼n"）；｝int main(）｛int decimal;printf(＂请输入一个十进制数: ＂）；scanf(＂％d"，＆decimal)；printf(＂转换后的八进制数为: ＂）；decimalToOctal(decimal)；return 0;｝｀｀｀接下来是一道关于队列的习题。

c语言基于栈的进制转换栈是一种非常重要的数据结构，在计算机科学中应用广泛。

而基于栈的进制转换是我们在学习计算机编程过程中经常遇到的问题之一。

本文将介绍什么是栈、栈的特性以及如何利用栈实现进制转换。

首先，我们先来了解一下栈的概念。

栈是一种后进先出（LIFO）的数据结构，可以类比成一摞盘子，每次我们在放新盘子时都会把它放在现有的盘子顶部，而取出盘子时也是从顶部开始取。

栈有两个基本操作：压栈（push）和出栈（pop）。

压栈表示往栈中添加一个元素，出栈表示从栈中取出一个元素。

栈的特性使其对于进制转换非常适用。

我们知道，计算机中常用的进制有十进制、二进制、八进制和十六进制。

这些进制之间的转换可以借助栈来实现。

以十进制转二进制为例，我们可以使用栈来进行转换。

具体步骤如下：1. 将十进制数不断除以2，直到商为0为止。

2. 将每次的余数压入栈中。

3. 依次出栈，得到的就是转换后的二进制数。

这是因为，栈的后进先出特性使得每个余数都按照相反的顺序出栈，最后得到的二进制数也是正确的。

类似地，我们也可以用栈来实现其他进制之间的转换。

只需要将除以对应进制，将余数压入栈，然后依次出栈即可。

除了进制转换，栈还可以应用于其他方面。

比如，括号匹配问题就可以使用栈来解决。

通过遍历字符串，当遇到左括号时，将其压入栈中；当遇到右括号时，检查栈顶元素是否为与之匹配的左括号。

如果匹配成功，则将栈顶元素出栈；如果匹配失败，则表示括号不匹配，整个表达式无效。

总之，栈是一种非常有用的数据结构，可以应用于进制转换、括号匹配等多种场景。

对于初学者来说，理解栈的特性和使用方法对于掌握编程技巧非常重要。

通过解决实际问题，加深对栈的理解，相信能够在编程中得心应手。

C语⾔⽤栈实现⼗进制转换为⼆进制的⽅法⽰例本⽂实例讲述了C语⾔⽤栈实现⼗进制转换为⼆进制的⽅法。

分享给⼤家供⼤家参考，具体如下：#include<stdio.h>#include<malloc.h>#include<math.h>#include<string.h>#include "process.h"#define SIZE 100#define STACKINCREMENT 10#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;typedef struct{int a;} SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;} SqStack;SqStack S; //定义全局变量Status InitStack(SqStack *S){S->base=(SElemType *)malloc(SIZE*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base;S->stacksize=SIZE;return OK;}Status Push(SqStack *S,SElemType e){if(S->top-S->base>=S->stacksize){S->base=(SElemType *)malloc((S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;//printf("%dwww\n",*--S->top);return OK;}Status Stackempty(SqStack *S){if(S->top==S->base)return TRUE;elsereturn FALSE;}Status Pop(SqStack *S,SElemType *e){if(S->top==S->base) return ERROR;*e=*--S->top;return OK;}Status DtoBTrans(int N,SqStack *S){SElemType e;while(N){e.a=N%2;Push(S,e);N=N/2;}while(!Stackempty(S)){Pop(S,&e);printf("%d",e);}return OK;}void main(){int x;InitStack(&S);printf("请输⼊⼗进制数：");scanf("%d",&x);DtoBTrans(x,&S);}运⾏结果：希望本⽂所述对⼤家C语⾔程序设计有所帮助。

最后运行结果：代码：#include <stdio.h>#include <stdlib.h>typedef struct Node{int data;struct Node *next;}StackNode;StackNode *top = NULL;void Push(int e){StackNode *p;p = (StackNode *)malloc(sizeof(StackNode));p->data = e;p->next = top;top = p;}bool IsEmpty(){return top == NULL ? true : false;}int Pop(){StackNode *p;int e;if (IsEmpty()){printf("The stack is empty, failed to pop!\n");return NULL;}p = top;e = p->data;top = top->next;free(p);return e;}void Print(){StackNode *p;p = top;if (IsEmpty()){printf("The stack is empty!\n");return;}printf("转换后的结果是：");while (p){if (p->data<10)printf("%d ", p->data);else{if (p->data == 10)printf("a");else if (p->data == 11)printf("b");else if (p->data == 12)printf("c");else if (p->data == 13)printf("d");else if (p->data == 14)printf("e");else if (p->data == 15)printf("f");else printf("data is wrong!");}p = p->next;}printf("\n");}void main(){int m, c, d, n;printf("请输入要转换的十进制数：");scanf("%d", &m);printf("\n");printf("请输入转换进制：\n");printf("******************************\n");printf("* 请选择一个你要转换的进制*\n");printf("* 1.二进制*\n");printf("* 2.八进制*\n");printf("* 3.十六进制*\n");printf("******************************\n");scanf("%d", &d);printf("\n");if (d == 1)n = 2;else if (d == 2)n = 8;else if (d == 3)n = 16;else printf("输入有误！");while (m){c = m%n;m = m / n;Push(c);}Print();}。

用C语言解决数制转换问题摘要数据结构是计算机存储、组织数据的方式。

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

一般认为，一个数据结构是由数据元素依据某种逻辑联系组织起来的。

对数据元素间逻辑关系的描述称为数据的逻辑结构；数据必须在计算机内存储，数据的存储结构是数据结构的实现形式，是其在计算机内的表示；此外讨论一个数据结构必须同时讨论在该类数据上执行的运算才有意义。

在许多类型的程序的设计中，数据结构的选择是一个基本的设计考虑因素。

许多大型系统的构造经验表明，系统实现的困难程度和系统构造的质量都严重的依赖于是否选择了最优的数据结构。

许多时候，确定了数据结构后，算法就容易得到了。

有些时候事情也会反过来，我们根据特定算法来选择数据结构与之适应。

不论哪种情况，选择合适的数据结构都是非常重要的。

本课程设计主要使用不同的数据结构解决数制转换的问题。

在课程设计中，系统开发平台为Windows7，程序设计设计语言采用C语言，程序运行平台为Windows 98/2000/XP/7。

关键词程序设计；数制转换；C；课程设计；数据结构1 引言1. 课程设计目的高速发展的现代社会，计算机浩浩荡荡地成为了人们生活中不可缺少的一部分，帮助人们解决通信，联络，互动等各方面的问题。

计算机在处理数字是和人是不同的，计算机使用的是二进制，人们在日常生活中使用十进制，但是在一些特定场合使用其他进制的表示，所以需要进行不同进制之间的转换。

本课程设计主要解决不同的进制之间的转换问题，并且采用不同的数据结构进行存储和转换，实现普通的进制之间的转换。

在程序设计中，可以用使用很多种方法解决该问题。

例如：数组、栈、递归。

不同的方法实现转换的原理基本相同，只是代码的细节不同。

在我的程序中不同的方法所需的函数在一个单独的头文件里面，便以管理和修改。

2. 数据结构设计（1）数组的结构由于处理简单的情况，最大的数字将不大于整形的范围，在VS2008整形为4个字节，因此开辟的数组为33个元素。