C语言经典算法实例7：完数

一、问题描述

1.1、什么是完数

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
如果一个数恰好等于它的真因子之和，则称该数为“完全数”。
第一个完全数是6，第二个完全数是28，第三个完全数是496，后面的完全数还有8128、33550336等等。

1.2、完数定义

如果一个数恰好等于它的真因子之和，则称该数为“完全数” 。各个小于它的约数（真约数,列出某数的约数，去掉该数本身，剩下的就是它的真约数）的和等于它本身的自然数叫做完全数（Perfect number），又称完美数或完备数。
例如：
第一个完全数是6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。
第二个完全数是28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
第三个完全数是496，有约数1、2、4、8、16、31、62、124、248、496，除去其本身496外，其余9个数相加，1+2+4+8+16+31+62+124+248=496。
后面的完全数还有8128、33550336等等。

1.3、本文的问题描述

本文完数
问题的描述
如下几点所示

1. 输出 1-10000 以内所有完数。
2. 完数所有的真因子（即除了自身以外的约数）的和恰好等于它本身。
3. 六是一个完全数，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。

二、算法实例编译环境

本文C语言经典算法实例的编译环境，使用的是集成开发环境：Visual Studio 2019

Visual Studio 2019官网链接如下

Visual Studio 2019官网链接

Visual Studio 2019集成的开发环境的特点有

1. Visual Studio 2019默认安装Live Share代码协作服务。
2. 帮助用户快速编写代码的新欢迎窗口、改进搜索功能、总体性能改进。
3. Visual Studio IntelliCode AI帮助。
4. 更好的Python虚拟和Conda支持。
5. 以及对包括WinForms和WPF在内的.NET Core 3.0项目支持等

三、算法实例实现过程

3.1、包含头文件

包含头文件 代码如下所示

#pragma once

// 包含头文件
#include 
#include 

1
2
3
4
5
6

• 将要用到的Ｃ语言头文件包含近年来。

3.2、声明变量

声明变量 代码如下所示

    // 声明变量
    int i, j, k; 
1
2

• 声明了变量 i, j, k 。

3.3、使用for循环来求1-10000的完数

使用for循环来求1-10000的完数 代码如下所示

	/// 

    /// 使用for循环来求1-10000的完数
    /// 
    /// 无
    for (i = 1; i < 10000; i++)
    {
        
    }
1
2
3
4
5
6
7
8

• 使用for循环来求1-10000的完数。
• 求1-10000的完数的具体实现如下几个点所示。

3.4、变量赋值

变量赋值 代码如下所示

 	// 变量赋值, 保证每次循环时sum的初值为0
    int sum = 0;
1
2

• 变量赋值, 保证每次循环时sum的初值为0。
• 变量赋值进行完数的求解。
  

3.5、判断j是否为i的因子

判断j是否为i的因子，代码如下所示

		for (j = 1; j < i; j++)
        {
            /// 

            /// // 判断j是否为i的因子
            /// 
            /// 
            if (i % j == 0)    
            {
                sum += j;
            }
        }
1
2
3
4
5
6
7
8
9
10
11

• 判断j是否为i的因子。

3.6、判断因子数的和是否和原数相等

判断因子数是否和原数相等 代码如下所示

		/// 

        /// 判断因子数的和是否和原数相等
        /// 
        /// 
        if (sum == i)
        {
            printf("%d 的因数是： ", i);

            for (k = 1; k < i; k++)
            {
                if (i % k == 0)
                {
                    printf("%d ", k);
                }
            }
            printf("\n");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 判断因子数的和是否和原数相等。
• 如果因子数的和与原数相等，则这个数是完全数。
• 如果因子数的和与原数不相等，则这个数不是完全数。

按F5进行编译，调试结果如下所示。

6 的因数是： 1 2 3
28 的因数是： 1 2 4 7 14
496 的因数是： 1 2 4 8 16 31 62 124 248
8128 的因数是： 1 2 4 8 16 32 64 127 254 508 1016 2032 4064

请按任意键继续. . .

1
2
3
4
5
6
7

• 可以看到1-10000内的完全数总共有四个。
• 这几个完数分别是
• 6 的因数是： 1 2 3
• 28 的因数是： 1 2 4 7 14
• 496 的因数是： 1 2 4 8 16 31 62 124 248
• 8128 的因数是： 1 2 4 8 16 32 64 127 254 508 1016 2032 4064

3.7、对求1-10000内的完数功能进行函数模块化

• 对求1-10000内的完数采用函数编写的方式。

对求1-10000内的完数功能进行函数模块化 代码如下所示。

3.7.1、对求1-10000内的完数功能进行函数模块化的函数声明

/// 

/// 求完数的函数声明
/// 
void numberPerfect();
1
2
3
4

• 声明了求完数的函数。

3.7.2、对求1-10000内的完数功能进行函数模块化的函数定义

对求1-10000内的完数功能进行函数模块化的函数定义 代码如下所示。

/// 

/// 求完数的函数定义
/// 
void numberPerfect()
{
    // 声明变量
    int i, j, k;

    /// 

    /// 使用for循环来求1-10000的完数
    /// 
    /// 无
    for (i = 1; i < 10000; i++)
    {
        // 变量赋值, 保证每次循环时sum的初值为0
        int sum = 0;

        for (j = 1; j < i; j++)
        {
            /// 

            /// // 判断j是否为i的因子
            /// 
            /// 
            if (i % j == 0)
            {
                sum += j;
            }
        }

        /// 

        /// 判断因子数的和是否和原数相等
        /// 
        /// 
        if (sum == i)
        {
            printf("%d 的因数是： ", i);

            for (k = 1; k < i; k++)
            {
                if (i % k == 0)
                {
                    printf("%d ", k);
                }
            }
            printf("\n");
        }
    }

    printf("\n");
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

• 将上面几点的功能加入到函数体即可，如上面的函数定义所示。
• 实现了函数的功能：求1-10000内的完数。
• 使用for循环的方式。
• 求1-10000之内的完数。
• 先求自身的因子数。
• 在求因子数的和是否与自身相等。

3.7.3、主函数中调用求1-10000内的完数功能的函数numberPerfect

主函数中调用求1-10000内的完数功能的函数numberPerfect 代码如下所示

 	// 调用求完数的函数
    numberPerfect();
1
2

按F5进行编译，调试结果如下所示。

四、经典算法实例程序 完整代码

经典算法实例程序完整代码如下所示

4.1、main.h文件

#pragma once

// 包含头文件
#include 
#include 


/// 

/// 求完数的函数声明
/// 
void numberPerfect();


1
2
3
4
5
6
7
8
9
10
11
12
13

4.2、main.c文件

#define _CRT_SECURE_NO_WARNINGS

#include "Main.h"

/// 

/// 主函数
/// 
/// 返回0
int main()
{
    system("color 3E");

    // 调用求完数的函数
    numberPerfect();

    system("pause");
    return 0;
}

/// 

/// 求完数的函数定义
/// 
void numberPerfect()
{
    // 声明变量
    int i, j, k;

    /// 

    /// 使用for循环来求1-10000的完数
    /// 
    /// 无
    for (i = 1; i < 10000; i++)
    {
        // 变量赋值, 保证每次循环时sum的初值为0
        int sum = 0;

        for (j = 1; j < i; j++)
        {
            /// 

            /// // 判断j是否为i的因子
            /// 
            /// 
            if (i % j == 0)
            {
                sum += j;
            }
        }

        /// 

        /// 判断因子数的和是否和原数相等
        /// 
        /// 
        if (sum == i)
        {
            printf("%d 的因数是： ", i);

            for (k = 1; k < i; k++)
            {
                if (i % k == 0)
                {
                    printf("%d ", k);
                }
            }
            printf("\n");
        }
    }

    printf("\n");
}





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

五、总结

本文的C语言经典算法实例：完数，要实现的目标如下

1. 输出 1-10000 以内所有完数。
2. 完数所有的真因子（即除了自身以外的约数）的和恰好等于它本身。
3. 六是一个完全数，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。

文到这里就结束啦。
希望本文的C语言经典算法实例：完数。
能激发你对C语言以及算法学习的热爱。

• 你的支持是对我最大的鼓励。