【趣学C语言和数据结构100例】

问题描述

11.求一个 3x3 的整型矩阵对角线元素之和。

（扩展）输入 n，求一个 nxn 的整型矩阵对角线元素之和。

12.有一个已排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中。

13.将一个数组中的值按逆序重新存放。例如，原来顺序为 8, 6, 5, 4, 1。要求改为 1, 4, 5, 6, 8。

14.输出杨辉三角（10行）

15.输出“魔方阵”。所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。要求输出 1~n² 的自然数构成的魔方阵。

代码分析

==11和扩展.矩阵对角线元素之和==
对角线分为正对角线和副对角线，对角线元素之和=正对角线+副对角线-重复的元素
对于 3x3 的整型矩阵对角线元素之和为正对角线+副对角线-a[1][1]。
对于 nxn 的整型矩阵，先判断n为奇数还是偶数：

• n为奇数，对角线元素之和为正对角线+副对角线-a[n/2][n/2]
• n为偶数，对角线元素之和为正对角线+副对角线

==12.有序数组进行插入==
for循环遍历，从后往前==（因为数组最后一位为空）==，检查当前元素是否大于输入的数 num，如果大于，则将当前元素向后移动一位（ array[i+1] = array[i];）。注意：跳出循环时，输入的数未插入，故加一步array[i + 1] = num。

==13.数组逆序==
使用双下标，beg和end,分别在数组最小和最大，for循环遍历，使array[beg]和array[end]和互换，并且beg++,end--。直到beg>=end结束。

==14. 杨辉三角==
杨辉三角如下：

可知第一列和正对角线都为1（即i= =j || i= =0），对于普通位置array[i][j]=array[i-1][j]+array[i-1][j-1];（该位置的正上方数+该位置的正上方数的左边），按照数组打印。

==15.魔方阵==
分析：每一行、每一列和对角线之和均相等。会得到以下规律。
（1）.==将1放在第1行的中间一列。==
（2）.从2开始直到n*n止，各数依次按此规律存放: ==每一个数存放的行比前一个数的行数减1，列数加1。==
（3）.==如果上一行的行数为1，则下一个数的行数为n(指最下一行)==
（4）.==当上一个数的列数为n时，下一个数的列数应该为1。==
（5）.如果按上面规律确定的位置==有数==，则把==下一个数放在上一个数的下面==。

代码实现

#include <stdio.h>

int main()
{
   
//  11.求一个 3x3 的整型矩阵对角线元素之和。
      int array[3][3], sum1 = 0, sum2 = 0;

    // 输入矩阵元素
    for (int i = 0; i < 3; i++) {
   
        for (int j = 0; j < 3; j++) {
   
            scanf("%d", &array[i][j]);
        }
    }

    // 计算主对角线元素之和
    for (int i = 0; i < 3; i++) {
   
        sum1 += array[i][i];
    }

    // 计算副对角线元素之和
    for (int i = 0; i < 3; i++) {
   
        sum2 += array[i][2 - i];
    }

    // 打印结果
    printf("主对角线元素之和: %d\n", sum1);
    printf("副对角线元素之和: %d\n", sum2);
    printf("整型矩阵对角线元素之和: %d\n", sum1+sum2-array[1][1]);

//  （扩展）.输入n,求一个 nxn 的整型矩阵对角线元素之和。
    int n, sum1 = 0, sum2 = 0;

    printf("请输入矩阵大小 n: ");
    scanf("%d", &n);
    int array[n][n];
    printf("请输入矩阵元素:\n");
    for (int i = 0; i < n; i++) {
   
        for (int j = 0; j < n; j++) {
   
            scanf("%d", &array[i][j]);
        }
    }
    // 计算主对角线元素之和
    for (int i = 0; i < n; i++) {
   
        sum1 += array[i][i];
    }
    // 计算副对角线元素之和
    for (int i = 0; i < n; i++) {
   
        sum2 += array[i][n - 1 - i];
    }
    // 打印结果
    printf("主对角线元素之和: %d\n", sum1);
    printf("副对角线元素之和: %d\n", sum2);

    if (n % 2 == 1) {
    
        printf("整型矩阵对角线元素之和: %d\n", sum1 + sum2 - array[n / 2][n / 2]);    // n为奇数,则减去重复 
    } else {
    
        printf("整型矩阵对角线元素之和: %d\n", sum1 + sum2);    // n为偶数，则直接加 
    }

//  12.有一个已排好序的数组,要求输入一个数后,按原来排序的规律将它插人数组中。
    int array[6] = {
   1, 3, 5, 7, 9};
    int num, i;

    printf("输入插入的数：");
    scanf("%d", &num);

//  如果当前元素 array[i] 大于 num，则将当前元素 array[i] 向后移动一位
//  即 array[i+1] = array[i]。循环结束时，i 指向插入位置的索引。
    for (i = 4; i >= 0 && array[i] > num; i--) {
   
        array[i+1] = array[i]; 
    }

    array[++i] = num; 

    for (i = 0; i < 6; i++) {
   
        printf("%d ", array[i]);
    }
    printf("\n");

//  13.将一个数组中的值按逆序重新存放。例如,原来顺序为 8,6,5,4,1。要求改为 1,4,5.6,8.
    int array[5]={
   8,6,5,4,1};
    int beg=0,end=4;
    printf("输出逆序前的数组:");
    for(int i=0;i<5;i++){
   
        printf("%d ",array[i]);
    }
    while(beg<end){
   
        int temp=array[beg];
        array[beg]=array[end];
        array[end]=temp;
        beg++;
        end--;
    }
    printf("输出逆序后的数组:");
    for(int i=0;i<5;i++){
   
        printf("%d ",array[i]);
    }
    printf("\n"); 

//    14.输出杨辉三角（10行）
    int array[10][10];
    for(int i=0;i<10;i++){
   
        for(int j=0;j<=i;j++){
   
            if(i==j || i==0)
            {
   
                array[i][j]=1;
            }
            else 
            {
   
                array[i][j]=array[i-1][j]+array[i-1][j-1];    
            }
        }
    }

    for(int i=0;i<10;i++){
   
        for(int j=0;j<=i;j++){
   
        printf("%5d",array[i][j]);
        }
        printf("\n");
    }

//    15.输出“魔方阵”。所谓魔方阵是指这样的方阵,它的每一行、每一列和对角线之和均相等。要求输出 1~n2的自然数构成的魔方阵。
//    步骤： 
//    1.将1放在第1行的中间一列。
//    2.从2开始直到n*n止，各数依次按此规律存放:每一个数存放的行比前一个数的行数减1，列数加1。 
//    3.如果上一行的行数为1，则下一个数的行数为n(指最下一行)
//    4.当上一个数的列数为n时，下一个数的列数应该为1。
//    5.如果按上面规律确定的位置有数，则把下一个数放在上一个数的下面。
    int array[N][N], i, j, n;
    printf("输入奇数n(1<=n<=%d):", N);
    scanf("%d", &n); 
    while (1) {
       
        if (n % 2 != 0 && n <= N && n != 0) 
            break;
        else {
   
            printf("重新输入奇数n(1<=n<=%d):", N);
            scanf("%d", &n);
        } 
    } 
    for (i = 0; i < n; i++) {
   
        for (j = 0; j < n; j++) {
   
            array[i][j] = 0;       // 初始化数组全为0 
        }
    }
    j = n / 2;    
    array[0][j] = 1;    // 将 1 放在第一行的中间一列

    // 从 2 的 n*n 开始，依次存放其他数字
    for (int k = 2; k <= n * n; k++) {
   
        i = i - 1;
        j = j + 1;
        // 处理越界情况,即步骤3-4
        if (i < 0 && j >= n) {
    
            i = n - 1; 
            j = 0; 
        } else if (i < 0) {
   
            i = n - 1;
        } else if (j >= n) {
   
            j = 0;
        }
        // 如果位置为空，则将数字填入
        if (array[i][j] == 0) {
   
            array[i][j] = k;
        } else {
   
            // 否则将数字填入上一个数字的下方 即步骤5
            i = (i + 1) % n;
            array[i][j] = k;
        }
    }
    printf("魔方阵如下：\n");
    for (i = 0; i < n; i++) {
   
        for (j = 0; j < n; j++) {
   
            printf("%4d ", array[i][j]);
        }
        printf("\n");
    }

    return 0;
}

总结

本文介绍了五个编程问题及其C语言实现，这些问题覆盖了矩阵操作、数组排序、逆序存放、杨辉三角和魔方阵等多个领域。这些编程问题不仅锻炼了我们的编程技巧，也加深了对算法和数据结构的理解。

矩阵对角线元素之和问题要求我们计算一个给定矩阵的主对角线和副对角线的元素之和。这个问题的解决关键在于理解对角线的概念，并分别计算两条对角线上的元素和，最后减去重复计算的中心元素。

有序数组插入问题要求我们在已排序的数组中插入一个新元素，并保持数组的有序性。这个问题的解决需要我们从后向前遍历数组，找到合适的插入位置，并将新元素插入。

数组逆序存放问题要求我们将一个数组中的值按逆序重新存放。这个问题的解决可以通过双指针法实现，一个指针从头开始，另一个指针从尾开始，然后交换两个指针指向的元素，直到两个指针相遇。

杨辉三角输出问题要求我们输出10行的杨辉三角。这个问题的解决关键在于理解杨辉三角的规律，即每行的开始和结束都是1，其他位置的元素是上一行相邻两个元素的和。

魔方阵输出问题要求我们输出一个1~n²的自然数构成的魔方阵，其中每一行、每一列和对角线之和均相等。这个问题的解决需要我们按照特定的规律填充数组，即从中间开始，按照一定的方向移动，如果遇到已填充的位置，则向下移动。

这些算法的实现不仅展示了C语言在处理数组和矩阵时的能力，也体现了算法设计的基本思想，如条件判断、循环控制和递归。通过这些算法的学习，我们可以更好地理解数据结构和算法的基本概念，提高解决实际问题的能力。

总的来说，这些算法问题不仅锻炼了编程能力，也加深了对数据结构和算法的理解。通过这些问题的解决，我们可以逐步提高自己的编程技能，为将来的学习和工作做好准备。这些算法的掌握对于计算机专业的学生和软件开发人员来说都是非常重要的。通过这些练习，我们可以逐步提高自己的编程技能，为将来的学习和工作做好准备。同时，这些问题的解决也体现了算法在处理数据时的灵活性和效率，为我们在实际开发中遇到类似问题提供了解决思路。