教程标签: C语言

👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

2024-08-10发表2024-08-10更新编程 / C进阶7 分钟读完 (大约1020个字)

在文件操作中，除了使用 fopen 和 fclose 进行文件的打开和关闭外，fgetc、fputc、fread 以及 fwrite 是非常重要的输入输出函数，它们允许我们以不同的方式读取和写入数据。接下来我们将深入探讨这些函数的用法，并通过案例澄清它们之间的区别和应用场景。

fgetc 和 fputc

fgetc 和 fputc 分别用于字符的读取和写入。这两个函数的使用场景通常是需要以字符为单位操作文本文件。

fgetc 函数

fgetc 函数从指定的文件流中读取下一个字符并返回。其函数原型如下：

1	int fgetc(FILE *stream);

stream: 指向打开的文件的指针。

使用案例

以下是一个使用 fgetc 读取文本文件内容的简单示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Failed to open file");
        return 1;
    }

    int ch;
    while ((ch = fgetc(file)) != EOF) {
        putchar(ch); // 输出到控制台
    }

    fclose(file);
    return 0;
}

在这个示例中，程序从 example.txt 文件中逐字符读取内容，并将其打印到控制台。fgetc 函数返回 EOF（文件结束标志）时停止读取。

fputc 函数

fputc 函数向指定的文件流写入一个字符。其函数原型如下：

1	int fputc(int char, FILE *stream);

char: 要写入的字符（以整型形式提供）。
stream: 指向打开的文件的指针。

使用案例

以下是一个使用 fputc 写入字符到文本文件的示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("output.txt", "w");
    if (file == NULL) {
        perror("Failed to create file");
        return 1;
    }

    const char *str = "Hello, World!";
    while (*str) {
        fputc(*str++, file);
    }

    fclose(file);
    return 0;
}

这个示例将在 output.txt 文件中逐字符写入字符串 "Hello, World!"。

fread 和 fwrite

fread 和 fwrite 函数用于以块的形式读写数据，这在处理二进制文件或大型数据时尤为高效。

fread 函数

fread 函数从文件中读取多个对象。其函数原型如下：

1	size_t fread(void ptr, size_t size, size_t count, FILE stream);

ptr: 指向存储读取数据的缓冲区的指针。
size: 每个对象的字节大小。
count: 要读取的对象数量。
stream: 指向打开的文件的指针。

使用案例

以下是一个使用 fread 读取二进制文件的示例：

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

typedef struct {
    int id;
    char name[20];
} Student;

int main() {
    FILE *file = fopen("students.bin", "rb");
    if (file == NULL) {
        perror("Failed to open file");
        return 1;
    }

    Student students[10];
    size_t read_count = fread(students, sizeof(Student), 10, file);
    for (size_t i = 0; i < read_count; i++) {
        printf("ID: %d, Name: %s\n", students[i].id, students[i].name);
    }

    fclose(file);
    return 0;
}

在这个例子中，程序从 students.bin 文件中读取最多 10 个学生记录，并打印其 ID 和姓名。

fwrite 函数

fwrite 函数用于将多个对象写入文件。其函数原型如下：

1	size_t fwrite(const void ptr, size_t size, size_t count, FILE stream);

ptr: 指向要写入的对象的指针。
size: 每个对象的字节大小。
count: 要写入的对象数量。
stream: 指向打开的文件的指针。

使用案例

以下是一个使用 fwrite 写入二进制文件的示例：

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

typedef struct {
    int id;
    char name[20];
} Student;

int main() {
    FILE *file = fopen("students.bin", "wb");
    if (file == NULL) {
        perror("Failed to create file");
        return 1;
    }

    Student students[2] = {
        {1, "Alice"},
        {2, "Bob"}
    };

    fwrite(students, sizeof(Student), 2, file);
    fclose(file);
    return 0;
}

在这个示例中，程序将两个学生记录以二进制格式写入 students.bin 文件。

小结

通过 fgetc 和 fputc 我们可以方便地处理文本文件中的字符，而 fread 和 fwrite 则为我们提供了高效的二进制数据读写方式。选择合适的函数并理解其工作原理，能够帮助我们在不同的场景下更有效地进行文件操作。

在下一篇中，我们将讨论文件定位与缓冲，这将进一步让我们了解如何在文件中进行随意读取和写入。

分享转发

2024-08-10发表2024-08-10更新编程 / C小白5 分钟读完 (大约739个字)

13 运算符与表达式之关系运算符

在C语言中，关系运算符主要用于比较两个表达式的值。它们的结果是一个布尔值，表示比较的结果是“真”还是“假”。关系运算符通常用于控制流语句中，例如if、while等，以决定程序执行的路径。

关系运算符一览

C语言中主要有以下几种关系运算符：

== : 等于运算符
!= : 不等于运算符
> : 大于运算符
< : 小于运算符
>= : 大于等于运算符
<= : 小于等于运算符

每一个运算符都是用来比较两个操作数的，结果返回 1（真）或 0（假）。

运算符优先级

关系运算符的优先级较低，通常在算术运算符之后。例如，在表达式中，如果同时包含算术运算符和关系运算符，算术运算符会优先计算。

示例：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 20;

    // 这里，a + b 会先计算，结果是 30
    if (a + b > 25) {
        printf("a + b 大于 25\n");
    } else {
        printf("a + b 小于或等于 25\n");
    }

    return 0;
}

在这个例子中，首先计算 a + b 的值，然后将其与 25 进行比较。

具体案例分析

使用`==`和`!=`运算符

==运算符用于检查两个值是否相等，而!=则用于检查它们是否不相等。

示例：

#include <stdio.h>

int main() {
    int x = 5;
    
    if (x == 5) {
        printf("x等于5\n");
    }
    
    if (x != 10) {
        printf("x不等于10\n");
    }

    return 0;
}

在这个代码中，x == 5的条件为真，因此将打印“x等于5”。而x != 10也为真，因此将打印“x不等于10”。

使用`>`和`<`运算符

>和<运算符用于比较两个值的大小关系。

示例：

#include <stdio.h>

int main() {
    int a = 15;
    int b = 10;

    if (a > b) {
        printf("a大于b\n");
    }
    
    if (b < a) {
        printf("b小于a\n");
    }

    return 0;
}

在这个例子中，a > b和b < a都为真，因此将分别打印“a大于b”和“b小于a”。

使用`>=`和`<=`运算符

>=和<=运算符则用于判断一个值是否大于等于或小于等于另一个值。

示例：

#include <stdio.h>

int main() {
    int score = 90;

    if (score >= 60) {
        printf("成绩及格\n");
    } else {
        printf("成绩不及格\n");
    }

    return 0;
}

在这个例子中，score >= 60为真，因此将打印“成绩及格”。

小结

关系运算符在C语言中是非常重要的，它们帮助我们进行各种条件判断。在使用时，需要注意其优先级以及如何组合与其他运算符的使用。理解关系运算符的工作原理，可以帮助我们更好地控制程序的逻辑流。

接下来，我们将进入运算符与表达式之逻辑运算符的主题，探讨如何利用逻辑运算符进行更复杂的条件判断。

分享转发

2024-08-10发表2024-08-10更新编程 / C进阶7 分钟读完 (大约1105个字)

14 文件操作之文件定位与缓冲

在 C 语言的文件操作中，文件定位和缓冲是两个非常重要的概念。它们直接影响着文件的读写效率和程序的执行效率。本节将深入探讨如何在文件中进行定位，以及缓冲机制的工作原理。

文件定位

文件定位涉及到如何在打开的文件中移动文件指针。C 语言为文件定位提供了一些标准函数，最常用的函数是 fseek()、ftell() 和 rewind()。

1. `fseek()`

fseek() 函数用于移动文件指针到指定的位置。其函数原型如下：

1	int fseek(FILE *stream, long offset, int whence);

stream：文件指针。
offset：要移动的字节数。
whence：基准位置，可以是：
- SEEK_SET：从文件头开始。
- SEEK_CUR：从当前位置开始。
- SEEK_END：从文件末尾开始。

示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    // 移动到文件开始位置
    fseek(file, 10, SEEK_SET);
    // 获取当前位置
    long pos = ftell(file);
    printf("Current position: %ld\n", pos);

    // 移动到文件末尾
    fseek(file, 0, SEEK_END);
    pos = ftell(file);
    printf("End position: %ld\n", pos);

    fclose(file);
    return 0;
}

在上面的例子中，我们打开一个文件并移动文件指针到第 10 个字节的位置，然后打印当前指针位置，接着我们将指针移动到文件末尾并输出其位置。

2. `ftell()`

ftell() 函数用于获取当前文件指针的位置，其原型如下：

1	long ftell(FILE *stream);

它返回当前文件指针的字节偏移量。如果出错，返回 -1。

3. `rewind()`

rewind() 函数用于将文件指针移动到文件开头，其原型如下：

1	void rewind(FILE *stream);

与 fseek() 不同，rewind() 不需要偏移参数。

示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    // 读取文件的前10个字节
    char buffer[11];
    fread(buffer, 1, 10, file);
    buffer[10] = '\0'; // 添加字符串结束符
    printf("Read first 10 bytes: %s\n", buffer);

    // 重置文件指针
    rewind(file);

    // 读取文件的前10个字节
    fread(buffer, 1, 10, file);
    printf("Read first 10 bytes again: %s\n", buffer);

    fclose(file);
    return 0;
}

总结文件定位

使用 fseek() 可以灵活控制文件指针的位置。
ftell() 用于获取当前指针位置，而 rewind() 用于返回文件开头。
文件定位在处理大文件、随机访问数据时非常有用。

文件缓冲

文件缓冲是一种提高 I/O 性能的机制。C 语言的 stdio.h 提供了缓冲文件的功能，允许 C 语言在内存中临时存储数据，从而减少对磁盘的访问次数。

缓冲类型

C 语言中的文件指针可以是三种缓冲模式之一：

全缓冲（Fully Buffered）：在进行大块数据 I/O 时，数据会先被存储到一个大缓冲区中，直至缓冲区满后再写入到磁盘。
行缓冲（Line Buffered）：输出缓冲会在每次遇到换行符时或者缓冲区满时写入数据。
无缓冲（Unbuffered）：每次 I/O 操作都直接访问磁盘，不使用缓冲区。

函数 `setvbuf()`

setvbuf() 函数用来设置文件流的缓冲模式，其原型如下：

1	int setvbuf(FILE stream, char buf, int mode, size_t size);

buf：自定义缓冲区，如果为 NULL，则使用系统默认缓冲区。
mode：指定缓冲模式，可以是 _IOFBF（全缓冲）、_IOLBF（行缓冲）和 _IONBF（无缓冲）。
size：缓冲区的大小。

示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "w");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    // 设置全缓冲
    char buffer[1024];
    setvbuf(file, buffer, _IOFBF, sizeof(buffer));

    // 写入数据
    fprintf(file, "Hello, World!\n");
    fprintf(file, "This is a test...\n");

    fclose(file);
    return 0;
}

结论

文件定位和缓冲是 C 语言文件操作中不可或缺的部分。合理地利用 fseek()、ftell()、rewind() 可以让我们高效地处理文件。而理解缓冲机制能够极大地提升 I/O 性能，尤其是在处理大量数据时。接下来的内容将会探讨如何处理文本与二进制文件，为你在文件操作的进一步探索打下基础。

分享转发

2024-08-10发表2024-08-10更新编程 / C小白5 分钟读完 (大约787个字)

14 运算符与表达式之逻辑运算符

在前一篇中，我们介绍了关系运算符，它们用于比较两个操作数的大小关系，并返回布尔值（true或false）。本篇将进一步讲解逻辑运算符，它们在控制程序流和条件判断中发挥着重要作用。逻辑运算符的主要员工是连接多个布尔表达式，以产生单一的布尔结果。我们将了解三种主要的逻辑运算符：&&（逻辑与），||（逻辑或）和!（逻辑非）。

逻辑与：`&&`

逻辑与运算符（&&）会在两个条件都为真时返回真。换句话说，只有当两个条件都为true时，结果才为true。如果任一条件为false，结果则为false。

示例

#include <stdio.h>

int main() {
    int a = 5, b = 10;
    
    // 判断条件
    if (a < 10 && b > 5) {
        printf("条件成立：a 小于 10 并且 b 大于 5\n");
    } else {
        printf("条件不成立\n");
    }
    
    return 0;
}

在上述代码中，当a小于10且b大于5时，控制台将输出“条件成立”。如果我们将b改变为2，结果将为“条件不成立”。

逻辑或：`||`

逻辑或运算符（||）在至少一个条件为真时返回真。只要其中一个条件为true，结果就为true，仅在所有条件都为false时结果才为false。

示例

#include <stdio.h>

int main() {
    int a = 5, b = 10;
    
    // 判断条件
    if (a > 10 || b > 5) {
        printf("条件成立：a 大于 10 或者 b 大于 5\n");
    } else {
        printf("条件不成立\n");
    }
    
    return 0;
}

在这个例子中，由于b大于5，控制台将输出“条件成立”。即使a不大于10，只要满足任一条件就可以。

逻辑非：`!`

逻辑非运算符（!）用于反转布尔值。如果条件为真，使用逻辑非将更改为假；反之亦然。

示例

#include <stdio.h>

int main() {
    int a = 5;
    
    // 判断条件
    if (!(a > 10)) {
        printf("条件成立：a 不大于 10\n");
    } else {
        printf("条件不成立\n");
    }
    
    return 0;
}

在这里，!(a > 10)的结果为true，因为a确实不大于10，因此控制台输出“条件成立”。

逻辑运算符的结合使用

逻辑运算符可以结合使用来构建复杂的条件判断。

示例

#include <stdio.h>

int main() {
    int a = 5, b = 10, c = 15;
    
    // 判断多个条件
    if ((a < 10 && b > 5) || (c > 20 && a > 0)) {
        printf("条件成立：至少一个复杂条件为真\n");
    } else {
        printf("条件不成立\n");
    }
    
    return 0;
}

在这个示例中，尽管c > 20为false，但由于第一个条件(a < 10 && b > 5)为true，因此整个条件表达式评估为true，控制台输出“条件成立”。

总结

逻辑运算符在条件判断和控制流程中非常重要。通过使用逻辑与&&、逻辑或||和逻辑非!，我们可以构建复杂的逻辑条件，控制程序的执行路径。

在下一篇文章中，我们将探讨位运算符，了解如何直接操作数据的二进制位。

分享转发

2024-08-10发表2024-08-10更新编程 / C进阶7 分钟读完 (大约1078个字)

15 处理文本与二进制文件的内容

在前一篇中，我们探讨了文件位置和缓冲的概念，这为接下来的文件操作打下了坚实的基础。在这一节中，我们将深入了解如何处理文本文件和二进制文件的内容，学习如何读取和写入这些文件，并举一些具体的例子来帮助理解。

文本文件和二进制文件的基本区别

在开始之前，我们首先需要了解什么是文本文件和二进制文件：

文本文件：文本文件是由可见字符组成的文件，其内容可以用任何文本编辑器（如记事本）打开和查看。文本文件使用特定的编码格式（如ASCII或UTF-8）来表示字符。
二进制文件：二进制文件包含的是原始字节数据，这些数据可能是文本、图像、音频或其他类型的信息。二进制文件通常无法用文本编辑器直接查看，因为其内容是由不可见的字节组成。

理解了这个基本概念后，我们可以更有效地进行文件内容的处理。

读取文本文件

我们可以使用 fopen 打开文本文件，使用 fgets 或 fscanf 来读取文件的内容。以下是一个读取文本文件的简单示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }
    
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s", buffer);
    }

    fclose(file);
    return 0;
}

在这个例子中，我们打开一个名为 example.txt 的文件并逐行读取其内容直到文件结束。fgets 函数安全且高效，有效地处理字符流。

写入文本文件

我们可以使用 fopen 以写模式打开文件，并使用 fprintf 或 fputs 来写入内容。以下是写入文本文件的示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("output.txt", "w");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    fprintf(file, "Hello, World!\n");
    fputs("This is a text file.\n", file);

    fclose(file);
    return 0;
}

在这个代码片段中，我们创建（或覆盖）一个名为 output.txt 的文件，并向其中写入一些文本内容。

读取二进制文件

读取二进制文件相对文本文件稍具挑战，但仍然可以通过 fopen 和 fread 来实现。以下是一个例子，展示如何读取一个二进制文件：

#include <stdio.h>

int main() {
    FILE *file = fopen("image.bin", "rb");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    unsigned char buffer[256];
    size_t bytesRead = fread(buffer, sizeof(unsigned char), sizeof(buffer), file);

    printf("Read %zu bytes from the binary file.\n", bytesRead);

    fclose(file);
    return 0;
}

在这个示例中，我们打开一个名为 image.bin 的二进制文件并读取最多 256 字节的数据。

写入二进制文件

写二进制文件的方式也类似，我们使用 fwrite 来写入数据。下面是一个写入二进制文件的示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("output.bin", "wb");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }

    unsigned char data[5] = {0, 1, 2, 3, 4};
    size_t bytesWritten = fwrite(data, sizeof(unsigned char), sizeof(data), file);

    printf("Wrote %zu bytes to the binary file.\n", bytesWritten);

    fclose(file);
    return 0;
}

在这段代码中，我们创建了一个名为 output.bin 的二进制文件，并将一个字节数组写入到该文件中。

结论

到此为止，我们详细探讨了如何处理文本和二进制文件的内容，包括读取和写入的基本操作。通过这些示例，我们可以清楚地看到，在 C 语言中进行文件操作是相对直接的，但需要注意文件的打开模式（文本模式或二进制模式）和读取、写入函数的使用。

在下一节中，我们将开始讨论数据结构与算法的基础，特别是数组与链表。这将为我们在程序设计中管理数据奠定基础，同时也实现更复杂的操作。希望大家能在文件操作中取得进一步的理解，并准备好迎接下一个重要主题的挑战！

分享转发

2024-08-10发表2024-08-10更新编程 / C小白7 分钟读完 (大约1023个字)

15 运算符与表达式之位运算符

在上一篇中，我们讨论了逻辑运算符的相关知识，学习了如何使用这些运算符进行更加复杂的条件判断。在本篇中，我们将继续深入运算符与表达式的主题，重点介绍位运算符。位运算符是在处理二进制数据时非常有用的工具，理解它们将帮助我们更高效地进行数据操作。

位运算符简介

位运算符主要用于处理二进制位，可以直接对整数的二进制表示进行操作。C语言中的位运算符有以下几种：

按位与（&）
按位或（|）
按位异或（^）
按位取反（~）
左移（<<）
右移（>>）

接下来，我们将逐一介绍这些运算符的性质及其使用方法。

1. 按位与 `&`

按位与运算符对两个整数的每一位进行比较，仅当对应的两位均为1时，结果的该位才为1，其余情况结果的该位为0。

示例：

1
2
3

int a = 5;   // 二进制表示为 0101
int b = 3;   // 二进制表示为 0011
int result = a & b; // 结果为 0001，即十进制的1

2. 按位或 `|`

按位或运算符会对两个整数的每一位进行比较，只要对应的任意一位为1，结果的该位就为1。

示例：

1
2
3

int a = 5;   // 二进制表示为 0101
int b = 3;   // 二进制表示为 0011
int result = a | b; // 结果为 0111，即十进制的7

3. 按位异或 `^`

按位异或运算符会对两个整数的每一位进行比较，当对应的两位不同时，结果的该位为1；相同时结果的该位为0。

示例：

1
2
3

int a = 5;   // 二进制表示为 0101
int b = 3;   // 二进制表示为 0011
int result = a ^ b; // 结果为 0110，即十进制的6

4. 按位取反 `~`

按位取反运算符会将整数的每一位进行反转，即1变为0，0变为1。

示例：

1 2	int a = 5; // 二进制表示为 0101 int result = ~a; // 结果为 1010，但由于C语言使用补码表示，结果为 -6

5. 左移 `<<`

左移运算符会将一个数的二进制位向左移动指定的位数，左移后低位补零。这相当于将数值乘以2的移动位数次方。

示例：

1 2	int a = 5; // 二进制表示为 0101 int result = a << 1; // 结果为 1010，即十进制的10

6. 右移 `>>`

右移运算符会将一个数的二进制位向右移动指定的位数，具体补多少位取决于数的符号。如果是无符号数，左侧补零；如果是有符号数，则采取算术右移，符号位将被扩展。

示例：

1 2	int a = 5; // 二进制表示为 0101 int result = a >> 1; // 结果为 0010，即十进制的2

应用案例：交换两个整数的值

位运算符在实际编程中有许多独特的应用，其中之一就是不使用临时变量交换两个整数的值。我们可以利用按位异或的特性来实现这个操作：

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    // 输出交换前的值
    printf("Before swap: a = %d, b = %d\n", a, b);

    // 使用按位异或进行交换
    a = a ^ b; // 第一步：a现在是a和b的异或
    b = a ^ b; // 第二步：b现在是原始的a
    a = a ^ b; // 第三步：a现在是原始的b

    // 输出交换后的值
    printf("After swap: a = %d, b = %d\n", a, b);
    return 0;
}

小结

在这一篇中，我们详细介绍了位运算符及其使用方法，并通过示例帮助大家理解它们的运作原理。掌握这些运算符可以让我们在处理二进制数据时更加灵活和高效。

在下一篇中，我们将进入控制结构的主题，讨论顺序结构的相关知识，继续提升我们的编程能力。欢迎大家继续学习！

分享转发

2024-08-10发表2024-08-10更新编程 / C进阶6 分钟读完 (大约893个字)

16 数据结构与算法之数组与链表

在这一篇中，我们将深入探讨C语言中的数组和链表这两种基本数据结构。这些数据结构是理解更复杂算法的基础，同时也是编程中常用的工具。我们将通过案例和代码示例来帮助您更好地理解它们的使用场景和优缺点。

5.1 数组

1. 数组的基本概念

数组是一个固定大小的、连续存储的元素集合，所有元素具有相同的类型。在C语言中，可以使用以下方式定义一个数组：

1	int arr[5]; // 定义一个包含5个整数的数组

1.1 数组的特点

固定大小：数组的大小一旦定义，就不可改变。
快速访问：可以通过索引快速访问元素，时间复杂度为$O(1)$。
内存连续：存储的元素在内存中是连续的，这有助于提高缓存命中率。

1.2 数组的案例

下面是一个简单的数组使用示例，演示如何遍历和修改数组元素：

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    
    // 遍历并打印数组元素
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    // 修改数组中的一个元素
    arr[2] = 10;
    printf("After modification, arr[2] = %d\n", arr[2]);
    
    return 0;
}

2. 数组的优缺点

优点：
- 访问速度快；
- 易于实现和理解。
缺点：
- 不支持动态调整大小；
- 插入和删除操作较慢，时间复杂度为$O(n)$。

5.2 链表

3. 链表的基本概念

链表是一种动态数据结构，由一系列节点组成。每个节点包含数据部分和指向下一个节点的指针，这使得试图在概念上理解链表的结构。

3.1 链表的定义

在C语言中，您可以通过结构体定义一个链表节点：

struct Node {
    int data;
    struct Node* next;
};

3.2 单链表的案例

下面的代码展示了如何创建、插入和遍历一个简单的单链表：

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

struct Node {
    int data;
    struct Node* next;
};

// 创建一个新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 插入节点到链表头
void insertAtHead(struct Node** head_ref, int new_data) {
    struct Node* newNode = createNode(new_data);
    newNode->next = *head_ref;
    *head_ref = newNode;
}

// 打印链表
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}

int main() {
    struct Node* head = NULL;

    // 向链表插入数据
    insertAtHead(&head, 1);
    insertAtHead(&head, 2);
    insertAtHead(&head, 3);
    
    // 打印链表
    printList(head);

    return 0;
}

4. 链表的优缺点

优点：
- 动态大小：链表可以在运行时动态分配和释放内存；
- 插入和删除操作的时间复杂度为$O(1)$（在已知位置的情况下）。
缺点：
- 随机访问速度慢：访问一个元素的时间复杂度为$O(n)$；
- 需要额外的内存来存储指针。

总结

在这部分中，我们分别介绍了数组和链表两种基本数据结构。数组适合需要快速随机访问的场景，而链表则在频繁插入和删除的情况下具有优势。掌握这两种数据结构是学习更复杂数据结构和算法的基础，对后续的学习，特别是会涉及到的栈和队列等结构理解会有很大的帮助。接下来，我们将深入探讨栈与队列的相关知识。

分享转发

2024-08-10发表2024-08-10更新编程 / C小白6 分钟读完 (大约935个字)

16 控制结构之顺序结构

在C语言中，控制结构是程序流程控制的基础。顺序结构是最基本的控制结构，它指的是程序从上到下、逐行执行的过程。在此篇中，我们将深入探讨顺序结构的概念以及如何在C语言中有效地应用它。

顺序结构的概念

顺序结构是指程序的执行是按照代码的书写顺序，从头到尾一行行执行的。没有任何的条件判断或跳转。这意味着在编写程序时，代码的执行路径是线性的，且每一行代码都是依次执行的。

顺序结构的示例

下面我们将通过一个简单的示例来展示顺序结构的工作方式。

示例 1: 计算两个数的和

#include <stdio.h>

int main() {
    int a, b, sum; // 声明变量

    // 输入两个数字
    printf("请输入第一个数字: ");
    scanf("%d", &a); // 读取第一个数字

    printf("请输入第二个数字: ");
    scanf("%d", &b); // 读取第二个数字

    sum = a + b; // 计算和

    // 输出结果
    printf("两数之和为: %d\n", sum);

    return 0; // 程序结束
}

在上述示例中，程序从int main()开始执行。首先，声明了三个整数变量a、b和sum。然后，依次执行输入、计算和输出的操作。由于这些操作是线性的，因此这是一个典型的顺序结构。

顺序结构的特点

简单性: 顺序结构是最容易理解和实现的控制结构。
可预测性: 执行的步骤是固定的，程序的输出结果在给定相同的输入时是可预测的。
易于调试: 由于没有复杂的控制路径，顺序结构的程序更容易查找和修复错误。

实际应用中的顺序结构

顺序结构在许多实际应用中都非常常见。以下是一些使用顺序结构的例子：

简单的计算器: 在输入和输出之间直接进行算术运算，计算结果。
数据处理: 从输入文件中读取数据，进行处理后输出到文件。
初始化设置: 在某个设置程序中，照着预设的步骤初始化参数。

示例 2: 求平均值

下面的代码示例演示了如何使用顺序结构来求多个数字的平均值。

#include <stdio.h>

int main() {
    int num1, num2, num3;
    float average;

    // 输入三个数字
    printf("请输入第一个数字: ");
    scanf("%d", &num1);

    printf("请输入第二个数字: ");
    scanf("%d", &num2);

    printf("请输入第三个数字: ");
    scanf("%d", &num3);

    // 计算平均值
    average = (num1 + num2 + num3) / 3.0;

    // 输出平均值
    printf("三个数的平均值为: %.2f\n", average);

    return 0;
}

在这个例子中，程序顺序地输入三个数字，计算它们的平均值，并最后输出结果。各步骤依次进行，体现了顺序结构的特性。

总结

顺序结构在C语言中是程序设计的基础，它的执行方式是从上到下，逐句执行。理解顺序结构是学习其他更复杂控制结构（如选择结构和循环结构）的基础。通过简单的输入、处理及输出步骤，我们可以实现各种基本功能，为日后深入学习打下坚实的基础。

在下一篇中，我们将探讨控制结构中的选择结构，包括if和switch的应用，进一步丰富我们对流程控制的理解。

分享转发

2024-08-10发表2024-08-10更新编程 / C进阶7 分钟读完 (大约1045个字)

17 数据结构与算法之栈与队列

在上一章中，我们讨论了数组与链表，它们是最基本的数据存储结构。接下来，我们将深入探讨两个非常重要的数据结构：栈 和 队列。这两个数据结构常用于管理数据的访问顺序，为算法提供支持，尤其是在解决递归、深度优先搜索和广度优先搜索等问题时表现尤为突出。

5.2.1 栈（Stack）

栈是一种后进先出（LIFO, Last In First Out）数据结构。它的基本操作包括：

push：将一个元素压入栈顶
pop：从栈顶移除一个元素
top 或 peek：返回栈顶元素但不移除它
isEmpty：检查栈是否为空

栈的实现

在C语言中，我们可以使用数组或链表来实现栈。下面是使用数组的简单实现：

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

#define MAX_SIZE 100

typedef struct Stack {
    int top;
    int items[MAX_SIZE];
} Stack;

void init(Stack *s) {
    s->top = -1;
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

int isFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}

void push(Stack *s, int item) {
    if (isFull(s)) {
        printf("Stack Overflow!\n");
        return;
    }
    s->items[++(s->top)] = item;
}

int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack Underflow!\n");
        return -1; // 可以使用其他错误码表示栈空
    }
    return s->items[(s->top)--];
}

int peek(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is Empty!\n");
        return -1;
    }
    return s->items[s->top];
}

栈的应用

括号匹配：用于检查字符串中的括号是否匹配。
深度优先搜索（DFS）：在图或树的遍历中。
函数调用管理：编程语言中函数调用的管理经常依赖于栈。

示例：括号匹配

下面是一个简单的示例，使用栈来检查输入字符串中的括号是否匹配。

#include <stdbool.h>

bool isMatching(char opening, char closing) {
    return (opening == '(' && closing == ')') ||
           (opening == '{' && closing == '}') ||
           (opening == '[' && closing == ']');
}

bool isBalanced(const char *expr) {
    Stack s;
    init(&s);
    
    for (int i = 0; expr[i] != '\0'; i++) {
        char current = expr[i];
        if (current == '(' || current == '{' || current == '[') {
            push(&s, current);
        } else if (current == ')' || current == '}' || current == ']') {
            if (isEmpty(&s) || !isMatching(pop(&s), current)) {
                return false; // 不匹配
            }
        }
    }
    return isEmpty(&s); // 栈空则匹配，返回真
}

5.2.2 队列（Queue）

与栈相对，队列是一种先进先出（FIFO, First In First Out）数据结构。基本操作包括：

enqueue：在队列末尾添加一个元素
dequeue：从队列头部移除一个元素
front：返回队列头元素但不移除它
isEmpty：检查队列是否为空

队列的实现

我们同样可以用数组或链表实现队列。以下是使用链表的简单实现：

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct Queue {
    Node *front;
    Node *rear;
} Queue;

void initQueue(Queue *q) {
    q->front = NULL;
    q->rear = NULL;
}

int isQueueEmpty(Queue *q) {
    return q->front == NULL;
}

void enqueue(Queue *q, int item) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = item;
    newNode->next = NULL;
    
    if (q->rear) {
        q->rear->next = newNode;
    } else {
        q->front = newNode; // 队列为空时，front指向新节点
    }
    q->rear = newNode; // 更新rear指向新节点
}

int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("Queue is Empty!\n");
        return -1; // 可以使用其他错误码表示队列空
    }
    Node *temp = q->front;
    int item = temp->data;
    q->front = q->front->next;
    
    if (q->front == NULL) {
        q->rear = NULL; // 队列为空时重置rear
    }
    
    free(temp);
    return item;
}

队列的应用

任务调度：在操作系统中用于管理正在执行的任务。
广度优先搜索（BFS）：在图或树的遍历中。
缓冲区管理：用于数据流的缓冲区如打印队列。

示例：任务调度模拟

下面是一个简单的队列使用示例，用于模拟简单的任务调度。

#include <stdio.h>

void simulateTaskQueue() {
    Queue taskQueue;
    initQueue(&taskQueue);

    // 添加任务
    enqueue(&taskQueue, 1);
    enqueue(&taskQueue, 2);
    enqueue(&taskQueue, 3);
    
    // 处理任务
    while (!isQueueEmpty(&taskQueue)) {
        int task = dequeue(&taskQueue);
        printf("Processing task %d\n", task);
    }
}

总结

在本节中，我们探讨了 栈 和 队列 的基本概念、实现及其应用。理解这两种数据结构不仅有助于编写高效的代码，还能在处理复杂问题时提供更清晰的思路。接下来，我们将在下一篇中学习更复杂的数据结构：树 和 图，它们在许多实际应用中扮演着关键角色。

分享转发

2024-08-10发表2024-08-10更新编程 / C小白8 分钟读完 (大约1154个字)

17 控制结构之选择结构（if、switch）

在上一篇中，我们介绍了控制结构之顺序结构的概念与应用。顺序结构是程序执行的基础，而选择结构则允许程序根据条件的不同走不同的路径，从而实现更复杂的逻辑。这一节我们将重点讨论C语言中的选择结构，包括if语句和switch语句。

一、if语句

if语句是选择结构中最基本的形式，它用于根据条件表达式的真值来决定是否执行某段代码。if语句的基本语法结构如下：

1
2
3

if (条件表达式) {
    // 如果条件为真执行的代码
}

示例

以下是一个简单的例子，判断一个数是否为正数：

#include <stdio.h>

int main() {
    int number;
    printf("请输入一个整数: ");
    scanf("%d", &number);

    if (number > 0) {
        printf("您输入的数是正数。\n");
    }

    return 0;
}

在这个例子中，如果用户输入的 number 大于0，程序将输出“您输入的数是正数。”

if-else语句

我们可以将if语句扩展为if-else结构，以处理条件为假时的情形：

if (条件表达式) {
    // 如果条件为真执行的代码
} else {
    // 如果条件为假执行的代码
}

示例

下面的例子中，如果输入的数是负数，则输出“您输入的数是负数。”

#include <stdio.h>

int main() {
    int number;
    printf("请输入一个整数: ");
    scanf("%d", &number);

    if (number > 0) {
        printf("您输入的数是正数。\n");
    } else {
        printf("您输入的数是负数或零。\n");
    }

    return 0;
}

多重选择：if-else if-else

当需要处理多个条件时，可以使用if-else if-else结构：

if (条件表达式1) {
    // 执行代码块1
} else if (条件表达式2) {
    // 执行代码块2
} else {
    // 执行其他代码块
}

示例

以下例子将根据用户输入的数判断其是否为正数、负数或零：

#include <stdio.h>

int main() {
    int number;
    printf("请输入一个整数: ");
    scanf("%d", &number);

    if (number > 0) {
        printf("您输入的数是正数。\n");
    } else if (number < 0) {
        printf("您输入的数是负数。\n");
    } else {
        printf("您输入的数是零。\n");
    }

    return 0;
}

二、switch语句

switch语句提供了一种多分支选择的方式，相对于if语句，在处理多个条件时更为简洁明了。switch语句的基本语法如下：

switch (表达式) {
    case 常量1:
        // 处理case常量1的代码
        break;
    case 常量2:
        // 处理case常量2的代码
        break;
    ...
    default:
        // 当没有匹配到任何case时执行的代码
}

示例

下面的例子根据用户输入的数字（1-3）输出对应的文本：

#include <stdio.h>

int main() {
    int choice;
    printf("请输入一个数字 (1-3): ");
    scanf("%d", &choice);

    switch (choice) {
        case 1:
            printf("您选择了第一项。\n");
            break;
        case 2:
            printf("您选择了第二项。\n");
            break;
        case 3:
            printf("您选择了第三项。\n");
            break;
        default:
            printf("输入无效，请输入1-3之间的数字。\n");
            break;
    }

    return 0;
}

在这个例子中，程序根据用户输入的choice值输出对应文本。如果输入的值不在1到3之间，则输出“输入无效”。

注意事项

break语句用于结束switch的执行，防止继续执行后面的case。
如果多个case有相同的处理逻辑，可以合并多个case语句。

参考示例

以下是一个更复杂的示例，使用switch语句进行简单的计算器功能，支持加减乘除：

#include <stdio.h>

int main() {
    char operator;
    double num1, num2, result;

    printf("请输入两个数 (以空格分隔): ");
    scanf("%lf %lf", &num1, &num2);
    printf("请输入运算符 (+, -, *, /): ");
    scanf(" %c", &operator);

    switch (operator) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            if (num2 != 0) {
                result = num1 / num2;
            } else {
                printf("错误：除数不能为零。\n");
                return 1;
            }
            break;
        default:
            printf("无效的运算符。\n");
            return 1;
    }
    
    printf("结果: %.2lf\n", result);
    return 0;
}

小结

在本节中，我们深入探讨了C语言中的选择结构，包括了if、if-else、if-else if-else以及switch语句的基本用法和应用案例。选择结构为程序赋予了条件判断的能力，使得程序能够根据不同的输入和状态做出相应的处理。

在下一篇中，我们将继续讨论控制结构之循环结构，包括for、while和do-while语句。通过循环结构，我们可以在特定条件下重复执行代码，从而实现更复杂的逻辑运算。

分享转发

2024-08-10发表2024-08-10更新编程 / C进阶7 分钟读完 (大约1107个字)

18 数据结构与算法之树与图

在上一篇中，我们讨论了 栈 和 队列 这两种重要的数据结构。本篇将深入探讨 树 和 图，这两者在计算机科学中扮演着至关重要的角色，尤其是在表示层次结构和复杂关系时。

5.3.1 树

1. 什么是树？

树是一种非线性数据结构，由节点（nodes）和边（edges）组成。树具有以下特征：

有一个根节点（root），其他节点通过边连接。
每个节点可以有零个或多个子节点（children）。
除根节点外，每个节点都有一个唯一的父节点（parent）。
树形结构没有循环。

2. 树的基本术语

高度（Height）：从树的根节点到最叶子节点的最长路径上的边数。
深度（Depth）：从根节点到某个节点的路径长度。
叶子节点（Leaf Node）：没有子节点的节点。

3. 树的类型

二叉树（Binary Tree）：每个节点最多有两个孩子，通常称为左孩（left child）和右孩（right child）。
二叉搜索树（Binary Search Tree, BST）：左孩子的值小于父节点，右孩子的值大于父节点。
AVL树：一种自平衡的二叉搜索树，保证操作的时间复杂度为 $O(\log n)$。
红黑树：另一种自平衡的二叉搜索树，具有颜色标记的节点来保持平衡。

4. 树的基本操作

以下是一些基本操作的实现示例（以二叉树为例）：

插入节点

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

Node* insert(Node* root, int data) {
    if (root == NULL) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = data;
        newNode->left = newNode->right = NULL;
        return newNode;
    }
    if (data < root->data) {
        root->left = insert(root->left, data);
    } else {
        root->right = insert(root->right, data);
    }
    return root;
}

遍历树

树的遍历可分为前序、中序和后序遍历。

void inorder(Node* root) {
    if (root != NULL) {
        inorder(root->left);
        printf("%d ", root->data);
        inorder(root->right);
    }
}

5.3.2 图

1. 什么是图？

图是一种由节点（顶点）和连接这些节点的边构成的数据结构。图可以表示复杂的关系，并具有以下基本特征：

节点通过边连接，边可以是有向的或无向的。
一个图可以包含环（cycles），也可以是无环（如树）。

2. 图的类型

有向图（Directed Graph）：边有方向，有序对 (u, v) 表示从顶点 $u$ 到 $v$ 的一条边。
无向图（Undirected Graph）：边没有方向，连接两个顶点的边可以用无序对 {u, v} 表示。
加权图（Weighted Graph）：边上有权值，常用来表示成本或距离。

3. 图的存储方式

图一般使用两种方式存储：

邻接矩阵（Adjacency Matrix）：使用一个二维数组存储节点间的关系。
邻接链表（Adjacency List）：使用链表存储每个节点的边的信息，适合稀疏图。

邻接链表的示例

typedef struct Edge {
    int destination;
    struct Edge* next;
} Edge;

typedef struct Vertex {
    int data;
    Edge* edges;
} Vertex;

typedef struct Graph {
    int numVertices;
    Vertex* vertices;
} Graph;

4. 图的基本操作

深度优先搜索（DFS）

void DFS(Graph* graph, int vertex, int* visited) {
    visited[vertex] = 1;
    printf("%d ", graph->vertices[vertex].data);
    
    Edge* edge = graph->vertices[vertex].edges;
    while (edge != NULL) {
        if (!visited[edge->destination]) {
            DFS(graph, edge->destination, visited);
        }
        edge = edge->next;
    }
}

广度优先搜索（BFS）

void BFS(Graph* graph, int startVertex) {
    Queue* queue = createQueue();
    int* visited = (int*)malloc(graph->numVertices * sizeof(int));
    memset(visited, 0, graph->numVertices * sizeof(int));

    enqueue(queue, startVertex);
    visited[startVertex] = 1;
    
    while (!isEmpty(queue)) {
        int currentVertex = dequeue(queue);
        printf("%d ", graph->vertices[currentVertex].data);

        Edge* edge = graph->vertices[currentVertex].edges;
        while (edge != NULL) {
            if (!visited[edge->destination]) {
                enqueue(queue, edge->destination);
                visited[edge->destination] = 1;
            }
            edge = edge->next;
        }
    }
}

5. 总结

本篇介绍了 树 和 图 两种重要的数据结构，讲解了它们的基本概念、操作及实现示例。树结构适合表示层级关系，而图结构则用于表示更为复杂的连接关系。在实际应用中，选择合适的数据结构是提升程序性能和可维护性的关键。

接下来，我们将进入经典算法的实现部分，这将帮助加深理解数据结构在解决问题中的应用，以及如何优化算法效率。

分享转发

2024-08-10发表2024-08-10更新编程 / C小白5 分钟读完 (大约758个字)

18 控制结构之循环结构

在上篇中，我们探讨了控制结构的选择结构，包括 if 和 switch，这些结构使我们能够根据条件执行不同的代码块。在本篇中，我们将深入了解循环结构，它是编程中非常重要的一个部分，允许我们重复执行一段代码，直到满足特定条件为止。

循环结构概述

C语言中有三种主要的循环结构：for 循环、while 循环和 do-while 循环。它们各自有不同的用法，其基本目的是相同的，即重复执行一段代码。

1. `for` 循环

for 循环通常用于已知循环次数的场景。其基本语法如下：

1
2
3

for (初始化; 条件; 更新) {
    // 循环体
}

示例：计算1到10的总和

#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i; // 将i累加到sum中
    }
    printf("1到10的总和是: %d\n", sum);
    return 0;
}

在这个例子中，for 循环从 1 到 10 迭代，sum 变量用于计算总和。循环体每次执行时，i 的值都被累加到 sum 中。

2. `while` 循环

while 循环适用于当循环次数未知，但需要根据条件持续执行时。其基本语法如下：

1
2
3

while (条件) {
    // 循环体
}

示例：从键盘输入数字，直到输入0

#include <stdio.h>

int main() {
    int num;
    int sum = 0;
    
    printf("请输入一个数字，输入0结束：\n");
    scanf("%d", &num);
    while (num != 0) {
        sum += num; // 将输入的数字累加到sum中
        printf("请输入一个数字，输入0结束：\n");
        scanf("%d", &num);
    }
    
    printf("输入的总和是: %d\n", sum);
    return 0;
}

在这个例子中，程序会持续要求用户输入数字，直到输入 0 为止。每次输入的数字都会被累加到 sum 中。

3. `do-while` 循环

do-while 循环与 while 循环相似，但它保证至少执行一次循环体。其基本语法如下：

1
2
3

do {
    // 循环体
} while (条件);

示例：至少输入一次年龄

#include <stdio.h>

int main() {
    int age;
    
    do {
        printf("请输入您的年龄：\n");
        scanf("%d", &age);
    } while (age < 0); // 如果年龄为负数，继续输入
    
    printf("您输入的年龄是: %d\n", age);
    return 0;
}

在这个例子中，即使用户输入一个负数，程序也会继续提示用户输入年龄，直到用户输入一个有效的非负数为止。

总结

本篇我们探讨了三种主要的循环结构：for、while 和 do-while。这些结构在处理需要重复执行代码的场景时非常有用。通过适当选择循环结构，可以使代码更加清晰和高效。

在下一篇中，我们将开始学习函数，包括函数的定义与调用。这是一个编程中非常重要的主题，它将帮助我们更好地组织和重用代码。请继续关注！

🔥 新增教程

fgetc 和 fputc

fgetc 函数

使用案例

fputc 函数

使用案例

fread 和 fwrite

fread 函数

使用案例

fwrite 函数

使用案例

小结

分享转发

关系运算符一览

运算符优先级

示例：

具体案例分析

使用==和!=运算符

示例：

使用>和<运算符

示例：

使用>=和<=运算符

示例：

小结

分享转发

文件定位

1. fseek()

示例：

2. ftell()

3. rewind()

示例：

总结文件定位

文件缓冲

缓冲类型

函数 setvbuf()

示例：

结论

分享转发

逻辑与：&&

示例

逻辑或：||

示例

逻辑非：!

示例

逻辑运算符的结合使用

示例

总结

分享转发

文本文件和二进制文件的基本区别

读取文本文件

写入文本文件

读取二进制文件

写入二进制文件

结论

分享转发

位运算符简介

1. 按位与 &

2. 按位或 |

3. 按位异或 ^

4. 按位取反 ~

5. 左移 <<

6. 右移 >>

应用案例：交换两个整数的值

小结

分享转发

5.1 数组

1. 数组的基本概念

1.1 数组的特点

1.2 数组的案例

2. 数组的优缺点

5.2 链表

3. 链表的基本概念

3.1 链表的定义

3.2 单链表的案例

4. 链表的优缺点

总结

分享转发

顺序结构的概念

顺序结构的示例

示例 1: 计算两个数的和

使用`==`和`!=`运算符

使用`>`和`<`运算符

使用`>=`和`<=`运算符

1. `fseek()`

2. `ftell()`

3. `rewind()`

函数 `setvbuf()`

逻辑与：`&&`

逻辑或：`||`

逻辑非：`!`

1. 按位与 `&`

2. 按位或 `|`

3. 按位异或 `^`

4. 按位取反 `~`

5. 左移 `<<`

6. 右移 `>>`

1. `for` 循环

2. `while` 循环

3. `do-while` 循环