c语言实验七

实验1：下列程序的功能是分别求出数组中所有奇数之和以及所有偶数之和。形参n给了数组中数据的个数，利用指针odd返回奇数之和，利用指针even返回偶数之和。例如：数组中的值依次为：1，9，2，3，11，6；则利用指针odd返回奇数之和24；利用指针even返回偶数之和8。请在下面空白处将实现这一功能的函数完善，并且调试运行出结果。

#include <stdio.h>

//fun函数用于计算数组中所有奇数之和与所有偶数之和
void fun(int* a, int n, int* odd, int* even) {
	//初始化奇数之和为0
	*odd = 0;
	//初始化偶数之和为0
	*even = 0;
	//遍历数组
	for (int i = 0; i < n; i++) {
		//如果当前元素是偶数
		if (a[i] % 2 == 0) {
			//增加偶数和
			*even += a[i];
		}
		else {
			//奇数
			*odd += a[i];
		}
	}
}

int main() {
	int a[6] = { 1,9,2,3,11,6 };
	//计算数组的大小
	int i, n = sizeof(a) / sizeof(a[0]);
	int odd, even;
	//打印原始数据
	printf("原始数据是:\n");
	//遍历数组并打印每个元素
	for (i = 0; i < n; i++) {
		printf("%d ",a[i]);
	}
	printf("\n\n");

	//通过fun函数计算奇数和偶数之和，并通过指针传递给odd与even变量
	fun(a, n, &odd, &even);


	printf("奇数之和：%d\n",odd);
	printf("偶数之和：%d\n",even);

	return 0;
}

分析：
该代码首先定义了一个fun函数，该函数通过遍历数组并检查每个元素是奇数还是偶数，来分别计算奇数之和和偶数之和。然后，在main函数中，代码初始化了数组、计算了数组的大小，并调用了fun函数来计算奇数和和偶数和。最后，代码打印了这两个值。

思路：
该代码的思路是通过对数组中的每个元素进行分类（奇数或偶数），然后分别累加到对应的变量中，从而得到奇数之和和偶数之和。这是一种基本的数组操作方法，用于对数组中的数据进行分类并计算总和。

注意事项：

1. 在调用fun函数时，需要使用&操作符获取odd和even的地址，以便将计算结果返回到这些变量中。这是因为fun函数需要修改odd和even的值。
2. 在计算数组大小时，使用sizeof(a) / sizeof(a[0])是一种常见的方法。这是因为sizeof(a)返回整个数组所占用的字节大小，而sizeof(a[0])返回数组中一个元素的字节大小。因此，将两者相除可以得到数组中元素的个数。

?

实验2：假设每班人数最多不超过30人，具体人数由键盘输入，试编程打印最高分及其学号。

要求：用一维数组和指针变量作函数参数，编程打印某班一门课成绩的最高分和学号。请编写相应的程序代码，并调试运行出正确结果。

#include <stdio.h>
#define MAX_STUDENTS 30

//定义一个函数，用于找到最高分数及其对应的学号
void findMaxScore(int* scores, int* studentID, int numStudents,
                 int* maxScore, int* maxID)
         {
    *maxScore = scores[0]; // 初始化最高分为第一个学生的成绩
    *maxID = studentID[0]; // 初始化最高分对应的学号为第一个学生的学号
	//遍历所有学生的分数，找到最高分数及其对应的学号
    for (int i = 1; i < numStudents; i++) {
        if (scores[i] > *maxScore) {
            *maxScore = scores[i]; // 更新最高分
            *maxID = studentID[i]; // 更新最高分对应的学号
        }
    }
}

int main() {
    int scores[MAX_STUDENTS]; //学生成绩的数组
    int studentID[MAX_STUDENTS];//学生学号的数组
    int numStudents;//学生人数

	//用户输入学生的人数
    printf("请输入班级中的学生人数：");
    scanf("%d", &numStudents);

	//用户输入每个学生的成绩
    printf("请输入每个学生的成绩：\n");
    for (int i = 0; i < numStudents; i++) {
        scanf("%d", &scores[i]);
    }
	//用户输入每个学生的学号
    printf("请输入每个学生的学号：\n");
    for (int i = 0; i < numStudents; i++) {
        scanf("%d", &studentID[i]);
    }

    int maxScore, maxID; //最高分数和对应学号的变量
	//调用函数，找出最高分数及其对应的学号
    findMaxScore(scores, studentID, numStudents, &maxScore, &maxID);

    printf("最高分：%d\n", maxScore);
    printf("对应学号：%d\n", maxID);

    return 0;
}

解释思路：

1. 首先，程序定义了一个findMaxScore函数，该函数接受学生的分数和学号数组，以及学生人数作为参数。这个函数通过遍历所有学生的分数，找出最高分数及其对应的学号。
2. 在main函数中，程序首先声明了存储学生成绩和学号的数组，以及一个变量用于存储学生人数。然后，程序询问用户输入学生人数、每个学生的成绩和学号。这些信息分别被存储在相应的数组中。
3. 在收集了所有必要的信息后，程序调用findMaxScore函数，该函数将找出最高分数及其对应的学号。这些信息被存储在maxScore和maxID变量中。
4. 最后，程序打印出找到的最高分数和对应学号。

?实验3：

1. 输入一个字符串，内有数字和非数字字符，例如A123X456 17960? 302tab5876 ,将其中连续的数字作为一个整数，依次存放在一个数组m中，例如，123放在m[0],456放在m[1]...，并统计共有多少个整数，输出这些数。

#include <stdio.h>
#include <string.h>  //字符串处理函数
#include <ctype.h>   //字符类别测试函数

//定义extractIntegers函数，用于从字符串中提取整数
int extractIntegers(char* str, int* m) {
    int count = 0; // 统计整数的个数

    // 遍历字符串中的每个字符
    for (int i = 0; i < strlen(str); i++) {

        //使用isdigit函数检查当前字符是否为数字
        if (isdigit(str[i])) { // 如果当前字符是数字
            int num = 0; // 用于存储提取到的数字

            // 提取连续的数字 
            while (isdigit(str[i])) {
                num = num * 10 + (str[i] - '0'); // 将字符转换为数字并累加
                i++; // 继续下一个字符
            }

            m[count] = num; // 将提取到的数字存入数组中
            count++; // 整数个数加1
        }
    }

    return count;
}

int main() {
    char str[100];
    int m[100];

    printf("请输入一个字符串：");
    gets_s(str);

    int count = extractIntegers(str, m);

    printf("共有%d个整数，它们分别是：", count);
    for (int i = 0; i < count; i++) {
        printf("%d ", m[i]);
    }
    printf("\n");

    return 0;
}

分析思路：
这段代码的逻辑比较清晰。首先，它定义了一个?extractIntegers?函数，该函数通过遍历输入字符串中的每个字符来提取整数。然后，在?main?函数中，程序提示用户输入一个字符串，并调用?extractIntegers?函数来提取其中的整数。最后，程序输出提取到的整数及其个数。代码使用了?isdigit?函数来判断字符是否为数字，以及?gets_s?函数来安全地读取用户输入。整体而言，代码结构清晰，逻辑严密。

isdigit?是一个 C 语言标准库函数，用于检查给定的字符是否是数字字符（0-9）。它属于?<ctype.h>?头文件。

函数的定义如下：

如果?c?是一个数字字符（0-9），则?isdigit(c)?返回非零值（通常是?1）。否则，返回?0。

例如：

#include <stdio.h>  
#include <ctype.h>  
  
int main() {  
    char c1 = '5';  
    char c2 = 'a';  
      
    if (isdigit(c1)) {  
        printf("%c is a digit\n", c1);  
    } else {  
        printf("%c is not a digit\n", c1);  
    }  
      
    if (isdigit(c2)) {  
        printf("%c is a digit\n", c2);  
    } else {  
        printf("%c is not a digit\n", c2);  
    }  
      
    return 0;  
}

输出

实验4：矩阵转置；

要求：从主程序中输入一个3*5的整形矩阵，调用一个函数，将此矩阵转置，用指针作为函数的形参，在主程序中输出转置后的矩阵。

// 引入标准输入输出库和标准库  
#include <stdio.h>  
#include <stdlib.h>  

// 定义矩阵转置函数，输入是一个二维整数指针和行数与列数  
void transposeMatrix(int** matrix, int rows, int cols) {
    // 动态分配一个二维指针，用于存储转置后的矩阵  
    int** temp = (int**)malloc(cols * sizeof(int*));
    // 为每一列分配内存  
    for (int i = 0; i < cols; i++) {
        temp[i] = (int*)malloc(rows * sizeof(int));
    }

    // 转置矩阵：将原矩阵的[i][j]元素复制到temp的[j][i]  
    for (int i = 0; i < cols; i++) {
        for (int j = 0; j < rows; j++) {
            temp[i][j] = matrix[j][i];
        }
    }

    // 将temp中的数据复制回原矩阵，完成转置操作  
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = temp[j][i];
        }
    }

    // 释放temp所占用的内存  
    for (int i = 0; i < cols; i++) {
        free(temp[i]);
    }
    free(temp);
}

// 主函数  
int main() {
    // 输入矩阵的行数和列数  
    int rows, cols;
    printf("请输入矩阵的行数和列数：\n");
    scanf("%d %d", &rows, &cols);

    // 动态分配一个二维指针，用于存储输入的矩阵  
    int** matrix = (int**)malloc(rows * sizeof(int*));
    // 为每一行分配内存  
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
    }

    // 输入一个整数矩阵  
    printf("请输入一个%d*%d的整数矩阵：\n", rows, cols);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    // 调用矩阵转置函数  
    transposeMatrix(matrix, rows, cols);

    // 输出转置后的矩阵  
    printf("转置后的矩阵为：\n");
    for (int i = 0; i < cols; i++) {
        for (int j = 0; j < rows; j++) {
            printf("%d ", matrix[j][i]);
        }
        printf("\n");
    }

    // 释放matrix所占用的内存  
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;  // 主函数返回0，表示程序正常结束  
}

?

以下是上述代码的思路分析：

1. 首先，通过malloc动态分配内存，创建了一个二维数组temp，它的行数等于原矩阵的列数，列数等于原矩阵的行数。
2. 使用两个嵌套循环，将原矩阵的数据复制到temp中，实现矩阵的转置。
3. 再次使用两个嵌套循环，将temp中的数据复制回原矩阵。
4. 最后，逐行释放temp中的内存，然后再释放temp本身的内存。

这个思路的核心是利用了两个二维数组，其中一个（temp）用于存储转置后的矩阵，另一个（原矩阵）用于存储用户输入的矩阵。通过两个嵌套循环，实现了矩阵的转置操作。