思路分析：
 
我们在进行十进制转化为其他进制的时候用的就是所谓的短除法
 如下图：
 
 
#include"iostream"
using namespace std;
int main()
{
    int a[100];//定义一个数组来存最后的八进制数
    int n,i=0;
    cin>>n;
    //用短除法实现进制转化
    while(1)
    {
        if(n<8)//如果"n"小于8，则可以直接赋值后跳出循环 
        {
            a[i]=n;
            break;
        }
        else
        {
            a[i]=n/8;//这一步便是所谓的短除法
            
        }
        n%=8;//将"n"余8的值重新给"n"赋值
        i+=1;
    }
    //循环输出数组的数字，结果便是转化后的八进制数
    for(int j=0;j<=i;j++)
    cout<<a[j];
    return 0;
}
 
在下面贴一个C语言版本：
 
#include"stdio.h"

int main()
{
    int a[101];
    int i=0,n;
    scanf("%d",&n);
    while(1)
    {
        if(n<8)
        {
            a[i]=n;
            break;
        }
        else
        {
            a[i]=n/8;
            
        }
        n%=8;
        i+=1;
    }
    for(int j=0;j<=i;j++)
    printf("%d",a[j]);
    return 0;
}
 
希望该文章对你有所帮助，如果有不同看法或是建议的话可以在评论区提出，谢谢。

 
将十进制转化为八进制的算法
 
Converting a number from Decimal to Octal is almost similar to converting Decimal into Binary, although just one difference is that unlike Binary conversion, here in an integral part, we successively divide the number by 8 until the quotient is 0 (the last remainder becomes the MSB). The remainders read from bottom to top give the equivalent octal integer number. and in the fractional part, we multiply it by 8 till the fractional part of the product is 0. The first integer in the product term gives the MSB, thus the integers read from top to bottom gives the equivalent octal fraction.
 
 
 将数字从十进制转换为八进制几乎类似于将十进制转换为二进制 ，尽管唯一的区别是与二进制转换不同，在整数部分中，我们将数字连续除以8直到商为0(最后的余数变为MSB)。 从下到上读取的余数给出等效的八进制整数。 在小数部分中，我们将其乘以8，直到乘积的小数部分为0。乘积项中的第一个整数给出MSB，因此从上到下读取的整数给出等效的八进制小数。 
 
 
Same as in decimal to binary conversion, to convert a mixed decimal number into octal, we first separate the integral and the fractional part and then convert them into octal individually, after converting both to octal separately, we combine them back together to get the desired result.
 
 
 与十进制转换为二进制一样 ， 要将混合的十进制数转换为八进制 ，我们首先将整数和小数部分分离，然后将它们分别转换为八进制，分别将其转换为八进制后，将它们组合在一起即可得到所需的值结果。 
 
 
Example 1:
 
 
 范例1： 
 
 
Convert (73.625)10 to ( ? )8
 
 
 将(73.625) 10转换为(？) 8 
 
 
Solution:
 
 
 解： 
 
 
Firstly, we will separate the integral part (73)8 and the fractional part (0.625)8. Now, we will convert each of them to octal individually.
 
 
 首先，我们将积分部分(73) 8和小数部分(0.625) 8分开。 现在，我们将它们分别转换为八进制。 
 
 
Integral Part
 
 
 整体部分 
 
 
Divisor
Quotient
Remainder
8
73
8
9
1 LSB
8
1
1
8
0
1 MSB
 
 
 除数 
 商 
 余 
 8 
 73 
 8 
 9 
 1 LSB 
 8 
 1个 
 1个 
 8 
 0 
 1个MSB 
 
 
All the remainders read from top to bottom, where topmost is the LSB and bottom one is the MSB.
 
 
 所有其余部分从上至下读取，其中最高的是LSB，最低的是MSB。 
 
 
Therefore, (73)10 = (111)8
 
 
 因此，(73) 10 =(111) 8 
 
 
Fractional Part
 
 
 小数部分 
 
 
    0.625 * 8 = 5.000


 
The integer part of the product term read from top to bottom forms the equivalent octal number i.e., (.625)10 = (0.5)8
 
 
 从上到下读取的乘积项的整数部分形成等效的八进制数，即(.625) 10 =(0.5) 8 
 
 
After converting both integral part and fractional part individually into octal, now we combine both to get our desired result i.e., (73.625)10 = (111.5)8
 
 
 将整数部分和小数部分分别转换为八进制后，现在我们将两者合并以获得所需的结果，即(73.625) 10 =(111.5) 8 
 
 
Example 2:
 
 
 范例2： 
 
 
Convert (965.198)10 to ( ? )8
 
 
 将(965.198) 10转换为(？) 8 
 
 
Solution:
 
 
 解： 
 
 
Integral Part
 
 
 整体部分 
 
 
Divisor
Quotient
Remainder
8
965
8
120
5 LSB
8
15
0
8
1
7
8
0
1 MSB
 
 
 除数 
 商 
 余 
 8 
 965 
 8 
 120 
 5 LSB 
 8 
 15 
 0 
 8 
 1个 
 7 
 8 
 0 
 1个MSB 
 
 
The remainders read from bottom to top gives the equivalent octal number i.e., (965)10 = (1705)8.
 
 
 从下到上读取的余数给出等效的八进制数，即(965) 10 =(1705) 8 。 
 
 
Fractional Part
 
 
 小数部分 
 
 
    0.198 * 8 = 1.584	MSB
    0.584 * 8 = 4.672
    0.672 * 8 = 5.376
    0.376 * 8 = 3.008
    0.008 * 8 = 0.064
    0.064 * 8 = 0.512	LSB


 
The integer part of the product term read from top to bottom forms the equivalent octal number i.e., (0.198)10 = (0.145300)8.
 
 
 从上到下读取的乘积项的整数部分形成等效的八进制数，即(0.198) 10 =(0.145300) 8 。 
 
 
After converting both integral part and fractional part individually into octal, now we combine both to get our desired result i.e., (965.198)10 = (1705.145300)8
 
 
 将整数部分和小数部分分别转换为八进制后，现在我们将两者合并以获得所需的结果，即(965.198) 10 =(1705.145300) 8 
 
 
Example 3:
 
 
 范例3： 
 
 
Convert (296.225)10 to ( ? )8
 
 
 将(296.225) 10转换为(？) 8 
 
 
Solution:
 
 
 解： 
 
 
Integral Part
 
 
 整体部分 
 
 
Divisor
Quotient
Remainder
8
296
8
37
0 LSB
8
4
5
8
0
4 MSB
 
 
 除数 
 商 
 余 
 8 
 296 
 8 
 37 
 0 LSB 
 8 
 4 
 5 
 8 
 0 
 4个MSB 
 
 
The remainders read from bottom to top gives the equivalent octal number i.e., (296)10 = (450)8.
 
 
 从下到上读取的余数给出等效的八进制数，即(296) 10 =(450) 8 。 
 
 
Fractional Part
 
 
 小数部分 
 
 
    0.225 * 8 = 1.80    MSB
    0.80  * 8 = 0.64
    0.64  * 8 = 5.12
    0.12  * 8 = 0.96
    0.96  * 8 = 7.68     LSB


 
The integer part of the product term read from top to bottom forms the equivalent octal number i.e., (0.198)10 = (0.10507)8.
 
 
 从上到下读取的乘积项的整数部分形成等效的八进制数，即(0.198) 10 =(0.10507) 8 。 
 
 
After converting both integral part and fractional part individually into octal, now we combine both to get our desired result i.e., (296.225)10 = (450.10507)8.
 
 
 在将整数部分和小数部分分别转换为八进制之后，现在我们将两者合并以获得所需的结果，即(296.225) 10 =(450.10507) 8 。 
 
 

  
翻译自: https://www.includehelp.com/basics/conversion-of-decimal-number-system-into-octal-number-system.aspx
 
 
将十进制转化为八进制的算法

import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 

 

 /**

  * 程序中遇到3个问题：

  * 第一个问题：

  * 1.Java控制台输入的方法：一般常用的是两种（Scanner）方法和BufferedReader防范，具体用法

  *   可查阅相关资料

  * 2.判断输入是否结束：使用方法BufferedReader类中的readLine（）方法,判断是否为空

  * 3.字符串类型转换成整数类型的方法：Integer.parseInt(String).具体使用可查阅资料

  * @author Administrator

  *

  */

 public class tenToeight {

 

 

 
public static void main(String[] args) throws NumberFormatException,IOException {

 
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

 
//
 System.out.print("请输入测试用例：");

 
String str = null;

 


 
while((str = input.readLine()) != null) {

 
int s = 0;

 
int a = 0;

 
int b = 0;

 
int i = 0;

 


 
a = Integer.parseInt(str);

 


 
while(a != 0) {

 
b=a%8;

 
s = s+b*(int)Math.pow(10, i);//10的阶乘运算

 
i++;

 
a = a/8;

 
}

 
System.out.println(s);

 
}

 


 
}

 


 }

 
C语言实验（十一）
 
实验内容
实验一：勒让德多项式程序
实验二：进制转换
实验三：计算阶乘
     
总结反思
   
  
 

 
实验内容
 
实验一：勒让德多项式程序
 
用递归法求n阶勒让德多项式的值。
 
 实验步骤
 1、首先，观察该多项式需要有n及x两个值才可以求解它的值。所以需要有两个输入。
 
2、然后，将该多项式的求值方法封装成一个函数，在main()函数中调用这个函数。把结果输出。
 
3、在勒让德多项式求值的函数中，需要将x,n作为参数传入。根据题示的式子，判断n的取值，使用多重选择语句设置不同的计算方法。在n不等于0或1时，有递归。
 
实验代码
 
#include <stdio.h>
#include <stdlib.h>
int legendre(int n,int x);

int main()
{
    int n,x;
    float s;
    printf("Input n:");
    scanf("%d",&n);
    printf("\n");
    printf("Input x:");
    scanf("%d",&x);
    s = legendre(n,x);
    printf("勒让德多项式的值为%.2f",s);
    return 0;
}

int legendre(int n,int x)
{
    if (n == 0)
        return 1;
    else if (n == 1)
        return x;
    else
        return ((2*n-1)*x-legendre(n-1,x)-(n-1)*legendre(n-2,x))/n;
}
 
运行结果
 

 
 
 
实验二：进制转换
 
编写一个函数将输入的十进制转化为8进制。
 
实验步骤
 
1、首先，了解十进制转换为八进制的基本方法“除8取余”。输入一个十进制的数字，通过一个转换的函数转化为十进制。将“除8取余”方法封装成一个函数，在main()函数中调用这个函数。把结果输出。
 
2、在十进制转化成八进制的过程中，同样使用了递归的方法。“除8取余”的思想，将每一次的上次取余的结果乘以10得到上一位，加上本次模运算的结果即为最终结果。
 
实验代码
 
#include <stdio.h>
#include <stdlib.h>
int transform(int n);

int main()
{
    int n,t;
    printf("十进制：");
    scanf("%d",&n);
    printf("八进制：%d",transform(n));
    return 0;
}

int transform(int n)
{
    if (n < 8)
    {
        return n;
    }
    else
    {
        return (transform(n / 8) * 10 +n % 8);
    }
    return 0;
}
 
运行结果
 
 
 
实验三：计算阶乘
 
编写一个函数将计算10以下的阶乘。
 
实验步骤
 1、计算10以下的阶乘。最重要的是阶乘的算法实现，前面的实验也用到过。
 
2、阶乘的实质就是不断与之前的数相乘，n=1为判断结束条件，实现起来比较容易。加上特殊的条件0的阶乘是1.
 
3、完成阶乘函数之后，在main()函数中计算10以下的阶乘即可。
 
实验代码
 
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i;
    for(i=0;i<10;i++)
        printf("%d的阶乘结果为%d\n",i,fac(i));
    return 0;
}

int fac(int n)
{
    if(n == 1||n == 0)
        return 1;
    else
        return n*fac(n-1);
}
 
运行结果
 
 
总结反思
 
这次实验主要练习了函数的使用以及递归的思想。练习了三个比较简单的实验：求解勒让德多项式的值、十进制整数转换为八进制及求10以内的阶乘。
 
递归的思想在高中数学中就已经学习到了。求最大公约数的辗转相除法、阶乘的方法、斐波那契数列及十进制转换为二进制的“除2取余”这些方法都有一种递归（迭代）的思想在。在编程的过程中，递归的思想通过函数自身调用实现。这个方法可以解决很多使用常规思路难以解决的问题。函数结合递归使用是一种很方便的编程技巧。
 
判断能否使用递归需要判断两个条件：1、存在限制条件，当满足这个条件时，递归不再继续。2、每次递归调用之后越来越接近这个限制条件。