js让用什么CHS

在 ACM 模式的机试，允许使用的标准库函数通常取决于具体的规则。不过，一般来说，以下是常用的一些标准库函数，它们通常是允许使用的：

标准输入输出函数

• scanf
• printf
• gets（不推荐使用，容易引发缓冲区溢出问题）
• fgets
• puts
• putchar
• getchar

字符串处理函数

• strlen
• strcmp
• strncmp
• strcpy
• strncpy
• strcat
• strncat
• strstr
• strchr
• strrchr

内存分配函数

• malloc
• calloc
• realloc
• free

数学函数

• abs
• fabs
• ceil
• floor
• sqrt
• pow
• exp
• log
• log10
• sin
• cos
• tan
• asin
• acos
• atan
• atan2
• hypot

排序和搜索函数

• qsort
• bsearch

时间函数

• time
• clock
• difftime
• mktime

其他常用函数

• exit
• atoi
• atol
• atof
• sprintf
• sscanf
• memcpy
• memmove
• memcmp
• memset

请注意，在比赛中使用标准库函数时，请务必确认它们是否在比赛规则允许的范围内。不同的比赛可能有不同的规定，一些比赛可能会限制某些函数的使用。

C语言中的这些函数

• scanf
• printf
• gets（不推荐使用，容易引发缓冲区溢出问题）
• fgets
• puts
• putchar
• getchar

主要用于输入和输出操作，它们在数据结构的处理中扮演着重要的角色，尤其是在与用户交互或显示数据时。下面我会逐一介绍每个函数，并提供一些简单的示例来说明它们在数据结构中的应用。

### 1. `scanf` 和 `printf`
`scanf` 函数用于从标准输入（通常是键盘）读取格式化的输入。它常用于获取用户输入的数据，这些数据可以是基本数据类型或者是结构体中的字段。`printf` 函数则用于向标凈输出（通常是屏幕）打印格式化的输出。

**示例**：假设我们有一个学生数据结构，我们可以使用 `scanf` 和 `printf` 来读取和显示学生信息。
```c
#include <stdio.h>

typedef struct {
    char name[50];
    int age;
    float gpa;
} Student;

int main() {
    Student s;
    printf("Enter name, age and GPA: ");
    scanf("%49s %d %f", s.name, &s.age, &s.gpa); // 注意%s的使用，限制长度为49
    printf("Student: %s, Age: %d, GPA: %.2f\n", s.name, s.age, s.gpa);
    return 0;
}
```

### 2. `fgets` 和 `puts`
`fgets` 函数用于从文件或标准输入读取一行文本，直到遇到换行符或达到指定的字符数。它比 `gets` 安全，因为可以指定缓冲区的最大长度，避免溢出。`puts` 函数用于输出一个字符串，然后自动添加一个换行符。

**示例**：使用 `fgets` 读取一行文本，并使用 `puts` 打印出来。
```c
#include <stdio.h>

int main() {
    char str[100];
    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // 从stdin读取最多99个字符
    puts("You entered: ");
    puts(str);
    return 0;
}
```

### 3. `putchar` 和 `getchar`
`putchar` 函数用于输出单个字符，而 `getchar` 用于从标准输入读取单个字符。

**示例**：复制输入到输出直到遇到EOF（文件结束标志）。
```c
#include <stdio.h>

int main() {
    int c;
    printf("Enter text (Ctrl+D to stop): ");
    while ((c = getchar()) != EOF) {
        putchar(c);
    }
    return 0;
}
```

通过上述函数和示例，你可以看到这些基本的输入输出函数在处理数据结构时是如何使用的。这些操作是任何数据处理程序的基础，尤其是需要与用户进行交互的应用程序。

在C语言中，处理字符串是非常常见的任务，而字符串本身可以视为一种简单的数据结构——字符数组。下面我会逐一介绍你提到的字符串处理函数，并提供一些实际示例，以展示它们在数据结构中的应用。

### 1. `strlen`
`strlen` 函数用于计算字符串的长度，不包括结尾的空字符（`\0`）。

**示例**：计算一个字符串的长度。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, world!";
    printf("Length of '%s' is %lu.\n", str, strlen(str));
    return 0;
}
```

### 2. `strcmp` 和 `strncmp`
`strcmp` 函数比较两个字符串，如果相等返回0，如果第一个字符串小于第二个字符串返回负数，反之返回正数。`strncmp` 功能类似，但它只比较前n个字符。

**示例**：比较两个字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello";
    char str2[] = "World";
    printf("strcmp(str1, str2) = %d\n", strcmp(str1, str2));
    printf("strncmp(str1, str2, 3) = %d\n", strncmp(str1, str2, 3));
    return 0;
}
```

### 3. `strcpy` 和 `strncpy`
`strcpy` 函数用于将一个字符串复制到另一个字符串中，`strncpy` 类似但可以指定最大复制字符数，提供了缓冲区溢出的保护。

**示例**：复制字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Hello";
    char dest[10];
    strcpy(dest, src);
    printf("Copied string: %s\n", dest);
    
    char dest2[10];
    strncpy(dest2, src, sizeof(dest2));
    dest2[9] = '\0';  // 确保字符串以null终止
    printf("Safely copied string: %s\n", dest2);
    return 0;
}
```

### 4. `strcat` 和 `strncat`
`strcat` 函数用于连接两个字符串，将第二个字符串追加到第一个字符串的末尾。`strncat` 功能相同，但可以指定最大追加字符数。

**示例**：连接两个字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[20] = "Hello, ";
    char str2[] = "world!";
    strcat(str1, str2);
    printf("Concatenated string: %s\n", str1);
    
    char str3[20] = "Hello, ";
    strncat(str3, str2, 3);
    printf("Partially concatenated string: %s\n", str3);
    return 0;
}
```

### 5. `strstr`, `strchr`, 和 `strrchr`
`strstr` 函数查找一个字符串在另一个字符串中的第一次出现。`strchr` 和 `strrchr` 查找字符在字符串中的第一次和最后一次出现位置。

**示例**：查找子字符串和字符。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, world!";
    char *sub = strstr(str, "world");
    if (sub) printf("Substring found: %s\n", sub);
    
    char *ch = strchr(str, 'o');
    if (ch) printf("First 'o' found at position: %ld\n", ch - str);
    
    char *rch = strrchr(str, 'o');
    if (rch) printf("Last 'o' found at position: %ld\n", rch - str);
    return 0;
}
```

这些函数是C语言中处理字符串和字符数组的基础，了解和掌握它们对于进行有效的数据处理是非常重要的。

在C语言中，处理字符串是非常常见的任务，而字符串本身可以视为一种简单的数据结构——字符数组。下面我会逐一介绍你提到的字符串处理函数，并提供一些实际示例，以展示它们在数据结构中的应用。

### 1. `strlen`
`strlen` 函数用于计算字符串的长度，不包括结尾的空字符（`\0`）。

**示例**：计算一个字符串的长度。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, world!";
    printf("Length of '%s' is %lu.\n", str, strlen(str));
    return 0;
}
```

### 2. `strcmp` 和 `strncmp`
`strcmp` 函数比较两个字符串，如果相等返回0，如果第一个字符串小于第二个字符串返回负数，反之返回正数。`strncmp` 功能类似，但它只比较前n个字符。

**示例**：比较两个字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello";
    char str2[] = "World";
    printf("strcmp(str1, str2) = %d\n", strcmp(str1, str2));
    printf("strncmp(str1, str2, 3) = %d\n", strncmp(str1, str2, 3));
    return 0;
}
```

### 3. `strcpy` 和 `strncpy`
`strcpy` 函数用于将一个字符串复制到另一个字符串中，`strncpy` 类似但可以指定最大复制字符数，提供了缓冲区溢出的保护。

**示例**：复制字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Hello";
    char dest[10];
    strcpy(dest, src);
    printf("Copied string: %s\n", dest);
    
    char dest2[10];
    strncpy(dest2, src, sizeof(dest2));
    dest2[9] = '\0';  // 确保字符串以null终止
    printf("Safely copied string: %s\n", dest2);
    return 0;
}
```

### 4. `strcat` 和 `strncat`
`strcat` 函数用于连接两个字符串，将第二个字符串追加到第一个字符串的末尾。`strncat` 功能相同，但可以指定最大追加字符数。

**示例**：连接两个字符串。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[20] = "Hello, ";
    char str2[] = "world!";
    strcat(str1, str2);
    printf("Concatenated string: %s\n", str1);
    
    char str3[20] = "Hello, ";
    strncat(str3, str2, 3);
    printf("Partially concatenated string: %s\n", str3);
    return 0;
}
```

### 5. `strstr`, `strchr`, 和 `strrchr`
`strstr` 函数查找一个字符串在另一个字符串中的第一次出现。`strchr` 和 `strrchr` 查找字符在字符串中的第一次和最后一次出现位置。

**示例**：查找子字符串和字符。
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, world!";
    char *sub = strstr(str, "world");
    if (sub) printf("Substring found: %s\n", sub);
    
    char *ch = strchr(str, 'o');
    if (ch) printf("First 'o' found at position: %ld\n", ch - str);
    
    char *rch = strrchr(str, 'o');
    if (rch) printf("Last 'o' found at position: %ld\n", rch - str);
    return 0;
}
```

这些函数是C语言中处理字符串和字符数组的基础，了解和掌握它们对于进行有效的数据处理是非常重要的。

在C语言中，`malloc`, `calloc`, `realloc`, 和 `free` 是与动态内存管理相关的函数。理解和正确使用这些函数对于开发复杂的数据结构和避免内存泄漏非常关键。下面我会逐一介绍这些函数，并通过实际示例展示它们在数据结构中的应用。

### 1. `malloc`
`malloc`（Memory Allocation 的缩写）函数用于分配指定大小的内存块。它返回一个指向分配的内存的指针，如果分配失败则返回NULL。

**示例**：使用 `malloc` 为一个整数数组分配内存。
```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n = 5;  // 假设我们需要一个有5个元素的数组
    arr = (int*)malloc(n * sizeof(int));  // 为5个整数分配内存

    if (arr != NULL) {
        for (int i = 0; i < n; i++) {
            arr[i] = i * i;  // 初始化数组
        }

        for (int i = 0; i < n; i++) {
            printf("%d ", arr[i]);  // 输出数组
        }
        free(arr);  // 释放分配的内存
    } else {
        printf("Memory allocation failed\n");
    }

    return 0;
}
```

### 2. `calloc`
`calloc`（Contiguous Allocation 的缩写）函数与 `malloc` 类似，也是用于分配内存。不同之处在于，`calloc` 为分配的内存自动初始化为零，并且它接受两个参数：元素数量和每个元素的大小。

**示例**：使用 `calloc` 为一个整数数组分配并初始化内存。
```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n = 5;
    arr = (int*)calloc(n, sizeof(int));  // 为5个整数分配内存并初始化为0

    if (arr != NULL) {
        for (int i = 0; i < n; i++) {
            printf("%d ", arr[i]);  // 输出数组，应该都是0
        }
        free(arr);  // 释放分配的内存
    } else {
        printf("Memory allocation failed\n");
    }

    return 0;
}
```

### 3. `realloc`
`realloc`（Re-allocation 的缩写）函数用于调整已经分配的内存块的大小。它接受两个参数：一个指向已经分配的内存的指针和一个新的大小。

**示例**：扩展或缩减前面分配的数组的大小。
```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int*)malloc(5 * sizeof(int));  // 最初分配5个整数
    if (arr != NULL) {
        for (int i = 0; i < 5; i++) {
            arr[i] = i;
        }

        int *temp = (int*)realloc(arr, 10 * sizeof(int));  // 将数组大小增加到10
        if (temp != NULL) {
            arr = temp;
            for (int i = 5; i < 10; i++) {
                arr[i] = i;
            }

            for (int i = 0; i < 10; i++) {
                printf("%d ", arr[i]);
            }
            free(arr);
        } else {
            free(arr);
            printf("Re-allocation failed\n");
        }
    } else {
        printf("Initial memory allocation failed\n");
    }

    return 0;
}
```

在C语言中，`free` 函数确实用于释放之前通过 `malloc`, `calloc`, 或 `realloc` 函数分配的内存。正确地使用 `free` 函数是防止内存泄漏的关键步骤。内存泄漏发生在程序中已分配的内存没有被释放，从而导致随着程序的运行时间越长，系统的可用内存越来越少。这可能导致程序或者整个系统运行缓慢甚至崩溃。

下面是一个示例，说明了如何使用 `malloc` 和 `free` 来管理内存，以避免内存泄漏：

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配内存
    int *arr = (int*)malloc(10 * sizeof(int));  // 为10个整数分配内存

    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;  // 如果内存分配失败，退出程序
    }

    // 使用内存
    for (int i = 0; i < 10; i++) {
        arr[i] = i * i;
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放内存
    free(arr);
    arr = NULL;  // 将指针设置为NULL，避免野指针

    return 0;
}
```

在这个例子中，我们首先通过 `malloc` 函数分配了一块足够存储10个整数的内存。然后，我们使用这块内存存储整数，并最终通过 `free` 函数释放这块内存。在释放内存后，我们将指针设置为 `NULL`，这是一个良好的编程实践，可以帮助避免所谓的“野指针”问题（指针指向了无效的内存区域）。这样做可以在尝试解引用或再次释放已释放的内存时防止程序错误。

每次使用完通过 `malloc`, `calloc`, 或 `realloc` 分配的内存后，都应该用 `free` 释放它，并考虑将指针设为 `NULL`，这是防止内存泄漏和其他内存错误的重要措施。

在C语言中，`qsort` 和 `bsearch` 是两个非常实用的库函数，分别用于排序和二分查找。这些函数可以大大简化对各种数据结构（如数组）的处理过程。下面我会分别介绍这两个函数的用法，并提供相应的示例。

### 1. `qsort`
`qsort`（快速排序）函数用于对数组进行排序。它需要四个参数：指向数组首元素的指针、数组中元素的数量、每个元素的大小以及一个比较函数，用来决定排序的顺序。

**比较函数** 应该接受两个 `const void*` 类型的参数（指向数组中两个元素的指针），返回一个整数来表示这两个元素的相对顺序（小于、等于或大于）。

**示例**：使用 `qsort` 对一个整数数组进行排序。
```c
#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    const int *ia = (const int *)a;
    const int *ib = (const int *)b;
    return (*ia > *ib) - (*ia < *ib);
}

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

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

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

    return 0;
}
```
在这个例子中，`qsort` 使用提供的 `compare` 函数来确定数组中元素的排序顺序。

### 2. `bsearch`
`bsearch`（二分查找）函数用于在已排序的数组中查找特定的元素。它需要五个参数：一个指向要查找的元素的指针、一个指向数组首元素的指针、数组中的元素数量、每个元素的大小以及一个比较函数。

**比较函数** 的要求与 `qsort` 相同，用于比较查找的元素和数组中的元素。

**示例**：在排序后的数组中使用 `bsearch` 查找一个元素。
```c
#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    const int *ia = (const int *)a;
    const int *ib = (const int *)b;
    return (*ia > *ib) - (*ia < *ib);
}

int main() {
    int arr[] = {1, 2, 5, 5, 6, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 5;
    int *result = (int *)bsearch(&key, arr, n, sizeof(int), compare);

    if (result) {
        printf("Found %d at index %ld\n", *result, (result - arr));
    } else {
        printf("Did not find %d\n", key);
    }

    return 0;
}
```
这里，`bsearch` 在数组中搜索键值 `5`。如果找到，它会返回指向该元素的指针；如果没有找到，返回 `NULL`。

在C语言中，处理时间和日期是常见需求，尤其在需要执行定时任务、测量代码执行时间、或进行时间日期计算时。标准C库提供了一些函数来帮助管理和计算时间。这些包括 `time`, `clock`, `difftime`, 和 `mktime`。下面我会分别解释这些函数，并提供示例来展示它们在数据结构和程序中的应用。

### 1. `time`
`time` 函数用于获取当前时间，返回自1970年1月1日（UTC）以来经过的秒数，通常称为Unix时间戳。

**示例**：获取当前时间并打印。
```c
#include <stdio.h>
#include <time.h>

int main() {
    time_t now;
    time(&now);
    printf("Current time in seconds since the Epoch: %ld\n", now);

    return 0;
}
```

### 2. `clock`
`clock` 函数提供了程序执行的处理器时间，这不是实际的墙钟时间，而是CPU花费在程序上的时间。这个函数非常适合测量代码片段的执行时间。

**示例**：测量代码执行时间。
```c
#include <stdio.h>
#include <time.h>

int main() {
    clock_t start, end;
    double cpu_time_used;

    start = clock();
    // 执行一些操作
    for (int i = 0; i < 10000000; i++) {
        // 一个简单的循环
    }
    end = clock();

    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("The loop took %f seconds to execute.\n", cpu_time_used);

    return 0;
}
```

### 3. `difftime`
`difftime` 函数用来计算两个时间点之间的差异（秒）。这对于计算时间间隔非常有用。

**示例**：计算两个时间点之间的差异。
```c
#include <stdio.h>
#include <time.h>

int main() {
    time_t start, end;
    double diff;

    time(&start);
    // 假设这里有一些耗时的操作
    sleep(3);  // 使程序暂停3秒
    time(&end);

    diff = difftime(end, start);
    printf("Operation took %f seconds.\n", diff);

    return 0;
}
```

### 4. `mktime`
`mktime` 函数用于将 `struct tm` 结构（表示本地时间的结构）转换为自Unix时代以来的秒数。这可以用于创建特定的时间点或对日期进行计算。

**示例**：创建特定的时间点并转换为时间戳。
```c
#include <stdio.h>
#include <time.h>

int main() {
    struct tm t;
    time_t t_of_day;

    t.tm_year = 2022 - 1900;  // 年份从1900年开始计数
    t.tm_mon = 6;             // 月份从0开始计数，6表示7月
    t.tm_mday = 14;           // 日期
    t.tm_hour = 12;
    t.tm_min = 0;
    t.tm_sec = 0;
    t.tm_isdst = -1;          // 自动检测夏令时

    t_of_day = mktime(&t);
    printf("Specified time in seconds since the Epoch: %ld\n", t_of_day);

    return 0;
}
```

在C语言中

• exit
• atoi
• atol
• atof
• sprintf
• sscanf
• memcpy
• memmove
• memcmp
• memse

这些函数属于标准库的一部分，涵盖了程序控制、字符串和内存操作等多个方面。下面，我将逐一介绍每个函数，并提供实际示例，帮助你理解它们在数据结构和程序中的应用。

### 1. `exit`
`exit` 函数用于立即结束程序，并返回一个状态码给操作系统。通常用于程序中遇到无法恢复的错误时。

**示例**：
```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    printf("Performing an operation...\n");
    // 在某些条件下，决定退出程序
    exit(EXIT_FAILURE);  // 使用标准宏EXIT_FAILURE指示失败
}
```

### 2. `atoi`, `atol`, `atof`
这些函数用于将字符串转换为整数(`atoi`), 长整数(`atol`), 和浮点数(`atof`)。

**示例**：
```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    char *intStr = "123";
    char *longStr = "1234567890123";
    char *floatStr = "123.456";

    int i = atoi(intStr);
    long l = atol(longStr);
    double f = atof(floatStr);

    printf("int: %d, long: %ld, double: %f\n", i, l, f);
    return 0;
}
```

### 3. `sprintf`, `sscanf`
- `sprintf` 将格式化的数据写入字符串。
- `sscanf` 从字符串读取格式化的数据。

**示例**：
```c
#include <stdio.h>

int main() {
    char buffer[100];
    int age = 23;
    double height = 5.9;

    // 将格式化的文本写入buffer
    sprintf(buffer, "Age: %d, Height: %.1f", age, height);
    printf("Formatted String: %s\n", buffer);

    // 从字符串读取数据
    int readAge;
    double readHeight;
    sscanf(buffer, "Age: %d, Height: %lf", &readAge, &readHeight);
    printf("Read Age: %d, Read Height: %f\n", readAge, readHeight);
    return 0;
}
```

### 4. `memcpy`, `memmove`
- `memcpy` 用于复制内存区域。
- `memmove` 与 `memcpy` 类似，但正确处理源和目标内存区域重叠的情况。

**示例**：
```c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello World";
    char str2[20];
    char str3[20];

    // 复制字符串
    memcpy(str2, str1, strlen(str1) + 1);
    printf("Copied using memcpy: %s\n", str2);

    // 故意重叠内存以演示memmove
    memmove(str1 + 6, str1 + 5, 6);
    printf("Result of memmove (overlap handled): %s\n", str1);

    return 0;
}
```

### 5. `memcmp`, `memset`
- `memcmp` 比较两块内存区域。
- `memset` 用于将一块内存设置为特定的字节。

**示例**：
```c
#include <stdio.h>
#include <string.h>

int main() {
    char buffer1[] = "abc";
    char buffer2[] = "abc";
    char buffer3[] = "abd";

    // 比较内存
    printf("memcmp(buffer1, buffer2): %d\n", memcmp(buffer1, buffer2, 3));  // 0
    printf("memcmp(buffer1, buffer3): %d\n", memcmp(buffer1, buffer3, 3));  // 负数，因为'c' < 'd'

    // 设置内存
    memset(buffer1, 'x', 3);
    printf("buffer1 after memset: %s\n", buffer1);  // xxx

    return 0;
}
```