2025.12.02 C语言程序设计上机实习五#

必做题#

选做题#

题目1：字符串查找函数#

1
int FindSubstring(const char* str, const char* substr)
2
{
3
    if (!str || !substr) return -1;
4

5
    int n = strlen(str);
6
    int m = strlen(substr);
7

8
    if (m == 0) return 0;
9

10
    for (int i = 0; i <= n - m; i++)
11
    {
12
        int j = 0;
13
        while (j < m && str[i + j] == substr[j])
14
        {
15
            j++;
16
        }
17
        if (j == m)
18
        {
19
            return 1;
20
        }
21
    }
22

23
    return 0;
24
}

题目2：字符串替换函数#

1
// 字符串替换函数实现
2
char* ReplaceAll(const char* original, const char* target, const char* replacement)
3
{
4
    // 检查参数是否为空
5
    if (original == NULL || target == NULL || replacement == NULL)
6
    {
7
        return NULL;
8
    }
9

10
    // 计算各字符串长度
11
    int orig_len = strlen(original);
12
    int target_len = strlen(target);
13
    int repl_len = strlen(replacement);
14

15
    // 如果目标字符串为空，返回原字符串的副本
16
    if (target_len == 0)
17
    {
18
        char* result = (char*)malloc((orig_len + 1)*sizeof(char));
19

20
        if (result == NULL)
21
        {
22
            return NULL;
23
        }
24

25
        strcpy(result, original);
26
        result[orig_len] = '\0';
27
        return result;
28
    }
29

30
    // 计算需要替换的次数
31
    int count = 0;
32
    const char* pos = original;
33

34
    while ((pos = strstr(pos, target)) != NULL) // strstr的用法在课本P486
35
    {
36
        count++;
37
        pos += target_len; // 跳过已找到的目标字符串
38
    }
39

40
    // 计算新字符串长度
41
    int new_len = orig_len + count * (repl_len - target_len);
42
    char* result = (char*)malloc((new_len + 1)*sizeof(char));
43

44
    if (result == NULL)
45
    {
46
        return NULL;
47
    }
48

49
    // 执行替换操作
50
    char* current = result;
51
    const char* start = original;
52
    const char* found;
53

54
    while ((found = strstr(start, target)) != NULL)
55
    {
56
        // 复制目标字符串之前的部分
57
        int prefix_len = found - start;
58
        if (prefix_len > 0)
59
        {
60
            strncpy(current, start, prefix_len);
61
            current += prefix_len;
62
        }
63

64
        // 复制替换字符串
65
        if (repl_len > 0)
66
        {
67
            strcpy(current, replacement);
68
            current += repl_len;
69
        }
70

71
        // 移动到下一个位置
72
        start = found + target_len;
73
    }
74

75
    // 复制剩余部分
76
    strcpy(current, start);
77
    result[new_len] = '\0';
78
    return result;
79
}

修改部分：

malloc用法，长度*sizeof(类型)
strcpy复制位置（原有-1删去）（两处）
result字符串末尾要加 ‘\0’ （两处）
（无用）加入 repl_len > 0 判断

题目3：回文单词检测函数#

1
int HasPalindromeWord(const char* sentence)
2
{
3
    if (sentence == NULL)
4
        return -1; // 传空参数处理
5

6
    const char* p = sentence;
7
    while (*p) {
8

9
        while (*p && !isalnum(*p)) // 字母与数字可过，略过字符
10
        {
11
            p++;
12
        }
13

14
        if (*p == '\0') // 如果因为上一个while跳到结尾了就该抓紧终止了
15
        {
16
            break;
17
        }
18

19
        const char* start = p;
20

21
        while (*p && isalnum(*p)) // 来个字母和数字作为起点，读到不是字母和数字和'\0'就停
22
        {
23
            p++;
24
        }
25
        const char* end = p;
26

27
        unsigned int len = end - start;
28
        if (len >= 2) {
29
            size_t i = 0, j = len - 1;
30
            int is_pal = 1;
31
            while (i < j) {
32
                char a = (char)tolower(start[i]);
33
                char b = (char)tolower(start[j]);
34
                if (a != b)
35
                {
36
                    is_pal = 0;
37
                    break;
38
                }
39
                i++;
40
                j--;
41
            }
42
            if (is_pal)
43
                return 1;
44
        }
45
    }
46

47
    return 0;
48
}

题目4：礼貌数判断函数（被放弃的期中考试题）#

1
int IsPoliteNumber(int n)
2
{
3
    int test = n, sum = 0;
4
    for (int i = 1; i <= test; i++)
5
    {
6
        for (int j = i; j < test; j++)
7
        {
8
            sum += j;
9
            if (sum == test)
10
            {
11
                return 1;
12
            }
13
            else if (sum > test)
14
            {
15
                break;
16
            }
17
        }
18
        sum = 0;
19
    }
20
    return 0;
21
}

题目5：矩阵转置函数#

1
int** TransMat(int** matrix, int m, int n)
2
{
3
    int **arr;
4
    arr = (int **)malloc(n * sizeof(int *));
5
    for(int i = 0; i < n; i++)
6
    {
7
        arr[i] = (int *)malloc(m * sizeof(int));
8
        if(arr[i] == NULL)
9
            return NULL;
10
        for(int j = 0; j < m; j++)
11
        {
12
            arr[i][j] = matrix[j][i];
13
        }
14
    }
15
    return arr;
16
}

附：完整代码#

TestFindSubstr.c#

1
#include <stdio.h>
2
#include <string.h>
3

4
// 字符串查找函数声明
5
int FindSubstring(const char* str, const char* substr);
6
// 测试函数
7
void run_tests();
8

9
int main() {
10
    run_tests();
11
    return 0;
12
}
13

14
// 测试函数
15
void run_tests()
16
{
17
    printf("=== 字符串查找函数测试 ===\n\n");
18

19
    int pass_count = 0;
20
    int total_count = 0;
21

22
    // 测试用例1：正常情况
23
    printf("测试1: 正常查找\n");
24
    int result1 = FindSubstring("Hello world", "world");
25
    int expected1 = 1;
26
    printf("  输入: str=\"Hello world\", substr=\"world\"\n");
27
    printf("  预期: %d, 实际: %d - %s\n", expected1, result1,
28
           result1 == expected1 ? "通过" : "失败");
29
    if (result1 == expected1)
30
            pass_count++;
31
    total_count++;
32

33
    // 测试用例2：不存在的情况
34
    printf("\n测试2: 子串不存在\n");
35
    int result2 = FindSubstring("Hello world", "test");
36
    int expected2 = 0;
37
    printf("  输入: str=\"Hello world\", substr=\"test\"\n");
38
    printf("  预期: %d, 实际: %d - %s\n", expected2, result2,
39
           result2 == expected2 ? "通过" : "失败");
40
    if (result2 == expected2)
41
            pass_count++;
42
    total_count++;
43

44
    // 测试用例3：部分匹配但最后一个字符不匹配
45
    printf("\n测试3: 部分匹配（最后一个字符不匹配）\n");
46
    int result3 = FindSubstring("hello world", "hella");
47
    int expected3 = 0;
48
    printf("  输入: str=\"hello world\", substr=\"hella\"\n");
49
    printf("  预期: %d, 实际: %d - %s\n", expected3, result3,
50
           result3 == expected3 ? "通过" : "失败");
51
    if (result3 == expected3)
52
            pass_count++;
53
    total_count++;
54

55
    // 测试用例4：开头匹配
56
    printf("\n测试4: 子串在开头\n");
57
    int result4 = FindSubstring("hello world", "hello");
58
    int expected4 = 1;
59
    printf("  输入: str=\"hello world\", substr=\"hello\"\n");
60
    printf("  预期: %d, 实际: %d - %s\n", expected4, result4,
61
           result4 == expected4 ? "通过" : "失败");
62
    if (result4 == expected4)
63
            pass_count++;
64
    total_count++;
65

66
    // 测试用例5：结尾匹配
67
    printf("\n测试5: 子串在结尾\n");
68
    int result5 = FindSubstring("hello world", "world");
69
    int expected5 = 1;
70
    printf("  输入: str=\"hello world\", substr=\"world\"\n");
71
    printf("  预期: %d, 实际: %d - %s\n", expected5, result5,
72
           result5 == expected5 ? "通过" : "失败");
73
    if (result5 == expected5)
74
            pass_count++;
75
    total_count++;
76

77
    // 汇总结果
78
    printf("\n=== 测试结果 ===\n");
79
    printf("通过: %d/%d (%.1f%%)\n", pass_count, total_count,
80
           (float)pass_count/total_count*100);
81
}
82

83
int FindSubstring(const char* str, const char* substr)
84
{
85
    if (!str || !substr) return -1;
86

87
    int n = strlen(str);
88
    int m = strlen(substr);
89

90
    if (m == 0) return 0;
91

92
    for (int i = 0; i <= n - m; i++)
93
    {
94
        int j = 0;
95
        while (j < m && str[i + j] == substr[j])
96
        {
97
            j++;
98
        }
99
        if (j == m)
100
        {
101
            return 1;
102
        }
103
    }
104

105
    return 0;
106
}

TestReplaceAll.c#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4

5
// 函数原型声明
6
char* ReplaceAll(const char* original, const char* target, const char* replacement);
7
int StringsEqual(const char* str1, const char* str2);
8
void RunTests();
9
void TestMemoryLeak();
10

11
int main()
12
{
13
    RunTests();
14
    TestMemoryLeak();
15

16
    printf("\n按任意键退出...");
17
    getchar();
18

19
    return 0;
20
}
21

22
// 辅助函数：比较两个字符串是否相等
23
int StringsEqual(const char* str1, const char* str2)
24
{
25
    if (str1 == NULL && str2 == NULL)
26
    {
27
        return 1;
28
    }
29

30
    if (str1 == NULL || str2 == NULL)
31
    {
32
        return 0;
33
    }
34

35
    return strcmp(str1, str2) == 0;
36
}
37

38
// 测试函数
39
void RunTests()
40
{
41
    printf("=== 字符串替换函数测试 ===\n\n");
42

43
    int pass_count = 0;
44
    int total_count = 0;
45
    char* result = NULL;
46
    char* expected = NULL;
47

48
    // 测试用例1：正常情况 - 单次替换
49
    printf("测试1: 正常替换（单次出现）\n");
50
    result = ReplaceAll("I like apples", "apples", "oranges");
51
    expected = "I like oranges";
52
    printf("  输入: original=\"I like apples\", target=\"apples\", replacement=\"oranges\"\n");
53
    printf("  预期: \"%s\"\n", expected);
54
    printf("  实际: \"%s\"\n", result ? result : "NULL");
55
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
56

57
    if (StringsEqual(result, expected))
58
    {
59
        pass_count++;
60
    }
61
    total_count++;
62
    result = NULL;
63

64
    // 测试用例2：多次替换
65
    printf("\n测试2: 多次替换\n");
66
    result = ReplaceAll("I like apples, apples are delicious.", "apples", "oranges");
67
    expected = "I like oranges, oranges are delicious.";
68
    printf("  输入: original=\"I like apples, apples are delicious.\", target=\"apples\", replacement=\"oranges\"\n");
69
    printf("  预期: \"%s\"\n", expected);
70
    printf("  实际: \"%s\"\n", result ? result : "NULL");
71
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
72

73
    if (StringsEqual(result, expected))
74
    {
75
        pass_count++;
76
    }
77
    total_count++;
78
    result = NULL;
79

80
    // 测试用例3：目标子串不存在
81
    printf("\n测试3: 目标子串不存在\n");
82
    result = ReplaceAll("I like apples", "bananas", "oranges");
83
    expected = "I like apples";
84
    printf("  输入: original=\"I like apples\", target=\"bananas\", replacement=\"oranges\"\n");
85
    printf("  预期: \"%s\"\n", expected);
86
    printf("  实际: \"%s\"\n", result ? result : "NULL");
87
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
88

89
    if (StringsEqual(result, expected))
90
    {
91
        pass_count++;
92
    }
93
    total_count++;
94
    result = NULL;
95

96
    // 测试用例4：原始字符串为空
97
    printf("\n测试4: 原始字符串为空\n");
98
    result = ReplaceAll("", "apples", "oranges");
99
    expected = "";
100
    printf("  输入: original=\"\", target=\"apples\", replacement=\"oranges\"\n");
101
    printf("  预期: \"%s\"\n", expected);
102
    printf("  实际: \"%s\"\n", result ? result : "NULL");
103
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
104

105
    if (StringsEqual(result, expected))
106
    {
107
        pass_count++;
108
    }
109
    total_count++;
110
    result = NULL;
111

112
    // 测试用例5：替换为空字符串（删除操作）
113
    printf("\n测试5: 替换为空字符串（删除）\n");
114
    result = ReplaceAll("Hello World", "o", "");
115
    expected = "Hell Wrld";
116
    printf("  输入: original=\"Hello World\", target=\"o\", replacement=\"\"\n");
117
    printf("  预期: \"%s\"\n", expected);
118
    printf("  实际: \"%s\"\n", result ? result : "NULL");
119
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
120

121
    if (StringsEqual(result, expected))
122
    {
123
        pass_count++;
124
    }
125
    total_count++;
126
    result = NULL;
127

128
    // 测试用例6：连续出现目标子串（重点测试）
129
    printf("\n测试6: 连续出现目标子串\n");
130
    result = ReplaceAll("aaaa", "aa", "b");
131
    expected = "bb";
132
    printf("  输入: original=\"aaaa\", target=\"aa\", replacement=\"b\"\n");
133
    printf("  预期: \"%s\"\n", expected);
134
    printf("  实际: \"%s\"\n", result ? result : "NULL");
135
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
136

137
    if (StringsEqual(result, expected))
138
    {
139
        pass_count++;
140
    }
141
    total_count++;
142
    result = NULL;
143

144
    // 测试用例7：特殊字符
145
    printf("\n测试7: 特殊字符\n");
146
    result = ReplaceAll("a-b-c-d", "-", " ");
147
    expected = "a b c d";
148
    printf("  输入: original=\"a-b-c-d\", target=\"-\", replacement=\" \"\n");
149
    printf("  预期: \"%s\"\n", expected);
150
    printf("  实际: \"%s\"\n", result ? result : "NULL");
151
    printf("  结果: %s\n", StringsEqual(result, expected) ? "通过" : "失败");
152

153
    if (StringsEqual(result, expected))
154
    {
155
        pass_count++;
156
    }
157
    total_count++;
158
    result = NULL;
159

160
    // 汇总结果
161
    printf("\n=== 测试结果 ===\n");
162
    printf("通过: %d/%d (%.1f%%)\n", pass_count, total_count,
163
           (float)pass_count / total_count * 100);
164

165
    if (pass_count == total_count)
166
    {
167
        printf("所有测试通过！\n");
168
    }
169
    else
170
    {
171
        printf("有 %d 个测试失败\n", total_count - pass_count);
172
    }
173
}
174

175
// 内存泄漏检查辅助函数
176
void TestMemoryLeak()
177
{
178
    printf("\n=== 内存泄漏检查 ===\n");
179

180
    // 测试多次替换，检查是否有内存泄漏
181
    char* results[3];
182

183
    results[0] = ReplaceAll("test test test", "test", "TEST");
184
    results[1] = ReplaceAll("hello world", "hello", "Hi");
185
    results[2] = ReplaceAll("a b c d", " ", "");
186

187
    printf("替换结果:\n");
188

189
    for (int i = 0; i < 3; i++)
190
    {
191
        printf("  结果%d: %s\n", i + 1, results[i] ? results[i] : "NULL");
192
        free(results[i]); // 正确释放内存
193
        results[i] = NULL;
194
    }
195

196
    printf("若results均能正常输出，则释放基本正确\n");
197
}
198

199
// 字符串替换函数实现
200
char* ReplaceAll(const char* original, const char* target, const char* replacement)
201
{
202
    // 检查参数是否为空
203
    if (original == NULL || target == NULL || replacement == NULL)
204
    {
205
        return NULL;
206
    }
207

208
    // 计算各字符串长度
209
    int orig_len = strlen(original);
210
    int target_len = strlen(target);
211
    int repl_len = strlen(replacement);
212

213
    // 如果目标字符串为空，返回原字符串的副本
214
    if (target_len == 0)
215
    {
216
        char* result = (char*)malloc((orig_len + 1)*sizeof(char));
217

218
        if (result == NULL)
219
        {
220
            return NULL;
221
        }
222

223
        strcpy(result, original);
224
        result[orig_len] = '\0';
225
        return result;
226
    }
227

228
    // 计算需要替换的次数
229
    int count = 0;
230
    const char* pos = original;
231

232
    while ((pos = strstr(pos, target)) != NULL) // strstr的用法在课本P486
233
    {
234
        count++;
235
        pos += target_len; // 跳过已找到的目标字符串
236
    }
237

238
    // 计算新字符串长度
239
    int new_len = orig_len + count * (repl_len - target_len);
240
    char* result = (char*)malloc((new_len + 1)*sizeof(char));
241

242
    if (result == NULL)
243
    {
244
        return NULL;
245
    }
246

247
    // 执行替换操作
248
    char* current = result;
249
    const char* start = original;
250
    const char* found;
251

252
    while ((found = strstr(start, target)) != NULL)
253
    {
254
        // 复制目标字符串之前的部分
255
        int prefix_len = found - start;
256
        if (prefix_len > 0)
257
        {
258
            strncpy(current, start, prefix_len);
259
            current += prefix_len;
260
        }
261

262
        // 复制替换字符串
263
        if (repl_len > 0)
264
        {
265
            strcpy(current, replacement);
266
            current += repl_len;
267
        }
268

269
        // 移动到下一个位置
270
        start = found + target_len;
271
    }
272

273
    // 复制剩余部分
274
    strcpy(current, start);
275
    result[new_len] = '\0';
276
    return result;
277
}

TestPalindromeWord.c#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <ctype.h>
4

5
// 函数原型声明
6
int HasPalindromeWord(const char* sentence);
7
void RunTests();
8

9
int main()
10
{
11
    RunTests();
12
    printf("\n按任意键退出...");
13
    getchar();
14
    return 0;
15
}
16

17
// 测试函数
18
void RunTests()
19
{
20
    printf("=== 回文单词检测函数测试 ===\n\n");
21

22
    int pass_count = 0;
23
    int total_count = 0;
24
    int result = 0;
25

26
    // 测试用例1：包含回文单词
27
    printf("测试1: 包含回文单词\n");
28
    result = HasPalindromeWord("Madam,this is a test.");
29
    printf("  输入: \"Madam,this is a test.\"\n");
30
    printf("  预期: 1 (Madam是回文)\n");
31
    printf("  实际: %d\n", result);
32
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
33

34
    if (result == 1) pass_count++;
35
    total_count++;
36

37
    // 测试用例2：不包含回文单词
38
    printf("\n测试2: 不包含回文单词\n");
39
    result = HasPalindromeWord("Hello world,this is a test.");
40
    printf("  输入: \"Hello world,this is a test.\"\n");
41
    printf("  预期: 0\n");
42
    printf("  实际: %d\n", result);
43
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
44

45
    if (result == 0) pass_count++;
46
    total_count++;
47

48
    // 测试用例3：多个回文单词
49
    printf("\n测试3: 多个回文单词\n");
50
    result = HasPalindromeWord("mem level");
51
    printf("  输入: \"mem level\"\n");
52
    printf("  预期: 1\n");
53
    printf("  实际: %d\n", result);
54
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
55

56
    if (result == 1) pass_count++;
57
    total_count++;
58

59
    // 测试用例4：空句子
60
    printf("\n测试4: 空句子\n");
61
    result = HasPalindromeWord("");
62
    printf("  输入: \"\"\n");
63
    printf("  预期: 0\n");
64
    printf("  实际: %d\n", result);
65
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
66

67
    if (result == 0) pass_count++;
68
    total_count++;
69

70
    // 测试用例5：只有标点符号
71
    printf("\n测试5: 只有标点符号\n");
72
    result = HasPalindromeWord("!@#$%^&*()");
73
    printf("  输入: \"!@#$%%^&*()\"\n");
74
    printf("  预期: 0\n");
75
    printf("  实际: %d\n", result);
76
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
77

78
    if (result == 0) pass_count++;
79
    total_count++;
80

81
    // 测试用例6：单个回文单词
82
    printf("\n测试6: 单个回文单词\n");
83
    result = HasPalindromeWord("racecar");
84
    printf("  输入: \"racecar\"\n");
85
    printf("  预期: 1\n");
86
    printf("  实际: %d\n", result);
87
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
88

89
    if (result == 1) pass_count++;
90
    total_count++;
91

92
    // 测试用例7：混合大小写的回文
93
    printf("\n测试7: 混合大小写的回文\n");
94
    result = HasPalindromeWord("LeVel is important");
95
    printf("  输入: \"LeVel is important\"\n");
96
    printf("  预期: 1 (Level是回文)\n");
97
    printf("  实际: %d\n", result);
98
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
99

100
    if (result == 1) pass_count++;
101
    total_count++;
102

103
    // 测试用例8：数字和字母混合
104
    printf("\n测试8: 数字和字母混合\n");
105
    result = HasPalindromeWord("This is 12321 number");
106
    printf("  输入: \"This is 12321 number\"\n");
107
    printf("  预期: 1 (12321是回文)\n");
108
    printf("  实际: %d\n", result);
109
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
110

111
    if (result == 1) pass_count++;
112
    total_count++;
113

114
    // 汇总结果
115
    printf("\n=== 测试结果 ===\n");
116
    printf("通过: %d/%d (%.1f%%)\n", pass_count, total_count,
117
           (float)pass_count / total_count * 100);
118

119
    if (pass_count == total_count)
120
    {
121
        printf("所有测试通过！\n");
122
    }
123
    else
124
    {
125
        printf("有 %d 个测试失败\n", total_count - pass_count);
126
    }
127
}
128

129
int HasPalindromeWord(const char* sentence)
130
{
131
    if (sentence == NULL)
132
        return -1; // 传空参数处理
133

134
    const char* p = sentence;
135
    while (*p) {
136

137
        while (*p && !isalnum(*p)) // 字母与数字可过，略过字符
138
        {
139
            p++;
140
        }
141

142
        if (*p == '\0') // 如果因为上一个while跳到结尾了就该抓紧终止了
143
        {
144
            break;
145
        }
146

147
        const char* start = p;
148

149
        while (*p && isalnum(*p)) // 来个字母和数字作为起点，读到不是字母和数字和'\0'就停
150
        {
151
            p++;
152
        }
153
        const char* end = p;
154

155
        unsigned int len = end - start;
156
        if (len >= 2) {
157
            size_t i = 0, j = len - 1;
158
            int is_pal = 1;
159
            while (i < j) {
160
                char a = (char)tolower(start[i]);
161
                char b = (char)tolower(start[j]);
162
                if (a != b)
163
                {
164
                    is_pal = 0;
165
                    break;
166
                }
167
                i++;
168
                j--;
169
            }
170
            if (is_pal)
171
                return 1;
172
        }
173
    }
174

175
    return 0;
176
}

TestPoliteNumber.c#

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <time.h>
4

5
// 函数原型声明
6
int IsPoliteNumber(int n);
7
void RunTests();
8

9
int main()
10
{
11
    RunTests();
12
    printf("\n按任意键退出...");
13
    getchar();
14
    return 0;
15
}
16

17
// 测试函数
18
void RunTests()
19
{
20
    printf("=== 礼貌数判断函数测试（必须使用循环实现） ===\n\n");
21
    printf("注意：本题必须使用循环方法实现，直接使用2的幂判断将不予通过！\n\n");
22

23
    int pass_count = 0;
24
    int total_count = 0;
25
    int result = 0;
26
    clock_t start, end;
27
    double cpu_time_used;
28

29
    // 测试用例1：明显的礼貌数
30
    printf("测试1: 明显的礼貌数\n");
31
    result = IsPoliteNumber(9); // 9 = 4+5 或 2+3+4
32
    printf("  输入: 9\n");
33
    printf("  预期: 1\n");
34
    printf("  实际: %d\n", result);
35
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
36

37
    if (result == 1) pass_count++;
38
    total_count++;
39

40
    // 测试用例2：2的幂次方（非礼貌数）
41
    printf("\n测试2: 2的幂次方（非礼貌数）\n");
42
    result = IsPoliteNumber(8); // 8 = 2^3
43
    printf("  输入: 8\n");
44
    printf("  预期: 0\n");
45
    printf("  实际: %d\n", result);
46
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
47

48
    if (result == 0) pass_count++;
49
    total_count++;
50

51
    // 测试用例3：边界值1
52
    printf("\n测试3: 边界值1\n");
53
    result = IsPoliteNumber(1);
54
    printf("  输入: 1\n");
55
    printf("  预期: 0（不能表示为两个或更多连续正整数之和）\n");
56
    printf("  实际: %d\n", result);
57
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
58

59
    if (result == 0) pass_count++;
60
    total_count++;
61

62
    // 测试用例4：边界值3
63
    printf("\n测试4: 边界值3\n");
64
    result = IsPoliteNumber(3);
65
    printf("  输入: 3\n");
66
    printf("  预期: 1（3=1+2）\n");
67
    printf("  实际: %d\n", result);
68
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
69

70
    if (result == 1) pass_count++;
71
    total_count++;
72

73
    // 测试用例5：较大的礼貌数
74
    printf("\n测试5: 较大的礼貌数\n");
75
    result = IsPoliteNumber(15); // 15=7+8 或 4+5+6 或 1+2+3+4+5
76
    printf("  输入: 15\n");
77
    printf("  预期: 1\n");
78
    printf("  实际: %d\n", result);
79
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
80

81
    if (result == 1) pass_count++;
82
    total_count++;
83

84
    // 测试用例6：质数（通常是礼貌数，除了2）
85
    printf("\n测试6: 质数（礼貌数）\n");
86
    result = IsPoliteNumber(7); // 7=3+4
87
    printf("  输入: 7\n");
88
    printf("  预期: 1\n");
89
    printf("  实际: %d\n", result);
90
    printf("  结果: %s\n", result == 1 ? "通过" : "失败");
91

92
    if (result == 1) pass_count++;
93
    total_count++;
94

95
    // 测试用例7：较大的2的幂次方
96
    printf("\n测试7: 较大的2的幂次方\n");
97
    result = IsPoliteNumber(32); // 32=2^5
98
    printf("  输入: 32\n");
99
    printf("  预期: 0\n");
100
    printf("  实际: %d\n", result);
101
    printf("  结果: %s\n", result == 0 ? "通过" : "失败");
102

103
    if (result == 0) pass_count++;
104
    total_count++;
105

106
    // 测试用例8：大数测试 - 礼貌数
107
    printf("\n测试8: 大数测试 - 礼貌数\n");
108
    start = clock();
109
    result = IsPoliteNumber(1000000); // 1000000是礼貌数
110
    end = clock();
111
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC * 1000; // 转换为毫秒
112

113
    printf("  输入: 1000000\n");
114
    printf("  预期: 1\n");
115
    printf("  实际: %d\n", result);
116
    printf("  运行时间: %.2f 毫秒\n", cpu_time_used);
117

118
    // 检查结果和运行时间
119
    int time_check = (cpu_time_used > 0.1); // 运行时间应大于0.1毫秒
120
    int result_check = (result == 1);
121

122
    if (result_check && time_check)
123
    {
124
        printf("  结果: 通过（结果正确且使用了循环）\n");
125
        pass_count++;
126
    }
127
    else if (result_check && !time_check)
128
    {
129
        printf("  结果: 失败（结果正确但运行时间过短，可能使用了直接判断）\n");
130
    }
131
    else
132
    {
133
        printf("  结果: 失败（结果错误）\n");
134
    }
135
    total_count++;
136

137
    // 测试用例9：大数测试 - 非礼貌数
138
    printf("\n测试9: 大数测试 - 非礼貌数\n");
139
    start = clock();
140
    result = IsPoliteNumber(1048576); // 1048576=2^20，不是礼貌数
141
    end = clock();
142
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC * 1000; // 转换为毫秒
143

144
    printf("  输入: 1048576\n");
145
    printf("  预期: 0\n");
146
    printf("  实际: %d\n", result);
147
    printf("  运行时间: %.2f 毫秒\n", cpu_time_used);
148

149
    // 检查结果和运行时间
150
    time_check = (cpu_time_used > 0.1); // 运行时间应大于0.1毫秒
151
    result_check = (result == 0);
152

153
    if (result_check && time_check)
154
    {
155
        printf("  结果: 通过（结果正确且使用了循环）\n");
156
        pass_count++;
157
    }
158
    else if (result_check && !time_check)
159
    {
160
        printf("  结果: 失败（结果正确但运行时间过短，可能使用了直接判断）\n");
161
    }
162
    else
163
    {
164
        printf("  结果: 失败（结果错误）\n");
165
    }
166
    total_count++;
167

168
    // 汇总结果
169
    printf("\n=== 测试结果 ===\n");
170
    printf("通过: %d/%d (%.1f%%)\n", pass_count, total_count,
171
           (float)pass_count / total_count * 100);
172

173
    if (pass_count == total_count)
174
    {
175
        printf("所有测试通过！\n");
176
    }
177
    else
178
    {
179
        printf("有 %d 个测试失败\n", total_count - pass_count);
180
    }
181

182
    // 特别说明
183
    if (pass_count >= 7 && pass_count < total_count)
184
    {
185
        printf("\n注意：部分测试失败可能是因为使用了直接判断方法（检查2的幂次方）。\n");
186
        printf("本题要求必须使用循环实现，请检查您的实现方法。\n");
187
    }
188
}
189

190
int IsPoliteNumber(int n)
191
{
192
    int test = n, sum = 0;
193
    for (int i = 1; i <= test; i++)
194
    {
195
        for (int j = i; j < test; j++)
196
        {
197
            sum += j;
198
            if (sum == test)
199
            {
200
                return 1;
201
            }
202
            else if (sum > test)
203
            {
204
                break;
205
            }
206
        }
207
        sum = 0;
208
    }
209
    return 0;
210
}

TestMatrixTranspose.c#

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
// 函数原型声明
5
int** TransMat(int** matrix, int m, int n);
6
int** CreateMatrix(int m, int n);
7
void FreeMatrix(int** matrix, int m);
8
void PrintMatrix(int** matrix, int m, int n);
9
int CompareMatrices(int** mat1, int m1, int n1, int** mat2, int m2, int n2);
10
void RunTests();
11

12
int main()
13
{
14
    RunTests();
15
    printf("\n测试完成，按任意键退出...");
16
    getchar();
17
    return 0;
18
}
19

20
// 创建指定大小的矩阵并填充测试数据
21
int** CreateMatrix(int m, int n)
22
{
23
    if (m <= 0 || n <= 0) return NULL;
24

25
    int** matrix = (int**)malloc(m * sizeof(int*));
26
    if (matrix == NULL) return NULL;
27

28
    for (int i = 0; i < m; i++)
29
    {
30
        matrix[i] = (int*)malloc(n * sizeof(int));
31
        if (matrix[i] == NULL)
32
        {
33
            // 分配失败，释放已分配的内存
34
            for (int j = 0; j < i; j++)
35
            {
36
                free(matrix[j]);
37
            }
38
            free(matrix);
39
            return NULL;
40
        }
41

42
        // 填充测试数据：matrix[i][j] = i * n + j + 1
43
        for (int j = 0; j < n; j++)
44
        {
45
            matrix[i][j] = i * n + j + 1;
46
        }
47
    }
48

49
    return matrix;
50
}
51

52
// 释放矩阵内存
53
void FreeMatrix(int** matrix, int m)
54
{
55
    if (matrix == NULL) return;
56

57
    for (int i = 0; i < m; i++)
58
    {
59
        free(matrix[i]);
60
    }
61
    free(matrix);
62
}
63

64
// 打印矩阵
65
void PrintMatrix(int** matrix, int m, int n)
66
{
67
    if (matrix == NULL)
68
    {
69
        printf("矩阵为空\n");
70
        return;
71
    }
72

73
    for (int i = 0; i < m; i++)
74
    {
75
        for (int j = 0; j < n; j++)
76
        {
77
            printf("%4d", matrix[i][j]);
78
        }
79
        printf("\n");
80
    }
81
}
82

83
// 比较两个矩阵是否相等
84
int CompareMatrices(int** mat1, int m1, int n1, int** mat2, int m2, int n2)
85
{
86
    if (m1 != m2 || n1 != n2) return 0;
87
    if (mat1 == NULL || mat2 == NULL) return 0;
88

89
    for (int i = 0; i < m1; i++)
90
    {
91
        for (int j = 0; j < n1; j++)
92
        {
93
            if (mat1[i][j] != mat2[i][j])
94
            {
95
                return 0;
96
            }
97
        }
98
    }
99
    return 1;
100
}
101

102
// 测试函数
103
void RunTests()
104
{
105
    printf("=== 矩阵转置函数测试 ===\n\n");
106

107
    int pass_count = 0;
108
    int total_count = 0;
109

110
    // 测试用例1：2x3矩阵转置
111
    printf("测试1: 2x3矩阵转置\n");
112
    int** original1 = CreateMatrix(2, 3);
113
    printf("原始矩阵(2x3):\n");
114
    PrintMatrix(original1, 2, 3);
115

116
    int** result1 = TransMat(original1, 2, 3);
117
    printf("转置结果(3x2):\n");
118
    PrintMatrix(result1, 3, 2);
119

120
    // 验证结果：创建期望的转置矩阵
121
    int** expected1 = CreateMatrix(3, 2);
122
    if (expected1 != NULL)
123
    {
124
        expected1[0][0] = 1; expected1[0][1] = 4;
125
        expected1[1][0] = 2; expected1[1][1] = 5;
126
        expected1[2][0] = 3; expected1[2][1] = 6;
127
    }
128

129
    int test1_pass = CompareMatrices(result1, 3, 2, expected1, 3, 2);
130
    printf("结果: %s\n\n", test1_pass ? "通过" : "失败");
131

132
    if (test1_pass) pass_count++;
133
    total_count++;
134

135
    // 释放内存
136
    FreeMatrix(original1, 2);
137
    FreeMatrix(result1, 3);
138
    FreeMatrix(expected1, 3);
139

140
    // 测试用例2：1x1矩阵转置
141
    printf("测试2: 1x1矩阵转置\n");
142
    int** original2 = CreateMatrix(1, 1);
143
    printf("原始矩阵(1x1):\n");
144
    PrintMatrix(original2, 1, 1);
145

146
    int** result2 = TransMat(original2, 1, 1);
147
    printf("转置结果(1x1):\n");
148
    PrintMatrix(result2, 1, 1);
149

150
    int test2_pass = (result2 != NULL) && (result2[0][0] == original2[0][0]);
151
    printf("结果: %s\n\n", test2_pass ? "通过" : "失败");
152

153
    if (test2_pass) pass_count++;
154
    total_count++;
155

156
    // 释放内存
157
    FreeMatrix(original2, 1);
158
    FreeMatrix(result2, 1);
159

160
    // 测试用例3：3x1矩阵转置（列向量）
161
    printf("测试3: 3x1矩阵转置（列向量）\n");
162
    int** original3 = CreateMatrix(3, 1);
163
    printf("原始矩阵(3x1):\n");
164
    PrintMatrix(original3, 3, 1);
165

166
    int** result3 = TransMat(original3, 3, 1);
167
    printf("转置结果(1x3):\n");
168
    PrintMatrix(result3, 1, 3);
169

170
    // 验证结果
171
    int test3_pass = 1;
172
    if (result3 != NULL)
173
    {
174
        test3_pass = (result3[0][0] == 1) && (result3[0][1] == 2) && (result3[0][2] == 3);
175
    }
176
    else
177
    {
178
        test3_pass = 0;
179
    }
180
    printf("结果: %s\n\n", test3_pass ? "通过" : "失败");
181

182
    if (test3_pass) pass_count++;
183
    total_count++;
184

185
    // 释放内存
186
    FreeMatrix(original3, 3);
187
    FreeMatrix(result3, 1);
188

189
    // 测试用例4：1x4矩阵转置（行向量）
190
    printf("测试4: 1x4矩阵转置（行向量）\n");
191
    int** original4 = CreateMatrix(1, 4);
192
    printf("原始矩阵(1x4):\n");
193
    PrintMatrix(original4, 1, 4);
194

195
    int** result4 = TransMat(original4, 1, 4);
196
    printf("转置结果(4x1):\n");
197
    PrintMatrix(result4, 4, 1);
198

199
    // 验证结果
200
    int test4_pass = 1;
201
    if (result4 != NULL)
202
    {
203
        test4_pass = (result4[0][0] == 1) && (result4[1][0] == 2) &&
204
                     (result4[2][0] == 3) && (result4[3][0] == 4);
205
    }
206
    else
207
    {
208
        test4_pass = 0;
209
    }
210
    printf("结果: %s\n\n", test4_pass ? "通过" : "失败");
211

212
    if (test4_pass) pass_count++;
213
    total_count++;
214

215
    // 释放内存
216
    FreeMatrix(original4, 1);
217
    FreeMatrix(result4, 4);
218

219
    // 测试用例5：方阵转置（3x3）
220
    printf("测试5: 3x3方阵转置\n");
221
    int** original5 = CreateMatrix(3, 3);
222
    printf("原始矩阵(3x3):\n");
223
    PrintMatrix(original5, 3, 3);
224

225
    int** result5 = TransMat(original5, 3, 3);
226
    printf("转置结果(3x3):\n");
227
    PrintMatrix(result5, 3, 3);
228

229
    // 验证方阵转置：对角线不变，其他元素对称交换
230
    int test5_pass = 1;
231
    if (result5 != NULL)
232
    {
233
        for (int i = 0; i < 3; i++)
234
        {
235
            for (int j = 0; j < 3; j++)
236
            {
237
                if (result5[i][j] != original5[j][i])
238
                {
239
                    test5_pass = 0;
240
                    break;
241
                }
242
            }
243
            if (!test5_pass) break;
244
        }
245
    }
246
    else
247
    {
248
        test5_pass = 0;
249
    }
250
    printf("结果: %s\n\n", test5_pass ? "通过" : "失败");
251

252
    if (test5_pass) pass_count++;
253
    total_count++;
254

255
    // 释放内存
256
    FreeMatrix(original5, 3);
257
    FreeMatrix(result5, 3);
258

259
    // 汇总结果
260
    printf("=== 测试结果汇总 ===\n");
261
    printf("通过测试: %d/%d\n", pass_count, total_count);
262
    printf("成功率: %.1f%%\n", (float)pass_count / total_count * 100);
263

264
    if (pass_count == total_count)
265
    {
266
        printf("🎉 所有测试通过！\n");
267
    }
268
    else
269
    {
270
        printf("❌ 有 %d 个测试失败\n", total_count - pass_count);
271
    }
272
}
273

274
int** TransMat(int** matrix, int m, int n)
275
{
276
    int **arr;
277
    arr = (int **)malloc(n * sizeof(int *));
278
    for(int i = 0; i < n; i++)
279
    {
280
        arr[i] = (int *)malloc(m * sizeof(int));
281
        if(arr[i] == NULL)
282
            return NULL;
283
        for(int j = 0; j < m; j++)
284
        {
285
            arr[i][j] = matrix[j][i];
286
        }
287
    }
288
    return arr;
289
}

Lovely HuTao!

2025.12.02 C语言程序设计上机实习五

2025.12.02 C语言程序设计上机实习五#

必做题#

选做题#

题目1：字符串查找函数#

题目2：字符串替换函数#

题目3：回文单词检测函数#

题目4：礼貌数判断函数（被放弃的期中考试题）#

题目5：矩阵转置函数#

附：完整代码#

TestFindSubstr.c#

TestReplaceAll.c#

TestPalindromeWord.c#

TestPoliteNumber.c#

TestMatrixTranspose.c#

文章分享

目录