数据结构-栈十进制转八进制的算法详解(已测试过)

十进制转八进制C语言
简介
在计算机科学中，数字通常以十进制表示，即使用0-9的数字进行计数。

而在计算机底层，二进制是最基本的表示方式，只使用0和1两个数字。

但在实际编程中，有时需要将十进制数转换为其他进制，比如八进制。

C语言作为一种常用的编程语言，提供了快速和简单的方法来进行十进制到八进制的转换。

实现
在C语言中，可以使用一种迭代的方式将十进制数转换为八进制。

下面是一个简单的C语言函数，可以实现十进制到八进制的转换：
```c #include <stdio.h>
void decimalToOctal(int decimal) { int octal[100]; int index = 0;
while (decimal > 0) {
octal[index] = decimal % 8;
decimal /= 8;
index++;
}
printf(\。

在我们接触编程知识时，总会接触有关进制转换的知识，最常见的就是10进制与二进制或十六进制之间的转换，很多时候我们总会遗忘，虽然现在也出现了很多可以直接使用的网络在线的进制转换工具，但考试中，我们就要靠自己通过公式进行运算了。

今天就跟大家分享一下有关进制转换的理论知识，大家可以通过对比从里面发现共同点，这样便于我们理解记忆。

在进行讲解之前，我们先在下面放置一个对应表，因为在理解下面转换的时候，你可以随时查看该表。

一、十进制与二进制之间的转换（1）十进制转换为二进制，分为整数部分和小数部分①整数部分方法：除2取余法，即每次将整数部分除以2，余数为该位权上的数，而商继续除以2，余数又为上一个位权上的数，这个步骤一直持续下去，直到商为0为止，最后读数时候，从最后一个余数读起，一直到最前面的一个余数。

下面举例：例：将十进制的168转换为二进制得出结果将十进制的168转换为二进制，（10101000）2分析:第一步，将168除以2商84余数为0。

第二步，将商84除以2，商42余数为0。

第三步，将商42除以2，商21余数为0。

第四步，将商21除以2，商10余数为1。

第五步，将商10除以2，商5余数为0。

第六步，将商5除以2，商2余数为1。

第七步，将商2除以2，商1余数为0。

第八步，将商1除以2，商0余数为1。

第九步，读数，因为最后一位是经过多次除以2才得到的，因此它是最高位，读数字从最后的余数向前读，即10101000②小数部分方法：乘2取整法，即将小数部分乘以2，然后取整数部分，剩下的小数部分继续乘以2，然后取整数部分，剩下的小数部分又乘以2，一直取到小数部分为零为止。

如果永远不能为零，就同十进制数的四舍五入一样，按照要求保留多少位小数时，就根据后面一位是0还是1，取舍，如果是零，舍掉，如果是1，向入一位。

换句话说就是0舍1入。

读数要从前面的整数读到后面的整数，下面举例：例1：将0.125换算为二进制得出结果：将0.125换算为二进制（0.001）2分析：第一步，将0.125乘以2，得0.25则整数部分为0小数部分为0.25;第二步将小数部分0.25乘以2得0.5则整数部分为0小数部分为0.5;第三步将小数部分0.5乘以2得1.0则整数部分为1小数部分为0.0;第四步读数从第一位读起读到最后一位即为0.001。

二进制，八进制,十进制，十六进制之间的转换算法一、十进制与二进制之间的转换（1）十进制转换为二进制，分为整数部分和小数部分①整数部分方法：除2取余法，即每次将整数部分除以2，余数为该位权上的数，而商继续除以2，余数又为上一个位权上的数，这个步骤一直持续下去，直到商为0为止，最后读数时候，从最后一个余数读起，一直到最前面的一个余数。

下面举例：例：将十进制的168转换为二进制得出结果将十进制的168转换为二进制，（10101000）2分析:第一步，将168除以2,商84,余数为0。

第二步，将商84除以2，商42余数为0。

第三步，将商42除以2，商21余数为0。

第四步，将商21除以2，商10余数为1。

第五步，将商10除以2，商5余数为0。

第六步，将商5除以2，商2余数为1。

第七步，将商2除以2，商1余数为0。

第八步，将商1除以2，商0余数为1。

第九步，读数，因为最后一位是经过多次除以2才得到的，因此它是最高位，读数字从最后的余数向前读，即10101000（2）小数部分方法：乘2取整法，即将小数部分乘以2，然后取整数部分，剩下的小数部分继续乘以2，然后取整数部分，剩下的小数部分又乘以2，一直取到小数部分为零为止。

如果永远不能为零，就同十进制数的四舍五入一样，按照要求保留多少位小数时，就根据后面一位是0还是1，取舍，如果是零，舍掉，如果是1，向入一位。

换句话说就是0舍1入。

读数要从前面的整数读到后面的整数，下面举例：例1：将0.125换算为二进制得出结果：将0.125换算为二进制（0.001）2分析：第一步，将0.125乘以2，得0.25,则整数部分为0,小数部分为0.25;第二步, 将小数部分0.25乘以2,得0.5,则整数部分为0,小数部分为0.5;第三步, 将小数部分0.5乘以2,得1.0,则整数部分为1,小数部分为0.0;第四步,读数,从第一位读起,读到最后一位,即为0.001。

例2,将0.45转换为二进制（保留到小数点第四位）大家从上面步骤可以看出，当第五次做乘法时候，得到的结果是0.4，那么小数部分继续乘以2，得0.8，0.8又乘以2的，到1.6这样一直乘下去，最后不可能得到小数部分为零，因此，这个时候只好学习十进制的方法进行四舍五入了，但是二进制只有0和1两个，于是就出现0舍1入。

十进制转八进制c语言十进制转八进制是一种常见的数值转换方法，在C语言中可以非常简单地实现，让我们来看看如何进行这个转换。

首先，需要明确的是十进制和八进制之间的转换规律。

在十进制数转换成八进制数时，我们可以将其每三位一组分离出来，每组数字按权值相加得到对应的八进制数。

例如，十进制数734对应的八进制数为1326，其中：7 x 10^2 + 3 x 10^1 + 4 x 10^0 = 1 x 8^3 + 3 x 8^2 + 2 x 8^1 + 6 x 8^0知道了这个规律之后，我们就可以开始写C语言代码了。

具体而言，可以使用while循环来不断从输入中读取十进制数，然后将其转换成八进制数并输出。

代码如下：```c#include <stdio.h>int main() {int decimal, octal, remainder, place = 1;printf("请输入一个十进制数：");scanf("%d", &decimal);octal = 0;// 将十进制数转换成八进制数while (decimal != 0) {remainder = decimal % 8;octal += remainder * place;place *= 10;decimal /= 8;}printf("该数的八进制表示为：%d\n", octal);return 0;}```在这个代码中，我们首先声明了四个变量：decimal用于存储输入的十进制数，octal用于存储转换后的八进制数，remainder用于临时存储余数，place用于表示当前位数的权值。

接着，我们通过scanf语句从标准输入中读取一个整数，将其赋值给decimal。

然后，在一个while循环中，我们使用类似于上面的转换规律来将decimal转换成八进制数。

具体而言，我们不断地计算decimal除以8的余数，然后将其乘以对应的权值加入到octal中。

栈的应⽤-数制转换（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开关实现。

十进制转化为八进制c语言
在C语言中，将十进制数转换为八进制数可以使用以下步骤：
1. 将十进制数除以8，将余数记录下来，直到商为0为止。

2. 将所有的余数组合在一起，倒序排列就是对应的八进制数。

以下是使用C语言实现十进制转换为八进制的示例代码：
```c
#include <stdio.h>
int main() {
int decimal, remainder, octal = 0, i = 1;
printf('Enter a decimal number: ');
scanf('%d', &decimal);
while (decimal != 0) {
remainder = decimal % 8;
decimal /= 8;
octal += remainder * i;
i *= 10;
}
printf('Octal equivalent: %d', octal);
return 0;
}
```
运行程序后，输入一个十进制数，程序会将其转换为对应的八进
制数并输出。

注意，使用整数变量存储八进制数时要使用前缀0来表示。

例如，十进制数25转换为八进制数后应该表示为031。

十进制转化为八进制的代码
在计算机编程中，经常需要将十进制的数字转化为其他进制，其中八进制也是一个常见的进制。

以下是将十进制转化为八进制的代码示例：
```
#include <stdio.h>
int main()
{
int decimal, octal = 0, i = 1;
printf('请输入一个十进制数：');
scanf('%d', &decimal);
while (decimal != 0)
{
octal += (decimal % 8) * i;
decimal /= 8;
i *= 10;
}
printf('转换为八进制为：%d
', octal);
return 0;
}
```
以上代码首先要求用户输入一个十进制数，然后通过循环将该数转化为八进制。

具体实现中，通过不断取余数和整除来得到八进制数的每一位，并将其乘以相应的位数加到最终结果中。

最后，将转化后的八进制数输出到屏幕上。

数据结构课程设计设计说明书进制转换的实现学生JUGG学号¥ #…班级Dota all star ------------------成绩___________ 优秀__________ 指导教师Puckdota科学与技术天灾元年3月14日数据结构课程设计评阅书Dota all star设计题目：___________________________ 进制转换的实现________________________________________________ 完成期限：自_天灾元年年二月J 日至_近卫戊年_年_______________________ 月J4 ______ 日共2周设计依据、要求及主要容（可另加附页）：进制数制是人们利用符号进行计数的科学方法。

数制有很多种，在计算机中常用的数制有：十进制，二进制、八进制和十六进制。

十六进制数有两个基本特点：它由十六个字符0〜9以及A, B, C, D,E, F组成（它们分别表示十进制数0〜15）,十六进制数运算规律是逢十六进一，例如：十六进制数4AC8 可写成（4AC8）16,或写成4AC8H要求：（1）输入一个十进制数N,将它转换成R进制数输出，并可以进行逆转换。

（2）输入数据包含多个测试实例，每个测试实例包含两个整数N（32位整数）和R （2<=R<=16,R<>10）。

（3）为每个测试实例输出转换后的数，每个输出占一行。

如果R大于10,则对应的数字规则参考16进制（比如，10用A表示，等等）。

（4）界面友好。

指导教师（签字）：___________________ 教研室主任（签字）：_________________________批准日期：年月日摘要由于数制计算和不同数制之间转换的需要，设计了一个10 进制转换其它进制（36 进制以）及逆转换的软件，该软件具有简单的将10进制数转换成2、8、16 进制数以及较复杂的高进制数的转换和逆转功能。

十进制转化为八进制的代码
十进制转化为八进制是编程中非常基础并且实用的操作，本文将会教会读者如何用代码来完成这一转化。

首先，我们需要先了解十进制和八进制的概念。

十进制是指以10为基数的数字系统，即0~9十个数字。

而八进制则是以8为基数的数字系统，即0~7七个数字。

因此，将十进制转化为八进制的过程也就是将十进制的数字按照八进制的规则计算出来。

下面是一个Python代码示例，可以将用户输入的十进制数字转化为八进制：
```
dec = int(input("请输入一个十进制数字: ")) # 读取用户输入的数字
octal = oct(dec) # 将数字转化为八进制
print("该数字的八进制形式为: " + str(octal)) # 输出转化后的结果
```
以上代码中，input()函数用于读取用户输入的数字，int()函数将该数字转化为整型变量。

接着，oct()函数将整型变量转化为八进制数字，并赋值给变量octal。

最后，使用print()函数输出结果。

需要注意的是，在Python中使用oct()函数可以直接将十进制转化为八进制，而不需要手动计算。

但是在其他编程语言中，可能需要手动计算和转化。

总体来说，将十进制转化为八进制需要理解数制之间的关系，并掌握基本的计算方法。

通过代码示例，我们可以轻松地实现这一转化操作。

将十进制转换成八进制的方法嘿，朋友们！今天咱来唠唠怎么把十进制转成八进制。

这事儿啊，就好比你有一堆糖果，要把它们重新分组一样。

十进制嘛，咱平时用得可多啦，什么 10、20、100 呀，都是十进制的数。

那八进制呢，就是用 0 到 7 这几个数字来表示。

你想啊，十进制就像是走在一条直直的大道上，每走一段就是一个新的数。

而八进制呢，就像是走进了一个有八个房间的屋子，每个房间都有特定的意义。

那怎么转换呢？嘿嘿，这就有门道啦！咱可以用除法呀。

就拿一个十进制数来说吧，比如 50。

咱就用 50 除以 8，得到商是 6，余数是 2。

这时候，余数 2 就是八进制数的最后一位。

然后呢，把商 6 再除以 8，又得到商 0，余数 6。

那这个 6 就是八进制数的前面一位啦。

所以 50 转成八进制就是 62 呀！是不是挺有意思的？这就好像你分苹果，先把一堆苹果分成 8 份，剩下几个就是最后一位，然后再把分好的份数继续分，依次类推。

再比如说 100 吧，除以 8 得到商 12，余数 4，然后 12 除以 8 得到商1，余数 4，最后 1 除以 8 得到商 0，余数 1。

那 100 转成八进制就是 144 啦！哎呀呀，这转换过程就像是一场有趣的游戏，你得仔细算，可不能马虎哟！不然就像搭积木没搭稳，一下子就垮啦。

其实啊，学会了这个，你就掌握了一种神奇的魔法，可以在十进制和八进制的世界里自由穿梭。

你想想，当别人还在迷糊的时候，你已经能轻松转换啦，那多牛啊！而且呀，这在很多地方都有用呢。

比如在计算机编程里，八进制可是经常用到的哦。

你要是不懂这个，那可就有点跟不上节奏啦。

所以啊，朋友们，赶紧把这个小技巧学会吧，以后说不定啥时候就能派上大用场呢！让我们一起在数字的海洋里畅游，把十进制和八进制都玩得团团转！这多带劲呀！就这么着吧，大家快去试试吧！。

数制转换数据结构课程设计报告一、课程设计目的本次数制转换数据结构课程设计的主要目的是通过实际编程实现不同数制之间的转换，加深对数据结构和算法的理解和运用。

具体而言，包括熟练掌握栈和队列等数据结构，以及运用递归、循环等算法思想来解决实际问题。

二、需求分析数制转换是计算机科学中常见的操作，常见的数制包括二进制、八进制、十进制和十六进制。

用户需要输入一个数以及其对应的原始数制，然后选择要转换的目标数制，程序能够准确地进行转换并输出结果。

三、数据结构选择在本次课程设计中，选择使用栈来实现数制转换。

栈具有后进先出的特点，非常适合在数制转换中进行余数的存储和处理。

四、算法设计（一）十进制转换为其他进制1、十进制转换为二进制：采用除 2 取余的方法，将每次除法的余数压入栈中，最后依次出栈得到二进制数。

2、十进制转换为八进制：采用除 8 取余的方法，与二进制类似，将余数压入栈中，最后出栈得到八进制数。

3、十进制转换为十六进制：除 16 取余，不过余数可能是 0 9 以及A F ，需要进行特殊处理。

（二）其他进制转换为十进制1、二进制转换为十进制：从右往左依次用二进制位上的数字乘以2 的相应位数的幂，然后将结果相加。

2、八进制转换为十进制：从右往左依次用八进制位上的数字乘以8 的相应位数的幂，然后将结果相加。

3、十六进制转换为十进制：从右往左依次用十六进制位上的数字乘以 16 的相应位数的幂，然后将结果相加。

A F 分别表示 10 15 。

（三）其他进制之间的转换通过先将原始进制转换为十进制，再将十进制转换为目标进制来实现。

五、程序实现以下是使用 C 语言实现的部分核心代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>／／定义栈的数据结构typedef struct Stack ｛int data;int top;int capacity;｝ Stack;／／创建栈Stack createStack(int capacity) ｛Stack stack ＝（Stack ）malloc(sizeof(Stack)）；stack>data ＝（int ）malloc(capacity sizeof(int)）；stack>top ＝－1;stack>capacity ＝ capacity;return stack;｝／／入栈操作void push(Stack stack, int element) ｛if （stack>top ＝＝ stack>capacity 1) ｛printf(＂Stack Overflow!＼n"）；return;｝stack>data+＋stack>top ＝ element;｝／／出栈操作int pop(Stack stack) ｛if （stack>top ＝＝－1) ｛printf(＂Stack Underflow!＼n"）；return －1;｝return stack>datastack>top;｝／／十进制转二进制void decimalToBinary(int decimal) ｛Stack stack ＝ createStack(32)；while （decimal ＞ 0) ｛push(stack, decimal ％ 2)；decimal ／＝ 2;while （stack>top!＝－1) ｛printf(＂％d"， pop(stack)）；｝printf(＂＼n"）；free(stack>data)；free(stack)；｝／／十进制转八进制void decimalToOctal(int decimal) ｛Stack stack ＝ createStack(16)；while （decimal ＞ 0) ｛push(stack, decimal ％ 8)；decimal ／＝ 8;｝while （stack>top!＝－1) ｛printf(＂％d"， pop(stack)）；printf(＂＼n"）；free(stack>data)；free(stack)；｝／／十进制转十六进制void decimalToHexadecimal(int decimal) ｛Stack stack ＝ createStack(16)；while （decimal ＞ 0) ｛int remainder ＝ decimal ％ 16;if （remainder ＜ 10) ｛push(stack, remainder ＋＇0'）；｝ else ｛push(stack, remainder 10 ＋＇A'）；｝decimal ／＝ 16;｝while （stack>top!＝－1) ｛printf(＂％c"， pop(stack)）；｝printf(＂＼n"）；free(stack>data)；free(stack)；｝／／二进制转十进制int binaryToDecimal(char binary) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(binary)；for （int i ＝ length 1; i ＞＝ 0; i) ｛if （binaryi ＝＝＇1'）｛decimal ＋＝ power;｝power ＝ 2;｝return decimal;｝／／八进制转十进制int octalToDecimal(char octal) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(octal)；for （int i ＝ length 1; i ＞＝ 0; i) ｛decimal ＋＝（octali ＇0'） power;power ＝ 8;｝return decimal;｝／／十六进制转十进制int hexadecimalToDecimal(char hexadecimal) ｛int decimal ＝ 0, power ＝ 1;int length ＝ strlen(hexadecimal)；for （int i ＝ length 1; i ＞＝ 0; i) ｛if （hexadecimali ＞＝＇0' ＆＆ hexadecimali ＜＝＇9'）｛decimal ＋＝（hexadecimali ＇0'） power;｝ else if （hexadecimali ＞＝＇A' ＆＆ hexadecimali ＜＝＇F'）｛decimal ＋＝（hexadecimali ＇A' ＋ 10) power;｝power ＝ 16;｝return decimal;｝int main(）｛int choice, decimal;char sourceNumber32;printf(＂1、 Decimal to Binary\n"）；printf(＂2、 Decimal to Octal\n"）；printf(＂3、 Decimal to Hexadecimal\n"）；printf(＂4、 Binary to Decimal\n"）；printf(＂5、 Octal to Decimal\n"）；printf(＂6、 Hexadecimal to Decimal\n"）；printf(＂Enter your choice: ＂）；scanf(＂％d"，＆choice)；switch （choice) ｛case 1:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToBinary(decimal)；break;case 2:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToOctal(decimal)；break;case 3:printf(＂Enter decimal number: ＂）；scanf(＂％d"，＆decimal)；decimalToHexadecimal(decimal)；break;case 4:printf(＂Enter binary number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， binaryToDecimal(sourceNumber)）；break;case 5:printf(＂Enter octal number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， octalToDecimal(sourceNumber)）；break;case 6:printf(＂Enter hexadecimal number: ＂）；scanf(＂％s"， sourceNumber)；printf(＂％d\n"， hexadecimalToDecimal(sourceNumber)）；break;default:printf(＂Invalid choice!＼n"）；｝return 0;｝｀｀｀六、测试与结果分析（一）测试用例1、十进制 10 转换为二进制、八进制、十六进制。

C++源代码文辑代码名称：十进制转换为八进制编程工具： Microsoft Visual C++ 6.0 作者：长风夜雨#define STACKINCREMENT 10;#define OVERFLOW 0#define OK 1#define ERROR 0typedefstruct{int *base;int *top;intstacksize;} SqStack;intInitStack (SqStack *S){// 构造一个空栈SS->base = (int *)malloc( 100 * sizeof(int));if (!S->base) return OVERFLOW; //存储分配失败S->top = S->base;S->stacksize = STACK_INIT_SIZE;return OK;};int Push (SqStack *S, int e){if (S->top - S->base >= S->stacksize) //栈满,追加存储空间{S->base = (int *) realloc( S->base,(S->stacksize + 10) *sizeof (int));if (!S->base) return OVERFLOW; //存储分配失败S->top = S->base + S->stacksize;S->stacksize += STACKINCREMENT;};*S->top++ = e;return OK;};int Pop (SqStack *S, int *e){ // 若栈不空，则删除S的栈顶元素，// 用e返回其值，并返回OK；// 否则返回ERRORif (S->top == S->base) return ERROR;*e = *--S->top;return OK;};boolStackEmpty(SqStack *S){if (S->top - S->base == 0){return 1;}else{return 0;};};void conversion (){SqStack S;int N, e;InitStack(&S);printf ( "Please input the num\n"); scanf ("%d",&N);while (N){Push(&S, N % 8);N = N/8;};while (!StackEmpty(&S)){Pop(&S, &e);printf ( "%d", e );};printf ( "\n");} // conversionvoid main(){conversion();}附：一个超低价虚拟业务联盟网站：http://xuni588.wdwd.co m。

十进制与八进制的转换在计算机科学和数字系统中，常常需要在十进制和八进制之间进行转换。

十进制是我们平常所使用的十个数字（0-9）的数字系统，而八进制则是使用八个数字（0-7）的数字系统。

本文将讨论十进制与八进制之间的相互转换方法。

一、十进制转换为八进制要将一个十进制数转换为八进制数，我们需要使用除法和取模的方法。

1. 将十进制数除以八，并记录下商和余数。

2. 将上一步得到的商再次除以八，并继续记录商和余数。

3. 重复以上步骤，直到商为零为止。

4. 逆序排列所获得的所有余数，即为对应的八进制数。

举例来说，我们将十进制数45转换为八进制数。

首先，将45除以8，商为5，余数为5。

然后，将商5再次除以8，商为0，余数为5。

因为商为0，我们停止计算。

最后，逆序排列的余数为55，即为45的八进制表示。

二、八进制转换为十进制要将一个八进制数转换为十进制数，我们需要使用乘法和求和的方法。

1. 将八进制数的最右边一位与八的零次方相乘。

2. 将八进制数的倒数第二位与八的一次方相乘。

3. 重复以上步骤，直到所有位数都与相应次方相乘。

4. 将所有乘积求和，结果即为对应的十进制数。

举例来说，我们将八进制数55转换为十进制数。

首先，将八进制数的最右边一位5与八的零次方1相乘，结果为5。

然后，将八进制数的倒数第二位5与八的一次方8相乘，结果为40。

最后，将两个乘积5和40求和，结果为45，即为55的十进制表示。

三、实际应用举例八进制数在计算机科学中有着广泛的应用。

例如，在使用Linux系统时，文件和文件夹的权限是通过八进制数表示的。

每个权限由三个数字组成，分别代表拥有者、所属组和其他用户的权限。

假设一个文件的权限为644。

将这个权限转换为八进制数，我们可以按照以下步骤进行计算。

首先，将每个权限的数字独立转换为八进制数。

6转换为110，4转换为100。

最后，将所有三个权限的八进制数按顺序排列，得到最终的八进制表示为644。

同样，如果我们有一个八进制数752，我们可以按照以下步骤将其转换为十进制数。

c语言十进制转八进制和十六进制在计算机科学中，数值的表示方法通常有十进制、二进制、八进制和十六进制。

在实际应用中，常常需要将十进制数转换为其他进制。

下面是详细的转换方法和步骤。

1. 十进制转二进制每个十进制数都可以转换为二进制形式。

基本步骤如下：1. 将十进制数用2整除，得到商和余数（1或0）；2. 将商再用2整除，得到新的商和余数；3. 不断重复上述步骤，直到商为0为止，将每一步的余数从低位到高位依次排列，即可得到该数的二进制表示。

例如，将十进制数23转换为二进制：```23 ÷2 = 11 余111 ÷2 = 5 余15 ÷2 = 2 余12 ÷2 = 1 余01 ÷2 = 0 余1将每一步的余数从低位到高位依次排列，得到23的二进制表示为10111。

```2. 二进制转八进制二进制数转换为八进制的方法是，每三位二进制数合并为一组，然后按照八进制数的规则进行转换。

具体步骤如下：1. 将二进制数每三位为一组进行划分，余数不足三位的单独一组；2. 每组二进制数转换为一个八进制数，转换规则是：000 -> 0、001 -> 1、010 -> 2、011 -> 3、100 -> 4、101 -> 5、110 -> 6、111 -> 7。

例如，将二进制数1011001转换为八进制：```yaml101 100 1012 004 007 (每三位为一组，转换对应的八进制数)```3. 二进制转十六进制二进制数转换为十六进制的方法是，每四位二进制数合并为一组，然后按照十六进制数的规则进行转换。

具体步骤如下：1. 将二进制数每四位为一组进行划分，余数不足四位的单独一组；2. 每组二进制数转换为一个十六进制数，转换规则是：0000 -> 0、0001 -> 1、0010 -> 2、一直到1111 -> F。

实验目的建立栈实现十进制转八进制实验内容编程序并上机调试运行。

建立栈实现十进制转八进制1.编写程序//十进制转八进制#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct {int *base;int *top;int stacksize;}sqstack;int initstack (sqstack *s){s->base=(int *)malloc(STACK_INIT_SIZE * sizeof(int)); if(!s->base)exit(0);s->top=s->base;s->stacksize =STACK_INIT_SIZE ;return 0;}// 构造一个空栈sint push(sqstack *s,int e){ if((s->top-s->base)>=s->stacksize){ s->base=(int*)realloc(s->base,(s->stacksi ze + STACKINCREMENT )*sizeof(int));if(!(s->base)) exit(1);s->top=s->base+s->stacksize;s->stacksize+=STACKINCREMENT;}*s->top++=e;return 0;}//插入新的元素e为新的栈顶元素int stackempty (sqstack *s) {if(s->top==s->base) return 1; else return 0;}//若栈s 为空栈，则返回1，否则返回0int pop (sqstack *s,int *e){if(s->top==s->base)return 1;*e=*--s->top;return 0;}//若栈不为空，则删除s的栈顶元素，用e返回其值，返回0K,否则返回ERRORvoid conversion (int n){ sqstack s;int e;initstack(&s);printf(" 请输入一个十进制数：\n"); scanf("%d",&n);while (n){push(&s,n%8);n=n/8;}printf("\n");printf(" 该数的八进制数为：\n");while(!stackempty(&s)){pop(&s,&e);printf("%d",e);prin tf("\n");｝〃对于输入的任意一个非负十进制整数，打印出与其等值的八进制数int mai n(){int n;//sqstack *s; // in itstack(s); con versi on (n); return 0;}//主函数运行程序：T F:\Debu g\Debug\w.ex c'程序解析：1.首先是将程序的开头写好，要有#include<stdlib.h>，然后定义STACK_INIT_SIZE 为100，STACKINCREMENT 为10。

十进制转八进制c语言代码
以下是将十进制数转换为八进制数的C语言代码：
```c
#include <stdio.h>
int main() {
int decimalNum, octNum = 0, i = 1;
printf("Enter a decimal number: ");
scanf("%d", &decimalNum);
while (decimalNum != 0) {
octNum += (decimalNum % 8) * i;
decimalNum /= 8;
i *= 10;
}
printf("The octal representation of the decimal number is: %d", octNum);
return 0;
}
```
代码解释：
1. 先声明变量 `decimalNum` 表示要转换的十进制数，变量
`octNum` 表示转换后的八进制数，变量 `i` 表示八进制数每一位的权重，初始为1。

2. 通过 `printf` 函数和 `scanf` 函数分别实现读入要转换的十进制数和输出转换后的八进制数。

3. 使用 `while` 循环求出八进制数各位的值，并不断将结果累加到变量 `octNum` 中。

具体做法是：先用 `%` 取出十进制数除以8的余数，再将余数乘以权重，将乘积累加到变量
`octNum` 中；然后将十进制数除以8，更新 `decimalNum` 的值；最后将权重乘以10，更新 `i` 的值。

4. 循环结束后，输出转换后的八进制数。