OverIQ 中文系列教程（八）

企业开发 2024-11-06 20:18:52 阅读次数: 0

原文：OverIQ Tutorials

协议：CC BY-NC-SA 4.0

C 程序：寻找数字的乘积

原文：https://overiq.com/c-examples/c-program-to-find-the-product-of-digits-of-a-number/

最后更新于 2020 年 9 月 23 日

下面是一个求数字的乘积的 C 程序:

/**************************************************
 Program to find the product of digits of a number
 * 
 * Enter a number: 456
 * 120
 **************************************************/

#include<stdio.h> // include stdio.h library

int main(void)
{
    
           
    int num, rem, prod = 1;

    printf("Enter a number: ");
    scanf("%d", &num);

    while(num != 0)
    {
    
    
        rem = num % 10; // get the right-most digit
        prod *= rem; // calculate product of digits
        num /=  10;  // remove the right-most digit
    }

    printf("%d", prod);

    return 0; // return 0 to operating system
}

现在试试

预期输出:

第一次运行:

Enter a number: 234
24

第二次运行:

Enter a number: 444
64

它是如何工作的

下表演示了 while 循环每次迭代时发生的情况，假设num = 234。

循环 rem prod num
第一次迭代后 rem=234%10=4 prod=1*4=4 num=234/10=23
第二次迭代后 rem=23%10=3 prod=4*3=12 num=23/10=2
第三次迭代后 rem=2%10=2 prod=12*2=24 num=2/10=0

推荐阅读:

扫描二维码关注公众号，回复： 17518013 查看本文章

C 程序：计算排列组合

原文：https://overiq.com/c-examples/c-program-to-calculate-permutation-and-combination/

最后更新于 2020 年 9 月 23 日

下面是一个计算排列组合的 C 程序:

/**************************************************
 Program to calculate Permutation and Combination
 * 
 * Enter n: 10
 * Enter r: 4
 * Permutation = 5040
 * Combination = 210
 ***************************************************/

#include<stdio.h> // include stdio.h library
long permutation(int n, int r);
long combination(int n, int r);
long factorial(int num);

int main(void)
{
    
        
    int n, r;

    printf("Enter n: ");
    scanf("%d", &n);

    printf("Enter r: ");
    scanf("%d", &r);

    printf("Permutation = %ld\n", permutation(n, r));    
    printf("Combination = %ld", combination(n, r));

    return 0; // return 0 to operating system
}

long permutation(int n, int r)
{
    
    
    return factorial(n) / factorial(n-r);
}

long combination(int n, int r)
{
    
    
    return permutation(n, r) / factorial(r);
}

long factorial(int num)
{
    
    
    long long fact = 1;

    while(num > 0)
    {
    
    
        fact *= num;
        num--;
    }

    return fact;
}

现在试试

**预期输出:**第一次运行:

Enter n: 5
Enter r: 3
Permutation = 60
Combination = 10

第二次运行:

Enter n: 5
Enter r: 0
Permutation = 1
Combination = 1

它是如何工作的

这里没什么神奇的，我们只是用公式来计算排列组合。

一次拍摄的不同物体的排列由下式给出:

\ begin { collect * }
NPr = \ frac { n！}{(n-r)！}
\ end { collect * }

一次拍摄的不同物体的组合由下式给出:

\ begin { collect * }
NCr = \ frac { n！}{r！(n-r)！}
\ end { collect * }

推荐阅读:

C 程序：求两个数的 LCM 和 HCF

原文：https://overiq.com/c-examples/c-program-to-find-lcm-and-hcf-of-two-numbers/

最后更新于 2020 年 9 月 23 日

什么是 LCM 和 HCF？

两个数的最小公倍数是能被这两个数整除的最小数:例如:4，10 的最小公倍数是 20，4，3 的最小公倍数是 12。

两个数的最大公因数，也称为最大公约数，是能被这两个数整除的最高数。比如:HCF 210，45 是 20，HCF 6，18 是 6。

欧几里德算法寻找人类合作框架

以下是使用欧几里德算法计算 HCF 的步骤:

  1. 输入两个正整数a和b。
  2. 如果a < b，则交换a和b的值。
  3. 将a除以b得到余数。如果余数为0，则b为 HCF，否则转到步骤 4。
  4. 将b的值赋给a，将余数赋给b，然后再次进入步骤 3。

一旦我们计算了 HCF，就可以使用以下关系式轻松计算 LCM:

\ begin { collect * }
LCM(A，B) = \frac{A*B}{HCF(A，B)}
\ end { collect * }

下面是一个计算两个数的 LCM 和 HCF 的 C 程序:

/***********************************************
 * C Program to find LCM and HCF of two numbers
************************************************/

#include<stdio.h> // include stdio.h

int main() 
{
    
    
    int a, b;

    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);

    printf("HCF = %d\n", calculate_hcf(a, b));
    printf("LCM = %d\n", calculate_lcm(a, b));

    return 0;
}

int calculate_hcf(int smaller, int larger)
{
    
    
    //  Finding HCF using Euclid's Algorithm
    //  https://en.wikipedia.org/wiki/Euclidean_algorithm

    int rem, tmp;

    if(larger < smaller)
    {
    
    
        tmp = larger;
        larger = smaller;
        smaller = tmp;
    }

    while(1)
    {
    
    
        rem = larger % smaller;
        if(rem == 0)
        {
    
    
            return smaller;
        }

        larger = smaller;
        smaller = rem;        
    }

}

int calculate_lcm(int a, int b)
{
    
    
    // lcm = product of two numbers / hcf
    return (a * b) / calculate_hcf(a, b);
}

现在试试

**预期输出:**第一次运行:

Enter two numbers: 3 4
HCF = 1
LCM = 12

第二次运行:

Enter two numbers: 210 45
HCF = 15
LCM = 630

工作原理

下表演示了在calculate_hcf()函数中 while 循环的每次迭代中发生的情况，假设larger = 210和smaller = 45:

循环 rem sum n
第一次迭代后 rem = larger % smaller = 210%45 = 30 larger = 45 smaller = 30
第二次迭代后 rem = 45%30 = 15 larger = 30 smaller = 15
第三次迭代后 rem = 30%15 = 0 larger = 15 smaller = 0

相关节目:

C 程序：寻找数组中最大和最小元素

原文：https://overiq.com/c-examples/c-program-to-find-the-maximum-and-minimum-element-in-the-array/

最后更新于 2020 年 9 月 23 日

下面是一个寻找数组中最大和最小元素的 C 程序:

/*********************************************************
 Program to find maximum and minimum element in the array 
 *********************************************************/

#include<stdio.h> // include stdio.h library
#define MAX 5

int main(void)
{
    
        
    int arr[MAX] = {
    
    50, -100, 20, 245, 0},
            min, max;

    min = max = arr[0]; // assign the first element to max and min

    for(int i = 0; i < MAX; i++)
    {
    
    
        if(arr[i] < min)
        {
    
    
            min = arr[i];
        }

        if(arr[i] > max)
        {
    
    
            max = arr[i];
        }
    }        

    printf("Min = %d\n", min);
    printf("Max = %d", max);

    return 0; // return 0 to operating system
}

现在试试

预期输出:

Min = -100
Max = 245

它是如何工作的

我们使用 for 循环迭代数组中的元素。如果数组中的当前元素小于min，我们将该值赋给min。同样，如果当前元素大于max，我们将该值赋给max。当循环终止时，我们打印min和max变量的值:

下表演示了 for 循环每次迭代时发生的情况:

循环 Condition 1 Condition 2 min max
one arr[0]<min=>50<50=>0 arr[0]>max=>50>50=>0 min=50 max=50
Two arr[1]<min=>-100<50=>1 arr[1]>max=>-100>50=>0 min=-100 max=50
three arr[2]<min=>20<-100=>0 arr[2]>max=>20>50=>0 min=-100 max=50
four arr[3]<min=>245<-100=>0 arr[2]>max=>245>50=>1 min=-100 max=245
five arr[4]<min=>0<-100=>0 arr[4]>max=>0>50=>0 min=-100 max=245

C 程序：反转数组元素

原文：https://overiq.com/c-examples/c-program-to-reverse-the-elements-of-an-array/

最后更新于 2020 年 9 月 23 日

下面是一个反转数组元素的 C 程序:

/**********************************************
 Program to reverse the elements of an array 
 **********************************************/

#include<stdio.h> // include stdio.h library
#define MAX 5

int main(void)
{
    
        
    int arr[MAX] = {
    
    10, 20, 30, 40, 50},
            i, j, tmp;

    i = 0;
    j = MAX - 1; // assign the last valid index 

    while(i < j)
    {
    
    
        // swap the elements
        tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp; 

        i++;  
        j--;
    }

    //  print the reversed array
    for(int k = 0; k < MAX; k++)
    {
    
    
        printf("%d ", arr[k]);
    }

    return 0; // return 0 to operating system
}

现在试试

预期输出:

50 40 30 20 10

它是如何工作的

为了反转数组的元素，我们用最后一个元素交换数组的第一个元素，用第二个元素交换最后一个元素，以此类推。我们不断重复这个过程，直到到达阵列的一半。

下图展示了运行中的流程:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

C 程序：对数组元素求和

原文：https://overiq.com/c-examples/c-program-to-sum-the-elements-of-an-array/

最后更新于 2020 年 9 月 23 日

下面是一个求数组元素之和的 C 程序:

/**********************************************
 Program to sum the elements of an array
 **********************************************/

#include<stdio.h> // include stdio.h library
#define MAX 5

int main(void)
{
    
        
    int arr[MAX];
    int sum = 0;  // accumulate sum in this variable

    // read input
    for(int i = 0; i < MAX; i++)
    {
    
    
        printf("Enter a[%d]: ", i);
        scanf("%d", &arr[i]);
    }

    // loop from index 0 to MAX
    for(int i = 0; i < MAX; i++)
    {
    
    
        sum += arr[i];  // add the current element to sum
    }

    printf("\nSum = %d", sum);

    return 0; // return 0 to operating system
}

现在试试

预期输出:

Enter a[0]: 1
Enter a[1]: 2
Enter a[2]: 3
Enter a[3]: 4
Enter a[4]: 5

Sum = 15

它是如何工作的

  1. 我们从声明变量arr和sum开始，分别存储数组和和。注意变量sum被初始化为0。
  2. 在第 14-18 行，我们有一个循环，提示用户向数组中输入元素。
  3. 在第 21-24 行，我们有第二个 for 循环来求和数组的元素。
  4. 在第 25 行，我们使用 print 语句打印总和。

推荐阅读:

C 程序：计算数组中奇数和偶数元素个数

原文：https://overiq.com/c-examples/c-program-to-find-the-count-of-even-and-odd-elements-in-the-array/

最后更新于 2020 年 9 月 23 日

下面是一个计算数组中偶数和奇数元素的 C 程序:

/***************************************************************
 Program to find the count of even or odd elements in the array
 ***************************************************************/

#include<stdio.h> // include stdio.h library
#define MAX 5

int main(void)
{
    
        
    int arr[MAX] = {
    
    1, 5, 9, 14, 200};
    int even_count = 0, odd_count = 0;   // variables to store even or odd count

    // iterate over the arrays
    for(int i = 0; i < MAX; i++)
    {
    
    
        // check for even number
        if(arr[i] % 2 == 0)
        {
    
    
            even_count++;
        }

        else
        {
    
    
            odd_count++;
        }
    }

    printf("Even elements = %d\n", even_count);
    printf("Odd elements = %d", odd_count);

    return 0; // return 0 to operating system
}

现在试试

预期输出:

Even elements = 2
Odd elements = 3

它是如何工作的

  • 在第 10 行，我们声明并初始化一个名为arr的数组。
  • 在第 11 行，我们声明并初始化变量even_count和odd_count，分别存储偶数和奇数元素的计数。
  • 在第 14-27 行，我们让 for 循环迭代数组中的项。
  • 在第 17 行，我们有一个 if 语句来检查偶数。如果条件评估为真，我们将even_count增加 1。否则，元素是奇数，我们将odd_count增加 1。当数组中的元素用完时，for 循环终止。
  • 在第 28 行和第 29 行，我们使用打印语句打印even_count和odd_count的值。

推荐阅读:

C 程序：相加两个矩阵

原文：https://overiq.com/c-examples/c-program-to-add-two-matrices/

最后更新于 2020 年 9 月 23 日

下面是一个 C 程序，它要求用户输入两个矩阵，然后将它们相加。

/******************************************
* Program to add two add matrices
******************************************/

#include<stdio.h> // include stdio.h
#define ROW 2
#define COL 3

int main()
{
    
    
    int i, j, arr1[ROW][COL], arr2[ROW][COL];

    printf("Enter first matrix: \n");

    for(i = 0; i < ROW; i++)
    {
    
    
        for(j = 0; j < COL; j++)
        {
    
    
            scanf("%d", &arr1[i][j]);
        }        
    }

    printf("\nEnter second matrix: \n");

    for(i = 0; i < ROW; i++)
    {
    
    
        for(j = 0; j < COL; j++)
        {
    
             
            scanf("%d", &arr2[i][j]);
        }                
    }

    printf("\narr1 + arr2 = \n");

    // add two matrices
    for(i = 0; i < ROW; i++)
    {
    
    
        for(j = 0; j < COL; j++)
        {
    
    
            printf("%5d ", arr1[i][j] + arr2[i][j]);            
        }        
        printf("\n");
    }       

    // signal to operating system everything works fine
    return 0;
}

现在试试

预期输出:

Enter first matrix: 
1 2 3
4 5 6

Enter second matrix: 
2 4 6
8 10 12

arr1 + arr2 = 
    3     6     9 
   12    15    18

它是如何工作的

要加或减矩阵，我们只需分别加或减每个矩阵中相应的条目。

[
\左(\ begin { array } { cc } A _ { 11 }&A _ { 12 } \ \ A _ { 21 }&A _ { 22 } \ end { array } \右)+\左(\ begin { array } { cc } B _ { 11 }&B _ { 12 } \ \ B _ { 21 }&B _ { 22 } \ end { array } \右)= \左(\ begin array { cc } A _ { 11 }

请注意，只有当两个矩阵大小相同时，矩阵加法或减法才是可能的。

以下是上述程序的工作原理:

  • 第 15-22 行的第一个 for 循环要求用户输入第一个矩阵。
  • 第 26-33 行的第二个 for 循环要求用户输入第二个矩阵。
  • 第三个 for 循环(第 38-45 行)通过在每个矩阵中添加相应的条目来显示结果矩阵。

推荐阅读:

C 程序：相乘两个矩阵

原文：https://overiq.com/c-examples/c-program-to-multiply-two-matrices/

最后更新于 2020 年 9 月 23 日

下面是一个 C 程序，用来相乘两个矩阵:

/******************************************
 Program to multiply two matrices
******************************************/

#include<stdio.h> // include stdio.h
#define ROW1 2
#define COL1 2
#define ROW2 COL1
#define COL2 3

int main()
{
    
    
    int i, j, arr1[ROW1][COL1],
              arr2[ROW2][COL2],
              arr3[ROW1][COL2];

    printf("Enter first matrix (%d x %d): \n", ROW1, COL1);

    // input first matrix
    for(i = 0; i < ROW1; i++)
    {
    
    
        for(j = 0; j < COL1; j++)
        {
    
                
            scanf("%d", &arr1[i][j]);
        }                
    }

    printf("\nEnter second matrix (%d x %d): \n", ROW2, COL2);

    // input second matrix
    for(i = 0; i < ROW2; i++)
    {
    
    
        for(j = 0; j < COL2; j++)
        {
    
                
            scanf("%d", &arr2[i][j]);
        }                
    }

    printf("\narr1 * arr2 = ");        

    // multiply two matrices
    for(i = 0; i < ROW1; i++)
    {
    
    
        for(j = 0; j < COL2; j++)
        {
    
    
            arr3[i][j] = 0;

            for(int k = 0; k < COL1; k++)
            {
    
    
                arr3[i][j] += arr1[i][k] * arr2[k][j];            
            }                                    
        }                

        printf("\n");
    }       

    // print the result
    for(i = 0; i < ROW2; i++)
    {
    
    
        for(j = 0; j < COL2; j++)
        {
    
    
            printf("%d ", arr3[i][j]);
        }              
        printf("\n");
    }

    // signal to operating system everything works fine
    return 0;
}

现在试试

预期输出:

Enter first matrix (2 x 2): 
2 3
4 5

Enter second matrix (2 x 3): 
6 4 2
7 8 9

arr1 * arr2 =

33 32 31 
59 56 53

它是如何工作的

只有当第一个矩阵的列数等于第二个矩阵的行数时，两个矩阵才能相乘。

设，A为大小为2x3的矩阵，B为大小为3x2的矩阵，则，A * B由下式给出:

[
\左(\ begin { array } { CCC } a&b&c \ \ d&e&f \ end { array } \右)* \左(\ begin { array } { cc } g&h \ \ k&l \ \ o&p \ end { array } \右)= \左(\ begin { array } { cc } a * g+b * k+c * o&a * h+b * l+c * p \ \ d * g+o

一般来说，如果矩阵A的大小是m x n，B的大小是n x p，那么矩阵A * B的大小就是m x p。

以下是该程序的工作原理:

  1. 第一个 for 循环(第 20-26 行)要求用户输入第一个矩阵。
  2. 第二个 for 循环(第 31-37 行)要求用户输入第二个矩阵。
  3. 第三个 for 循环(第 42-55 行)将矩阵相乘。
  4. 第四个 for 循环(第 58-65 行)打印矩阵乘法的结果。

推荐阅读:

C 程序：寻找矩阵转置

原文：https://overiq.com/c-examples/c-program-to-find-the-transpose-of-a-matrix/

最后更新于 2020 年 9 月 23 日

下面是一个求矩阵转置的 C 程序:

/********************************************
* Program to find the transpose of a matrix
********************************************/

#include<stdio.h> // include stdio.h
#define ROW 2
#define COL 4

int main()
{
    
    
    int i, j, mat[ROW][COL], trans_mat[COL][ROW];

    printf("Enter matrix: \n");

    // input matrix
    for(i = 0; i < ROW; i++)
    {
    
    
        for(j = 0; j < COL; j++)
        {
    
                
            scanf("%d", &mat[i][j]);
        }        
    }

    /* create transpose matrix by  
     * switch entries
     */ 
    for(i = 0; i < ROW; i++)
    {
    
    
        for(j = 0; j < COL; j++)
        {
    
    
            trans_mat[j][i] = mat[i][j];
        }                
    }       

    printf("\nTranspose matrix: \n");

    // print transpose matrix
    for(i = 0; i < COL; i++)
    {
    
    
        for(j = 0; j < ROW; j++)
        {
    
    
            printf("%d ", trans_mat[i][j]);
        }        

        printf("\n");
    }

    // signal to operating system everything works fine
    return 0;
}

现在试试

预期输出:

Enter matrix: 
1 2 3 4
5 6 7 8

Transpose matrix: 
    1     5 
    2     6 
    3     7 
    4     8

它是如何工作的

设A是一个大小为m x n的矩阵，那么通过行列互换得到的矩阵称为【T2 的转置】。

矩阵的转置由(A^T\表示)。例如:

[
A = \左(\开始{ array } { cc } 1&2 \ \ 3&4 \ \ 5&6 \结束{ array } \右)
]

然后

[
a^t = \左(\开始{ array } { CCC } 1&3&5 \ \ 2&4&6 \结束{ array } \右)
]

以下是该程序的工作原理:

  1. 第一个 for 循环(第 16-22 行)要求用户输入矩阵。
  2. 第二个 for 循环(第 27-33 行)通过交换行和列来创建转置矩阵。
  3. 第三个 for 循环(第 38-46 行)打印矩阵的转置。

推荐阅读:

C 程序：使用线性搜索搜索项目

原文：https://overiq.com/c-examples/c-program-to-search-for-an-item-using-linear-search/

最后更新于 2020 年 9 月 23 日

线性搜索

在线性搜索中，我们从数组的开头开始搜索目标项。如果目标等于索引 0 处的元素，那么我们就找到了目标。否则，我们继续在数组中一个接一个地搜索目标，直到找到匹配。线性搜索有时也称为顺序搜索。

当数组的元素没有排序时，我们通常使用线性搜索。

让我们举个例子:

假设，我们有一个数组arr声明并初始化为:

int arr[] = {
    
    100, 50, 99, 44, 12};

以下是在数组中搜索值44的步骤。

  1. 在索引0处搜索44。从，44 != arr[0]开始，我们进入下一个指数。
  2. 在索引1处搜索44。从，44 != arr[1]开始，我们进入下一个指数。
  3. 在索引2处搜索44。从，44 != arr[2]开始，我们进入下一个指数。
  4. 在索引4处搜索44。从，44 == arr[2]开始，我们就找到了目标。此时，我们不需要继续下一个指数。所以，我们的搜索到此结束。

时间复杂性

现在让我们根据大 0 符号来检查线性搜索的效率。

在最坏的情况下，如果数组中有 100 个元素，那么线性搜索将需要 100 步。同样，如果数组中有 1000 万个元素，那么线性搜索将需要 1000 万步。

注:最坏情况下，我们指的是在数组末尾找到目标。

一般来说，我们可以说，在最坏的情况下，线性搜索将采取与数组中元素一样多的步骤。因此，如果数组中有N个元素，那么线性搜索将采取N步。

上述陈述可以用大 O 符号表示如下:

O(N)

这被解读为 n 的大 O。

请记住，简单来说，O(N)仅仅意味着N个元素，一个算法需要N个步骤。

线性搜索 C 程序

下面是一个使用线性搜索算法搜索目标的 C 程序:

/***************************************************
* Program to search for an item using Linear Search 
****************************************************/

#include<stdio.h> // include stdio.h
#define SIZE 10

int main()
{
    
    
    int arr[SIZE] = {
    
    100, 91, 22, 52, 71, 9, 11, 24, 2, 80}, is_found = 0;
    int target; // number to be searched

    printf("Enter element to search: ");
    scanf("%d", &target);

    // search for the target sequentially
    for(int i = 0; i < SIZE; i++)
    {
    
    
        if(target == arr[i])
        {
    
    
            // if target is found stop the search and break out
            is_found = 1;
            break;
        }
    }

    if(is_found)
    {
    
    
        printf("Item %d found.", target);
    }
    else
    {
    
    
        printf("Item %d not found.", target);
    }

    // signal to operating system everything works fine
    return 0;
}

现在试试

**预期输出:**第一次运行:

Enter element to search: 80
Item 80 found.

第二次运行:

Enter element to search: 200 
Item 200 not found.

它是如何工作的

在第 13 行，我们要求用户输入一个要搜索的数字。

第 14 行的scanf()函数从键盘读取输入，并将其存储在名为target的变量中。

在第 17-25 行，我们使用 for 循环迭代数组中的元素。如果目标等于数组中的当前元素，我们将is_found设置为1，并使用break语句退出 for 循环。否则，我们会一直寻找目标，直到到达数组的末尾。

第 27-34 行的 if-else 语句检查is_found变量的值，以确定我们是否找到了目标，并显示适当的消息。

推荐阅读:

C 程序：使用二分搜索搜索项目

原文：https://overiq.com/c-examples/c-program-to-search-for-an-item-using-binary-search/

最后更新于 2020 年 9 月 23 日

线性搜索允许我们在未排序的数组中搜索目标项目。

然而，如果数组是排序的，那么我们可以使用一个更有效的算法，叫做二分搜索法。

二进位检索

在二分搜索法，我们从检查数组中间元素的目标值开始。如果目标值等于中间元素，我们的搜索就成功了，我们就完成了。如果目标值与中间元素不同，并且由于数组是排序的，我们可以自动移除数组中一半可能的元素。

如果目标值小于中间元素，那么我们可以得出结论，目标值必须位于数组的下半部分。否则，目标值必须位于数组的上半部分。

假设目标值小于中间元素，因此我们继续在数组的下半部分搜索，再次获取目标值并将其与中间元素进行比较。我们不断重复这个过程，直到找到目标值，或者没有更多的元素可以搜索。

举个例子吧。

假设，我们有一个数组arr声明并初始化为:

#define SIZE 10
int arr[SIZE] = {
    
    10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; // sorted array

为了跟踪我们将在数组中搜索的索引位置，我们需要三个额外的变量:low、up和midpoint。

low变量是指数组的下界。最初将设置为0。

low = 0

up变量是指数组的上限。最初，它将被设置为比数组小一。

up = SIZE - 1

midpoint变量是指数组下限和上限之间的中点。midpoint的值计算如下:

midpoint = (low + up) / 2

如果target > arr[midpoint]，那么我们可以断定目标值位于中间元素右侧的某个地方。为了开始在数组的右边部分搜索，我们将low的值更新为大于midpoint的1，即low = midpoint + 1。上界(up)的值还是一样的，不需要改动。

如果target < arr[midpoint]，那么我们可以断定目标值位于中间元素左侧的某个地方。为了开始在数组的左边搜索，我们将up的值更新为1小于midpoint，即up = midpoint - 1。下界(low)的值还是一样的，不需要改动。

如果target == arr[midpoint]，找到目标值，我们的搜索成功。

如果low > up，则没有找到目标值，因为没有更多的元素可以搜索。

以下是在排序数组中搜索目标值60的步骤。

第一步:

low = 0, up = 9,midpoint = 4

60 > arr[4] => 60 > 50，所以搜索将进行到数组的右边部分。

low = midpoint + 1 => low = 5
midpoint = (low + up) / 2 => m = (5 + 9) / 2 => m = 7

第二步:

low = 5, up = 9, midpoint = 7

60 < arr[7] => 60 < 80，所以搜索将进行到数组的左边部分。

up = midpoint - 1 => 6
midpoint = (5 + 6) / 2 => m = 5

第三步:

low = 5, up = 6, midpoint = 5

60 == arr[5] => 60 == 60，找到目标值。我们的搜索成功了。

请注意，我们已经通过 3 个步骤找到了目标值。使用线性搜索算法的相同搜索需要 6 个步骤。

现在，让我们看看如果在数组中找不到目标值会发生什么。

以下是在排序数组中搜索目标值95的步骤。

第一步:

low = 0, up = 9, midpoint = 4

95 > arr[4] => 95 > 50，所以搜索将进行到数组的右边部分。

low = midpoint + 1 => low = 5
midpoint = (low + up) / 2 => midpoint = (5 + 9) / 2 => midpoint = 7

第二步:

low = 5, up = 9, midpoint = 7

95 > arr[7] => 95 > 80，所以搜索将进行到数组的右边部分。

low = midpoint + 1 => 8
midpoint = (8 + 9) / 2 => midpoint = 8

第三步:

low = 8, up = 9, midpoint = 8

95 > arr[8] => 95 > 90，因此搜索将再次进行到数组的右边部分。

low = midpoint + 1 => 9 
midpoint = (9 + 9) / 2 => midpoint = 9

第四步:

low = 9, up = 9, midpoint = 9

95 < arr[9] => 95 < 100，因此搜索将再次进行到数组的右边部分。

up = midpoint - 1 => 8 
midpoint = (10 + 9) / 2 => midpoint = 8

注意第一次low ( 9)的值大于up ( 8)的值。因此，数组中不存在我们的目标值。

时间复杂性

现在让我们用大 O 符号来检验二分搜索法的效率。

如果数组的大小是3，那么找到目标值所需要的最大步数是 2。

同样，如果数组的大小是8，那么找到目标值所需要的最大步数是 3。

下表列出了数组的大小以及查找目标值所需的最大步骤数。

大小 步伐
three Two
eight three
Sixteen four
Thirty-two five
Sixty-four six

一般来说，我们可以说，对于大小为N的数组，找到目标值所需的最大步骤数是(\log_2N)或简单地(\log{}N)。

上述陈述可以用大 O 符号表示如下:

[\ math { o }(\ log { } n } ]

简单来说，(\ mathcal { O }(\ log { N }))仅仅意味着对于N个元素，一个算法需要(\ log { N } )个步骤

二分搜索法碳计划

下面是一个使用二进制搜索算法搜索目标的 C 程序:

/*****************************************************
 Program to search for an item using binary search
 *****************************************************/

#include <stdio.h>
#define SIZE 10

int binary_search(int arr[], int target); // function declaration

int main() 
{
    
    

    int arr[SIZE] = {
    
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // sorted array
    int target; // number to be searched
    int index;  // index position of the target

    printf("Enter number to search: ");
    scanf("%d", &target);

    index = binary_search(arr, target);  

    if(index !=  -1)
    {
    
    
        printf("Item %d found at index %d.", target, index);
    }
    else
    {
    
    
        printf("Item %d not found.", target);    
    }   

    return 0;
}

/*
 * binary_search() returns index position of the 
 * target item. Returns -1, if the target item is not found.
 */

int binary_search(int arr[], int target)
{
    
    
    /* 
       variables to keep track of the index positions
       where we will search in the array
    */
    int low = 0, up = SIZE - 1, midpoint;    

    while(low <= up)
    {
    
    
        midpoint = (low + up) / 2;  // calculate midpoint

        if(target > arr[midpoint])
        {
    
    
            // proceed search to the right portion
            low = midpoint + 1;
        }

        else if(target < arr[midpoint])
        {
    
    
            // proceed search to the left portion
            up = midpoint - 1;
        }

        else if(target == arr[midpoint])
        {
    
    
            // target value found. Return the index and exit the function
            return midpoint;
        }        
    }

    // target value not found, return -1 and exit the function
    return -1;
}

现在试试

**预期输出:**第一次运行:

Enter number to search: 5
Item 5 found at index 4.

第二次运行:

Enter number to search: 101
Item 101 not found.

它是如何工作的

程序的核心在于binary_search()功能。

binary_search()函数以数组和目标值为自变量，返回目标值的索引位置。如果没有找到目标值，则返回-1。

在第 45 行，我们声明变量来跟踪我们将在数组中搜索的索引位置。

在第 47-68 行中，我们有一个 while 循环，它一直运行到下限(low)的值小于或等于上限(up)的值。

在第 51-67 行，我们有一个 if-else 语句，它将目标值与中间元素进行比较，并相应地更新下限(low)和上限(up)的值。在目标值等于中间元素的情况下，我们返回中间元素的索引位置并退出函数。

当循环终止时，我们返回一个值-1，表示目标值不在数组中。

推荐阅读:

C 程序：使用冒泡排序法对数组升序排序

原文：https://overiq.com/c-examples/c-program-to-sort-an-array-in-ascending-order-using-bubble-sort/

最后更新于 2020 年 9 月 23 日

冒泡排序

冒泡排序是一种简单的方法，它将数组的元素按升序或降序排序。它的工作原理是比较相邻的元素，如果它们顺序不对，就交换它们。需要多次通过阵列。

以下是使用冒泡排序以升序对大小为N的数组进行排序的步骤:

通过#1 :

  1. 将arr[0]与arr[1]进行比较。如果arr[0] > arr[1]，交换他们。
  2. 将arr[1]与arr[2]进行比较。如果arr[1] > arr[2]，交换他们。
  3. 最后将a[N-2]和arr[N-1]进行对比，如果arr[N-2] > arr[N-1]的话，互换。

这完成了第一次通过。

在第一次通过之后，数组中的最高值将位于末尾。

通过#2 :

  1. 将arr[0]与arr[1]进行比较。如果arr[0] > arr[1]，交换他们。
  2. 将arr[1]与arr[2]进行比较。如果arr[1] > arr[2]，交换他们。
  3. 最后将a[N-3]和arr[N-2]进行对比，如果arr[N-3] > arr[N-2]的话，互换。

这完成了第二次通过。在此传递之后，第二高的元素将位于数组中第二高的索引处。

请注意，在第二次通过的最后一步中，我们没有将第二个最后元素即a[N-2]与最后一个元素即arr[N-1]进行比较，这是因为最后一个元素已经处于其正确位置。

通过#3 :

  1. 将arr[0]与arr[1]进行比较。如果arr[0] > arr[1]，交换他们。
  2. 将arr[1]与arr[2]进行比较。如果arr[1] > arr[2]，交换他们。
  3. 最后将a[N-4]和arr[N-3]进行对比，如果arr[N-4] > arr[N-3]的话，互换。

这完成了第三次通过。在此传递之后，第三高的元素将位于数组中第三高的索引处。

就这样，我们不停地穿过阵列。当我们遇到一个没有交换任何元素的通道时，我们就停下来。

举个例子吧。

假设，我们有一个数组arr声明并初始化为:

#define SIZE 5
int arr[SIZE] = {
    
    80, 60, 90, 10, 40}; // unsorted array

以下是使用冒泡排序按升序对该数组进行排序的步骤。

通过#1 :

第一步:比较80和60。80 > 60自，互换它们:

| 60 | 80 | 90 | 10 | 40 |

第二步:比较80和90。80 < 90自，我们什么都不做:

| 60 | 80 | 90 | 10 | 40 |

第三步:比较90和10。90 > 10自，互换它们:

| 60 | 80 | 10 | 90 | 40 |

第四步:比较90和40。90 > 40自，互换它们:

| 60 | 80 | 10 | 40 | 90 |

这完成了第一次通过。最高的元素，即90，现在在数组的末尾。在这个通道中，我们进行了三次互换。所以，我们需要进行另一次穿越。请记住，我们会一直穿过数组，直到遇到一个没有交换任何元素的通道。

通过#2 :

第一步:比较60和80。60 < 80自，我们什么都不做:

| 60 | 80 | 10 | 40 | 90 |

第二步:比较80和10。80 > 10自，互换它们:

| 60 | 10 | 80 | 40 | 90 |

第三步:比较80和40。80 > 40自，互换它们:

| 60 | 10 | 40 | 80 | 90 |

这完成了第二次通过。第二高的元素，即80，现在位于数组中第二高的索引处。另外，请注意，我们没有将80与90进行比较。这是因为元件90已经处于从通道#1 开始的正确位置。

我们在这个通道中进行了两次交换。所以，我们需要再表演一个。

通过#3 :

第一步:比较60和10。60 > 10自，互换它们:

| 10 | 60 | 40 | 80 | 90 |

第二步:比较60和40。60 > 40自，互换它们:

| 10 | 40 | 60 | 80 | 90 |

这完成了第三次通过。第三高的元素，即60，现在位于数组中第三高的索引处。另外，请注意，我们没有将60与80进行比较。这是因为元件80已经从通道#2 处于其正确位置。

我们在这个通道中进行了两次交换。所以，我们需要再表演一个。

通过#4 :

第一步:比较10和40。10 < 40自，我们什么都不做:

| 10 | 40 | 60 | 80 | 90 |

这完成了第四次通过。我们没有在这个通道里交换任何东西。所以，我们需要不需要再表演一个。数组中的所有元素现在都按升序排序。

冒泡排序程序

下面是一个使用冒泡排序算法对数组进行升序排序的 C 程序:

/****************************************************************
 * Program to sort an array in ascending order using Bubble sort  
 ****************************************************************/

#include<stdio.h> // include stdio.h library
#define MAX 5
void bubble_sort(int arr[]); // function declaration

int main(void)
{
    
            
    int arr[MAX]; 

    // input array
    for(int i = 0; i < MAX; i++)
    {
    
    
        printf("arr[%d] = ", i);    
        scanf("%d", &arr[i]);
    }

    printf("\nUnsorted array: \n");

    // print unsorted array
    for(int i = 0; i < MAX; i++)
    {
    
    
        printf("%d ", arr[i]);    
    }

    // sort array
    bubble_sort(arr);

    printf("\n\nSorted array: \n");

    // print sorted array
    for(int i = 0; i < MAX; i++)
    {
    
    
        printf("%d ", arr[i]);    
    }

    return 0; // return 0 to operating system
}

/*
 *  bubble_sort() takes an array and sorts it
 *  in the ascending order
 */

void bubble_sort(int arr[])
{
    
    
    int tmp,  // temporary variable to hold one of the values while swapping
        is_swapped; // variable to indicate whether we have made any swaps during the passthrough

    for(int i = 0; i < MAX; i++)
    {
    
    
        // re-initialize is_swapped to 0 after every passthrough       
        is_swapped = 0;  

        for(int j = 0; j < MAX - 1 - i; j++)
        {
    
                
            if(arr[j] > arr[j+1]) // compare adjacent elements
            {
    
    
                // swap adjacent elements
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;

                // set is_swapped to 1, to indicate
                // that we have made at least one 
                // swap during the passthrough
                is_swapped = 1;               
            }     
        }        

        // if no swaps are made in the last passthrough,
        // exit the outer for loop

        if (!is_swapped)
        {
    
    
            break;
        }
    }        
}

现在试试

预期输出:

Enter array: 
arr[0] = 80
arr[1] = 60
arr[2] = 90
arr[3] = 10
arr[4] = 40

Unsorted array: 
80 60 90 10 40 

Sorted array: 
10 40 60 80 90

它是如何工作的

所有工作都在bubble_sort()功能中完成:

以下是它的工作原理:

在第 50 行和第 51 行，我们已经声明了两个变量:tmp和is_swapped。在交换元素时，tmp变量将保存其中一个值，is_swapped用作一个标志，指示我们在传递过程中是否进行了任何交换。

在第 53-81 行，我们有一个外部 for 循环，它一直运行到数组没有被排序。

第 58-72 行的内部 for 循环在传递过程中交换无序元素。它从数组的开头开始，一直到还没有排序的索引。

如果我们在通过期间至少进行了一次交换，我们将is_swapped设置为1(第 70 行)。

最后，第 77-80 行的 if 语句检查is_swapped的值，以确定是否脱离外部 for 循环。当我们遇到一个没有交换任何元素的通道时，我们脱离了外部 for 循环。

请记住，上面的函数按升序对数组进行排序。要按降序排列元素，只需将第 60 行的 if 条件从arr[j] > arr[j+1]更改为arr[j] < arr[j+1]。

推荐阅读:

C 程序：检查一个字符串是否是回文

原文：https://overiq.com/c-examples/c-program-to-check-whether-a-string-is-palindrome-or-not/

最后更新于 2020 年 7 月 27 日

[no_toc]

什么是回文？

一个数字或一个单词即使被颠倒了也保持不变，叫做回文。比如妈妈，雷达，或者数字 45654，都是回文。

下面是一个判断一个字符串是否是回文的 C 程序。

/*******************************************************
 Program to check whether a string is palindrome or not
 * 
 * Enter a word: racecar
 * racecar is palindrome
 *******************************************************/

#include<stdio.h> // include stdio.h library
#include<string.h> // include stdio.h library

int main(void)
{
    
           

    int len, i= 0, j, is_palindrome = 1;

    char word[50];

    printf("Enter a word: ");
    scanf("%s", word);

    j = strlen(word) - 1;  // get the last valid index

    while(i <= j)
    {
    
    
        if (word[i] != word[j])
        {
    
    
            is_palindrome = 0;
            break;
        }

        i++;  
        j--;
    }

    if(is_palindrome)
    {
    
    
        printf("%s is palindrome", word);
    }
    else
    {
    
    
        printf("%s is not palindrome", word);
    }

    return 0;
}

**预期输出:**第一次运行:

Enter a word: racecar
racecar is palindrome

第二次运行:

Enter a word: netbeans
netbeans is not palindrome

相关程序: C 程序检查数字是否为回文

它是如何工作的

下表演示了 while 循环每次迭代时发生的情况，假设word = radar。

循环 情况 我 j
第一次迭代后 word[0]!=word[1]=>'r'!='r'=>0 i=1 j=3
第二次迭代后 word[1]!=word[3]=>'a'!='a'=>0 i=2 j=2
第三次迭代后 word[2]!=word[2]=>'d'!='d'=>0 i=3 j=1

因此，字符串radar是回文。

推荐阅读:

C 程序：使用递归计算阶乘

原文：https://overiq.com/c-examples/c-program-to-calculate-factorial-using-recursion/

最后更新于 2020 年 9 月 24 日

下面是一个使用递归计算阶乘的 C 程序:

/**************************************************
 Program to calculate Factorial using recursion 
 * 
 * Enter a number: 4
 * 4! = 24
 ***************************************************/

#include<stdio.h> // include stdio.h library
long factorial(int num);

int main(void)
{
    
        
    int n;

    printf("Enter a number: ");
    scanf("%d", &n);

    printf("%d! = %ld", n, factorial(n));

    return 0; // return 0 to operating system
}

long factorial(int num)
{
    
        

    //base condition
    if(num == 0)
    {
    
    
        return 1;
    }

    else
    {
    
    
        // recursive call
        return num * factorial(num -  1);
    }

}

现在试试

预期输出:

第一次运行:

Enter a number: 0
0! = 1

第二次运行:

Enter a number: 5
5! = 120

它是如何工作的

下图演示了5!的评估是如何进行的:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

C 程序：使用递归计算幂

原文：https://overiq.com/c-examples/c-program-to-calculate-the-power-using-recursion/

最后更新于 2020 年 9 月 24 日

下面是一个用递归计算幂的 C 程序:

/***************************************************
 Program to calculate the power using recursion 
 * 
 * Enter base: 2
 * Enter exponent: 5
 * 2^5 = 32
 ***************************************************/

#include<stdio.h> // include stdio.h library
int power(int, int);

int main(void)
{
    
        
    int base, exponent;

    printf("Enter base: ");
    scanf("%d", &base);

    printf("Enter exponent: ");
    scanf("%d", &exponent);

    printf("%d^%d = %d", base, exponent, power(base, exponent));

    return 0; // return 0 to operating system
}

int power(int base, int exponent)
{
    
        

    //base condition
    if(exponent == 0)
    {
    
    
        return 1;
    }

    else
    {
    
    
        // recursive call
        return base * power(base, exponent - 1);
    }

}

现在试试

**预期输出:**第一次运行:

Enter base: 2
Enter exponent: 0
2^0 = 1

第二次运行:

Enter base: 4
Enter exponent: 4
4^4 = 256

它是如何工作的

下图显示了(4^4\的递归计算是如何进行的。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

推荐阅读:

C 程序：使用递归打印斐波那契数列

原文：https://overiq.com/c-examples/c-program-to-print-fibonacci-sequence-using-recursion/

最后更新于 2020 年 9 月 24 日

下面是一个用递归打印斐波那契数列的 C 程序:

/****************************************************
 Program to print Fibonacci Sequence using recursion 
 * 
 * Enter terms: 10
 * 0 1 1 2 3 5 8 13 21 34 
 ****************************************************/

#include<stdio.h> // include stdio.h library
int fibonacci(int);

int main(void)
{
    
        
    int terms;

    printf("Enter terms: ");
    scanf("%d", &terms);       

    for(int n = 0; n < terms; n++)
    {
    
    
        printf("%d ", fibonacci(n));
    }

    return 0; // return 0 to operating system
}

int fibonacci(int num)
{
    
        

    //base condition
    if(num == 0 || num == 1)
    {
    
    
        return num;
    }

    else
    {
    
    
        // recursive call
        return fibonacci(num-1) + fibonacci(num-2);
    }

}

现在试试

预期输出:

Enter terms: 20
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

它是如何工作的

下图显示了fibonacci(3)的评估是如何进行的:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

推荐阅读:

C 程序：使用递归反转数字

原文：https://overiq.com/c-examples/c-program-to-reverse-the-digits-of-a-number-using-recursion/

最后更新于 2020 年 9 月 24 日

下面是一个使用递归反转数字的 C 程序:

/**********************************************************
 Program to reverse the digits of a number using recursion 
 * 
 * Enter a number: 4321
 * 1234
 **********************************************************/

#include<stdio.h> // include stdio.h library
void reverse_num(int num);

int main(void)
{
    
        
    int num;

    printf("Enter a number: ");
    scanf("%d", &num);       

    reverse_num(num);

    return 0; // return 0 to operating system
}

void reverse_num(int num)
{
    
        
    int rem;

    // base condition
    if (num == 0)
    {
    
    
        return;
    }

    else
    {
    
    
        rem = num % 10; // get the rightmost digit
        printf("%d", rem);
        reverse_num(num/10);  // recursive call
    }

}

现在试试

**预期输出:**第一次运行:

Enter a number: 12345
54321

第二次运行:

Enter a number: 1331 
1331

它是如何工作的

下图显示了reverse_num(123)的评估是如何进行的:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

推荐阅读:

C 程序：使用递归将十进制数转换成二进制、八进制和十六进制

原文：https://overiq.com/c-examples/c-program-to-convert-a-decimal-number-to-binary-octal-and-hexadecimal-using-recursion/

最后更新于 2020 年 9 月 24 日

下面是一个使用递归将十进制数转换为二进制、八进制和十六进制的 C 程序:

/**********************************************************
 Program to convert a decimal number to binary, 
 octal and hexadecimal using recursion 
 * 
 * Select conversion: 

 * 1\. Decimal to binary. 
 * 2\. Decimal to octal. 
 * 3\. Decimal to hexadecimal. 
 * 4\. Exit. 

 * Enter your choice: 1
 * Enter a number: 4
 * Result = 100
 **********************************************************/

#include<stdio.h> // include stdio.h library
void convert_to_x_base(int, int);

int main(void)
{
    
    
    int num, choice, base;

    while(1)
    {
    
    
        printf("Select conversion: \n\n");
        printf("1\. Decimal to binary. \n");
        printf("2\. Decimal to octal. \n");
        printf("3\. Decimal to hexadecimal. \n");              
        printf("4\. Exit. \n");

        printf("\nEnter your choice: ");
        scanf("%d", &choice);

        switch(choice)
        {
    
    
            case 1:
                base = 2;
                break;
            case 2:
                base = 8;
                break;              
            case 3:
                base = 16;
                break;
            case 4:
                printf("Exiting ...");
                exit(1);
            default:
                printf("Invalid choice.\n\n");
                continue;
        }

        printf("Enter a number: ");
        scanf("%d", &num);

        printf("Result = ");

        convert_to_x_base(num, base);

        printf("\n\n");
    }        

    return 0; // return 0 to operating system
}

void convert_to_x_base(int num, int base)
{
    
        
    int rem;

    // base condition
    if (num == 0)
    {
    
    
        return;
    }

    else
    {
    
    
        rem = num % base; // get the rightmost digit        
        convert_to_x_base(num/base, base);  // recursive call        
        if(base == 16 && rem >= 10)
        {
    
    
            printf("%c", rem+55);
        }

        else
        {
    
    
            printf("%d", rem);
        }
    }

}

现在试试

预期输出:

Select conversion:

1\. Decimal to binary. 
2\. Decimal to octal. 
3\. Decimal to hexadecimal. 
4\. Exit.

Enter your choice: 1
Enter a number: 7
Result = 111

Select conversion:

1\. Decimal to binary. 
2\. Decimal to octal. 
3\. Decimal to hexadecimal. 
4\. Exit.

Enter your choice: 2
Enter a number: 25
Result = 31

Select conversion:

1\. Decimal to binary. 
2\. Decimal to octal. 
3\. Decimal to hexadecimal. 
4\. Exit.

Enter your choice: 4
Exiting ...

它是如何工作的

下图显示了convert_to_x_base(4, 2)的评估是如何进行的:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

推荐阅读:

C 程序：将十进制数转换成二进制数

原文：https://overiq.com/c-examples/c-program-to-convert-a-decimal-number-to-a-binary-number/

最后更新于 2020 年 9 月 24 日

下面是一个将十进制数转换成二进制数的 C 程序:

/*******************************************************
 Program to convert a decimal number to a binary number
 ******************************************************/

#include<stdio.h> // include stdio.h library
#include<math.h> // include math.h library

int main(void)
{
    
       
    long long num, bin = 0;    
    int i = 0, rem;

    printf("Enter a decimal number: ");
    scanf("%lld", &num);      

    while(num != 0)
    {
    
    
        rem = num % 2;  // get the remainder 
        bin = rem * (long long)pow(10, i++) + bin;  
        num /= 2;  // get the quotient
    }       

    printf("%lld", bin);        

    return 0; // return 0 to operating system
}

现在试试

预期输出: 1sr 运行:

Enter a decimal number: 4
100

第二次运行:

Enter a decimal number: 123456
11110001001000000

工作原理:

要将十进制数转换为二进制数，我们遵循以下步骤:

第一步:十进制数连续除以 2，余数在被除数右侧向右。我们重复这个过程，直到得到商 0。

第二步:从下往上写余数。

现在我们举几个例子。

例 1 :将十进制数5转换为二进制数。

第一步:

商 剩余物
5/2 2 1
2/2 1 0
1/2 0 1

第二步:

(5_{10}) = (101_2)

例 2 :将十进制数123转换为二进制数。

第一步:

商 剩余物
123/2 61 1
61/2 30 1
30/2 15 0
15/2 7 1
7/2 3 1
3/2 1 1
1/2 0 1

步骤 2: (123_{10}) = (1111011_2)

下表显示了循环每次迭代时发生的情况(假设num = 4):

循环 雷姆 容器 数字 我
第一次迭代后 rem = 4 % 2 = 0 bin = 0 * (10^0) + 0 = 0 num = 4 / 2 = 2 i = 2
第二次迭代后 rem = 2 % 2 = 0 bin = 0 * (10^1) + 0 = 0 num = 2 / 2 = 1 i = 3
第三次迭代后 rem = 1 % 2 = 1 bin = 1 * (10^2) + 0 = 100 num = 1 / 2 = 0 i = 4

C 程序：将十进制数转换成十六进制数

原文：https://overiq.com/c-examples/c-program-to-convert-a-decimal-number-to-a-hexadecimal-number/

最后更新于 2020 年 9 月 24 日

下面是一个将十进制数转换成二进制数的 C 程序:

/************************************************************
 Program to convert a decimal number to a hexadecimal number
 ************************************************************/

#include<stdio.h> // include stdio.h library

int main(void)
{
    
       
    int num, bin = 0;    
    int i = 0, rem;
    char hex_arr[50];

    printf("Enter a decimal number: ");
    scanf("%d", &num);      

    while(num != 0)
    {
    
    
        rem = num % 16;  // get the right most digit

        if (rem < 10)
        {
    
    
            hex_arr[i++] = 48 + rem;
        }
        else
        {
    
    
            hex_arr[i++] = 55 + rem;
        }

        num /= 16;  // get the quotient
    }

    printf("0x");

    for(int j = i - 1; j >= 0 ; j--)  // print the hex_arr in reverse order
    {
    
    
        printf("%c", hex_arr[j]);
    }    

    return 0; // return 0 to operating system
}

现在试试

**预期输出:**第一次运行:

Enter a decimal number: 198
0xC6

第二次运行:

Enter a decimal number: 123456
0x1E240

它是如何工作的

要将十进制数转换为十六进制数，我们执行以下步骤:

第一步:十进制数连续除以 16，余数写在被除数的右边。我们重复这个过程，直到得到商 0。

步骤 2:如果余数大于 10，则用下表中给出的十六进制字符替换它:

小数 十六进制的
10 A
11 B
12 C
13 D
14 E
15 F

第三步:从下往上写剩余部分。

让我们举一些例子:

例 1 :将十进制 210 转换为十六进制数。

第一步:

商 剩余物
210/16 13 2
13/16 0 13

第二步:

商 剩余物 十六进制的
210/16 13 2 2
13/16 0 13 D

第三步:

(\mathtt{210_{10} = 0xD2_{16}})

例 2 :

将十进制 100 转换为十六进制数。

第一步:

商 剩余物
100/16 6 4
6/16 0 6

第二步:在这种情况下，两个余数都小于 10，所以我们不需要用十六进制字符替换它们。

第三步:

(\mathtt{100_{10} = 0x64_{16}})

下表显示了循环每次迭代时发生的情况(假设num = 198):

循环 雷姆 hex_arr 数字 我
第一次迭代后 rem=198%16=6 hex_arr[0]=48+6=54 num=198/16=12 i=1
第二次迭代后 rem=12%16=12 hex_arr[1]=55+12=67 num=12/16=0 i=2

推荐阅读

猜你喜欢

转载自blog.csdn.net/wizardforcel/article/details/143582753
今日推荐
周排行
跟小白一起了解区块链
linux下常用FTP命令 1 连接ftp服务器
Oracle RAC客户端tnsnames.ora相关配置及测试
总结1126
图像成像原理
进阶学习
CF598E Chocolate Bar
StratifiedKFold和Kfold的区别
列表[ ]元组()range
影视 "少年的你" 最大bug之手机出戏
每日归档
更多
2025-02-11(0)
2025-02-10(0)
2025-02-09(0)
2025-02-08(0)
2025-02-07(0)
2025-02-06(0)
2025-02-05(0)
2025-02-04(0)
2025-02-03(0)
2025-02-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022