【C语言上机考试易忘知识汇总】

爱康代码2025-03-28 19:22

上机考试易忘知识汇总

一、第一弹

1.1二次方程根

1.2 打印菱形

重点：通过变化的I来实现控制空格和*的个数

1.3 string.h之sscanf

c 复制代码 
#include <string.h>

        sscanf(input, "%d%c%d=%c", &a, &op, &b, &c);

1.4 三个基础排序

c 复制代码 
//简单选择排序
void selectionSort(int arr[], int n) {
    int i, j, min_idx, temp;
    for (i = 0; i < n - 1; i++) {
        min_idx = i;
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

// 直接插入排序函数
void insertionSort(int arr[], int n) {
    int i, j, key;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        // 将大于key的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

//冒泡排序
void bubbleSort(int arr[], int n){
	int i,j,temp;
	for(i=0;i<n-1;i++){
		for(j=0;j<n-i-1;j++){
			if(arr[j]>arr[j+1]){
			   temp=arr[j],arr[j]=arr[j+1],arr[j+1]=temp;
			}
		}
	}
}

1.5 动态分配二维数组malloc

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

    int m, n;
    scanf("%d %d", &m, &n);
    
    // 动态分配二维数组的内存
    int **matrix = (int **)malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        matrix[i] = (int *)malloc(n * sizeof(int));
    }
    
    // 释放动态分配的内存
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);

1.6 一特定字符(#)结束

c 复制代码 
//以一个'#'结束的字符串
    int i = 0;
    char ch[101];
    while ((ch[i] = getchar()) != '#') {
        if (ch[i] >= 'a' && ch[i] <= 'z') {
            ch[i] -= 32;
        }
        if (ch[i] >= 'A' && ch[i] <= 'Z') {
            ch[i] += 32;
        }
        i++;
    }

1.7 字符串的插入

注意：

1.注意下标=位置-1

2.先把插入位置及后面元素后移，再插入🎈

c 复制代码 
#include <stdio.h>
#include <string.h>

    int pos;
    scanf("%d", &pos);
    //改为物理索引
    pos--;
    // 拼接字符串
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    //先把pos后的元素后移
    for (int i = len1; i >= pos; i--) {
        str1[i + len2] = str1[i];
    }
    //插入
    for (int i = 0; i < len2; i++)
        str1[pos + i] = str2[i];

1.8字符串的删除

注意：数组的删除其实就是后面元素覆盖前面元素

c 复制代码 
        if (found) { //如果found为1则代表匹配到了子串
            //用后面部分覆盖子串
            for (int i = start + subLen; i < len; i++) {
                str[i - subLen] = str[i];
            }
            //注意要减少原串的长度
            len = len - subLen;
        }

1.9字符串的匹配

c 复制代码 
   while(start <= len - subLen) {
        //比较是否有匹配的字串
        int found = 1;
        for (int i = 0; i < subLen; i++) {
            if (str[start + i] != subStr[i]) {
                found = 0;
                break;
            }
        }
        if (found) {
        //说明匹配到了
        }
        else
            start++;
    }

二、第二弹几个数学知识

2.1最大公约数

辗转相除法

c 复制代码 
//保证a比b大
//辗转相除法
int gcd2(int a, int b){
    int remainder = a % b;
    while(remainder != 0){ //余数不为0时结束
        a = b;
        b = remainder;
        remainder = a % b;
    }
    return b;
}
//普通搜索方法求最大公约数
int gcd1(int a, int b){
    //初始化认为最大公约数就是a,b之中较小的那个
    int result = a < b ? a : b;
    //暴力往前搜素，第一个符合条件的就是最大公约数
    while(result > 0) {
        if(a % result == 0 && b % result == 0){
            return result;
        }
        result--;
    }
}

//辗转相除法递归
int gcd3(int m, int n){
    if(n == 0)
        return m;
    else
        return gcd3(n, m % n);
}

2.2 最小公倍数

记住公式就好了

c 复制代码 
  // 利用公式：最小公倍数 = (m * n) / 最大公约数
    int lcm = (m * n) / gcd(m, n);

2.3斐波那契

c 复制代码 
//递归斐波那契数列
int fb(int n) {
    if(n==1||n==2){
		return 1;
	}
	return fb(n-1)+fb(n-2);
}

2.4n的阶乘

c 复制代码 
int factorial(int n) {
    if (n == 0) {  //注意0的阶乘是1！
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

三、第三弹自定义数据结构

3.1 定义一个结构体

c 复制代码 
//定义100个学生结构体变量
struct Student {
    char name[11];
    char gender[11];
    int age;
    char student_id[11];
};  //别忘了这里的分号！
struct Student students[n];

3.2 定义一个共用体

c 复制代码 
union Data {
    int intData;
    double doubleData;
    char charData;
};
union Data myData;

3.3 定义一个枚举

c 复制代码 
// 定义枚举类型表示不同颜色
enum Color {
    RED=1,
    GREEN,
    BLUE
};  //注意里面是逗号

enum Color selectedColor

3.4 链表

创建头节点:

c 复制代码 
LinkList* createLinkedList(int arr[], int n) {
    LinkList *head = (LinkList*)malloc(sizeof(LinkList));
    head->next = NULL;
    LinkList *cur = head;
    for (int i = 0; i < n; i++) { // 遍历数组，创建链表节点并串接起来
        LinkList *newNode = (LinkList*)malloc(sizeof(LinkList));
        newNode->data = arr[i];
        newNode->next = NULL;
        cur->next = newNode;
        cur = newNode;
    }
    return head;
}

四、第四弹C语言直接能用的函数

4.1 文件中的函数

c 复制代码 
#include <stdio.h>

int main() {
    // 读取刚才创建的文件
    FILE* input_1 = fopen("input_1.txt", "r");
    if (input_1 == NULL) {
        return 0;
    }
    // 创建文件（拷贝目标）
    FILE* output_1 = fopen("output_1.txt", "w");
    if (output_1 == NULL) {  // 这里原代码判断条件错误，应为output_1，修正后抄写
        return 0;
    }
    // 开始操作
    char ch = 0;
    while (1) {
        // 复制
        ch = fgetc(input_1);
        if (ch == EOF)
            break;
        // 粘贴
        fputc(ch, output_1);
    }
    // 关闭文件
    fclose(input_1);
    fclose(output_1);
    return 0;
}

C语言上机考试文件常用函数总结📚

🌟文件打开与关闭

  • fopen()

    作用：以指定模式打开文件～

    用法：FILE *fopen(const char *filename, const char *mode)

    ✨mode常用："r"（读）、"w"（写，覆盖）、"a"（追加）

    返回：成功给文件指针，失败NULL！

  • fclose()

    作用：关闭打开的文件，防数据丢失～

    用法：int fclose(FILE *stream)

    返回：成功0，失败非0！

🌟字符读写

  • fgetc()

    从文件读一个字符，返回字符，失败/末尾-1（EOF）～

    用法：int fgetc(FILE *fp)

  • fputc()

    往文件写一个字符，成功返字符，失败EOF～

    用法：int fputc(int ch, FILE *fp)

🌟字符串读写

  • fgets()

    读字符串到数组，最多num-1字符，自动加\0～

    用法：char *fgets(char *str, int num, FILE *fp)

  • fputs()

    写字符串到文件（不带\0），成功非负，失败EOF～

    用法：int fputs(const char *str, FILE *stream)

🌟格式化读写

  • fscanf()

    按格式从文件读数据，返回成功读取数～

    用法：int fscanf(FILE *stream, const char *format, ...)

  • fprintf()

    按格式写数据到文件，成功返写入字符数，失败负～

    用法：int fprintf(FILE *stream, const char *format, ...)

🌟数据块读写

  • fread()

    读数据块，返回实际读的项数～

    用法：size_t fread(void *buffer, size_t size, size_t count, FILE *fp)

  • fwrite()

    写数据块，返回实际写的项数～

    用法：size_t fwrite(const void *buffer, size_t size, size_t count, FILE *fp)

🌟文件定位

  • fseek()

    移动文件指针，成功0，失败非0～

    用法：int fseek(FILE *fp, long offset, int origin)

    （origin：SEEK_SET开头，SEEK_CUR当前，SEEK_END末尾）

  • rewind()

    一键把文件指针复位到开头～

    用法：void rewind(FILE *fp)

  • ftell()

    查当前指针位置，距开头字节数，错返-1L～

    用法：long ftell(FILE *fp)

备考C语言上机考，这些函数多练多记💪

4.2 C语言string.h常用上机函数总结✨

string.h头文件中的函数那可是相当关键！下面就给大家好好总结一波常用的函数😎

🌟字符串长度计算

  • strlen()
    作用：计算字符串的长度，不包含字符串结束符\0。
    用法：size_t strlen(const char *s)
    注意：时间复杂度是 O ( n ) O(n) O(n)，需要遍历到\0才停止。

🌟字符串复制

  • strcpy()
    作用：把一个字符串完整地复制到另一个字符串中。
    用法：char *strcpy(char *dest, const char *src)
    注意：要保证目标字符串有足够的空间，不然会导致缓冲区溢出。
  • strncpy()
    作用：最多复制指定数量的字符到目标字符串。
    用法：char *strncpy(char *dest, const char *src, size_t n)
    注意：如果源字符串长度小于n，会用\0填充，但不会自动添加\0。

🌟字符串拼接

  • strcat()
    作用：把一个字符串拼接到另一个字符串的末尾。
    用法：char *strcat(char *dest, const char *src)
    注意：目标字符串必须以\0结尾，且要有足够空间。
  • strncat()
    作用：最多拼接指定数量的字符到目标字符串末尾，会自动添加\0。
    用法：char *strncat(char *dest, const char *src, size_t n)

🌟字符串比较

  • strcmp()
    作用：比较两个字符串的字典序。
    用法：int strcmp(const char *s1, const char *s2)
    返回值：小于 0 表示s1小于s2；等于 0 表示相等；大于 0 表示s1大于s2。
    注意：区分大小写，按 ASCII 码比较。
  • strncmp()
    作用：比较两个字符串的前n个字符的字典序。
    用法：int strncmp(const char *s1, const char *s2, size_t n)

🌟字符查找

  • strchr()
    作用：查找字符在字符串中第一次出现的位置。
    用法：char *strchr(const char *s, int c)
    返回：找到返回对应地址，没找到返回NULL。
  • strrchr()
    作用：查找字符在字符串中最后一次出现的位置。
    用法：char *strrchr(const char *s, int c)
    返回：找到返回对应地址，没找到返回NULL。

举例：

c 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    // 定义一个字符串
    char str[] = "Hello, World!";
    // 要查找的字符
    char ch = 'o';
    // 使用 strchr() 函数查找字符
    char *result = strchr(str, ch);

    if (result != NULL) {
        printf("字符 '%c' 首次出现在字符串中的位置是: %ld\n", ch, result - str);
    } else {
        printf("字符 '%c' 未在字符串中找到。\n", ch);
    }

    return 0;
}

🌟子串查找

  • strstr()
    作用：在一个字符串中查找另一个子字符串第一次出现的位置。
    用法：char *strstr(const char *haystack, const char *needle)
    返回：找到返回对应地址，没找到返回NULL。
c 复制代码 
#include <stdio.h>
#include <string.h>

int main() {
    // 定义主字符串
    char mainStr[] = "This is a sample string for testing.";
    // 定义要查找的子字符串
    char subStr[] = "sample";
    // 使用 strstr() 函数查找子字符串
    char *result = strstr(mainStr, subStr);

    if (result != NULL) {
        printf("子字符串 \"%s\" 首次出现在主字符串中的位置是: %ld\n", subStr, result - mainStr);
    } else {
        printf("子字符串 \"%s\" 未在主字符串中找到。\n", subStr);
    }

    return 0;
}

4.3 qsort函数

复制代码 
`qsort`是C语言标准库中的一个用于对数据进行排序的函数，功能强大且灵活，可以对不同类型的数据（如数组、结构体等）进行排序。以下是它的详细用法：

1. 函数原型

c 复制代码 
void qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));
  • base：指向要排序的数组的首元素指针。
  • num：表示数组中元素的个数。
  • size：每个元素的大小，以字节为单位，可以使用sizeof运算符获取。
  • compar：指向比较函数的指针，该函数用于确定两个元素的顺序，由用户自定义。

2. 比较函数compar的写法

比较函数compar的原型为int (*compar)(const void *, const void *)，它接受两个const void *类型的参数，分别指向要比较的两个元素，返回值决定了两个元素的顺序：

  • 返回值小于0：表示第一个元素应该排在第二个元素之前。
  • 返回值等于0：表示两个元素相等，它们的相对位置可以保持不变。
  • 返回值大于0：表示第一个元素应该排在第二个元素之后。

3. 常见使用场景及示例代码

（1）对整数数组排序
c 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 比较函数，升序排序
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    qsort(arr, n, sizeof(int), compare);

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

上述代码中，compare函数将const void *类型的参数强制转换为int *类型，然后进行比较，返回值使得qsort按照升序对整数数组arr进行排序。

（2）对字符串数组排序
c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 比较函数，按字典序升序排序字符串
int compare(const void *a, const void *b) {
    return strcmp(*(char **)a, *(char **)b);
}

int main() {
    char *strs[] = {"apple", "banana", "cherry"};
    int n = sizeof(strs) / sizeof(strs[0]);

    qsort(strs, n, sizeof(char *), compare);

    for (int i = 0; i < n; i++) {
        printf("%s ", strs[i]);
    }
    return 0;
}

这里因为要排序的是字符串数组，即指针数组，所以在compare函数中，先将const void *类型的参数转换为char **类型，再使用strcmp函数来比较两个字符串，实现按字典序升序排序。

（3）对结构体数组排序
c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义结构体
typedef struct {
    int id;
    char name[20];
} Student;

// 比较函数，按id升序排序
int compare(const void *a, const void *b) {
    return ((Student *)a)->id - ((Student *)b)->id;
}

int main() {
    Student students[] = { {3, "Tom"}, {1, "Alice"}, {2, "Bob"} };
    int n = sizeof(students) / sizeof(students[0]);

    qsort(students, n, sizeof(Student), compare);

    for (int i = 0; i < n; i++) {
        printf("id: %d, name: %s\n", students[i].id, students[i].name);
    }
    return 0;
}

此例中，定义了Student结构体，在compare函数里将参数转换为Student *类型，通过比较结构体中的id成员来确定元素顺序，使qsort对结构体数组按id升序排序。

4. 注意事项

  • 使用qsort函数需要包含头文件stdlib.h。
  • 比较函数必须保证具有一致性，即对于任意的a、b和c，若compare(a, b)返回值和compare(b, c)返回值确定了相应顺序关系，那么compare(a, c)的返回值也要符合这种传递性。
  • 由于qsort的参数base和比较函数中的参数都是void *类型，使用时需要进行适当的类型转换。

4.4 🎈数学函数

在C语言中，数学函数由标准库math.h提供，使用时需包含头文件#include <math.h>，编译时通常要加上参数-lm（表示链接至数学函数库） 。以下是一些常见的数学函数：

1. 绝对值函数

  • abs ：原型为int abs(int x)，用于计算整数x的绝对值，例如abs(-5)返回5。
  • labs ：原型为long labs(long x)，用于计算长整数x的绝对值，如labs(-10L)返回10L。
  • fabs ：原型为double fabs(double x)，用于计算实数（浮点数）x的绝对值，比如fabs(-3.14)返回3.14。

2. 幂函数与指数函数

  • pow ：原型是double pow(double x, double y)，用于计算x的y次方，如pow(2, 3)返回8.0。
  • exp ：原型为double exp(double x)，用于计算自然常数e的x次方，例如exp(1)返回e的近似值。

3. 对数函数

  • log ：原型是double log(double x) ，用于计算x的自然对数（以e为底），要求x > 0，如log(exp(2))返回2.0。
  • log10 ：原型为double log10(double x)，用于计算x以10为底的对数，同样要求x > 0 ，例如log10(100)返回2.0。

4. 开方函数

  • sqrt ：原型是double sqrt(double x)，用于计算x的平方根，要求x >= 0，如sqrt(9)返回3.0。

5. 三角函数

  • sin ：原型为double sin(double x)，计算x的正弦值，其中x的单位是弧度，例如sin(0)返回0.0。
  • cos ：原型是double cos(double x)，计算x的余弦值，x为弧度制，如cos(0)返回1.0。
  • tan ：原型为double tan(double x)，计算x的正切值，x以弧度为单位 ，比如tan(0)返回0.0。
  • asin ：原型是double asin(double x)，计算x的反正弦函数值，x的值需在(-1, 1)之间，返回值在(-π/2, π/2)之间。
  • acos ：原型为double acos(double x)，计算x的反余弦函数值，x取值范围是(-1, 1)，返回值在(0, π)之间。
  • atan ：原型是double atan(double x)，计算x的反正切函数值，返回值在(-π/2, π/2)之间。
  • atan2 ：原型为double atan2(double y, double x)，计算y/x的反正切函数值，返回值在(-π, π)之间。

6. 取整函数

  • ceil ：原型为double ceil(double x)，返回不小于x的最小整数，结果类型为double，如ceil(3.1)返回4.0。
  • floor ：原型是double floor(double x)，返回不大于x的最大整数，结果类型为double，例如floor(3.9)返回3.0。
    、
相关推荐
wen__xvn11 分钟前
Codeforces Round 1014 (Div. 2)2092A - Kamilka and the Sheep c++
开发语言·c++·算法
梁下轻语的秋缘20 分钟前
每日c/c++题 备战蓝桥杯（全排列问题）
c++·算法·蓝桥杯·深度优先
AredRabbit31 分钟前
vector＜int＞ 的用法
c++·算法·vector
pilgrim5337 分钟前
【二刷代码随想录】双指针-数组相关题型、推荐习题
java·数据结构·算法·leetcode
好好学习^按时吃饭1 小时前
P4551 最长异或路径
算法·深度优先·图论
爱补鱼的猫猫1 小时前
模型压缩（量化、剪枝、蒸馏、低秩分解）
算法·机器学习·剪枝
代码骑士1 小时前
聚类（Clustering）基础知识3
算法·支持向量机·聚类
梦姐的编程日志1 小时前
从研究动机视角对无监督图像去雾论文的分类
图像处理·人工智能·深度学习·算法·计算机视觉
Y1nhl1 小时前
搜广推校招面经六十二
人工智能·pytorch·python·算法·机器学习·推荐算法·搜索算法
蓝白咖啡2 小时前
华为OD机试 - 王者荣耀匹配机制 - 回溯（Java 2024 D卷 200分）
java·python·算法·华为od·机试
热门推荐
01HTML项目一键打包工具：HTML2EXE 最新版02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04【笔记】MJ Prompt05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07PyTorch量化技术教程：第四章 PyTorch在量化交易中的应用08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10RAG生成中的多文档动态融合及去重加权策略探讨