冒泡排序  

        冒泡排序是一种基础的排序算法，它遍历整个待排序的数组，逐对比较相邻的两个元素，如果它们的顺序错误（比如前面的比后面的大），就将它们交换位置。
        排序的过程是从数组的一端开始，逐对比较每一对相邻元素，并根据需要交换位置。每一轮排序都保证了最大（或最小）的元素移动到数组的一端，然后在剩余的元素中重复这个过程，每次需要比较的元素数量减一，直到没有元素需要比较为止。

#include <stdio.h>

void bubble_sort(int arr[], int n) {
int i, j, temp;
for(i = 0; i < n-1; i++){
int is_swapped = 0; // 添加标志位，用于判断数组是否已经排序好
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;
is_swapped = 1; // 存在交换，更改标志位
}
}
if(is_swapped == 0) break; // 若一轮比较下来没有发生交换，则终止排序
}
}


int main() {
int i, len;
int arr[] = {10, 34, 78, 54, 87, 67};
len = sizeof(arr)/sizeof(arr[0]); // 计算数组的长度
bubble_sort(arr, len); // 对数组进行排序
printf("排序后的数组为：\n");
for(i = 0; i < len; i++) { // 输出排序后的结果
printf("%d ", arr[i]);
}
return 0;
}

        这段代码首先定义了一个冒泡排序的函数bubble_sort。这个函数接受一个整型数组和一个整数n（代表数组长度）作为输入。

        在bubble_sort函数中，我们有两个循环。外部循环控制排序的总轮数，内部循环进行每轮的比较和交换。我们添加了一个标志位is_swapped，如果一轮比较中没有元素交换位置，那么我们可以提前结束排序，因为这意味着数组已经被排序好了。

        在主函数main中，我们定义了一个整型数组arr，并通过sizeof运算符计算得到数组的长度len。然后调用bubble_sort来排序这个数组，并且打印出排序后的结果。

        实际应用：冒泡排序是一个简单但效率较低的排序算法，它虽然不适合处理大规模的数据，但可以用在一些小规模且对效率要求不高的场景，比如学生的分数排序、电子商务平台的商品价格排序等。

附：实际应用

#include <stdio.h>

typedef struct {
    char name[50];
    int score;
} Student;

void bubble_sort(Student arr[], int n) {
    int i, j;
    Student temp;
    for(i = 0; i < n-1; i++){        
        for(j = 0; j < n-i-1; j++){ 
            if(arr[j].score < arr[j+1].score){    // 比较每对学生的成绩，若前一名学生的分数小于后一名，就交换他们
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int i, len;

    // 定义一个学生成绩数组
    Student students[] = {{"Alice", 85}, {"Bob", 90}, {"Charlie", 80}, {"Dave", 95}, {"Eve", 92}};
    len = sizeof(students)/sizeof(students[0]);

    // 对学生的成绩进行冒泡排序
    bubble_sort(students, len);

    printf("按照成绩降序排序后的学生成绩为：\n");
    for(i = 0; i < len; i++) {
        printf("%s: %d\n", students[i].name, students[i].score);   // 输出排序后的学生名字和对应成绩
    }

    return 0;
}

        这段代码首先定义了一个学生结构体Student实例，包含学生的姓名和分数两个字段。然后我们定义了一个冒泡排序函数bubble_sort，该函数接受一个Student类型的数组和一个整数n（代表数组长度）作为输入。

        在bubble_sort函数中，我们会遍历Student数组，并按照分数将学生进行排序。我们会比较每对相邻学生的分数，如果前面的学生分数小于后面的学生，我们就交换他们的位置。直到数组已经完全排序为止。

        在主函数main中，我们初始化了一个Student数组，并使用sizeof运算符来计算数组的长度。然后，我们调用了bubble_sort函数对学生名单进行排序。最后，我们遍历并打印出排序后的学生成绩。

快速排序

       快速排序是一种效率高且常用的排序方式。它的基本思想是，选择一个基准值（Pivot）,通过一趟排序后，将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分进行排序，以达到整个序列有序的目标。

#include <stdio.h>

void bubble_sort(int arr[], int n) {
int i, j, temp;
for(i = 0; i < n-1; i++){
int is_swapped = 0; // 添加标志位，用于判断数组是否已经排序好
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;
is_swapped = 1; // 存在交换，更改标志位
}
}
if(is_swapped == 0) break; // 若一轮比较下来没有发生交换，则终止排序
}
}


int main() {
int i, len;
int arr[] = {10, 34, 78, 54, 87, 67};
len = sizeof(arr)/sizeof(arr[0]); // 计算数组的长度
bubble_sort(arr, len); // 对数组进行排序
printf("排序后的数组为：\n");
for(i = 0; i < len; i++) { // 输出排序后的结果
printf("%d ", arr[i]);
}
return 0;
}

        这段代码首先定义了一个快速排序的函数quicksort。这个函数接受一个整型数组，并有两个整数low和high作为输入，分别代表了待排序的数组区间。另一个函数partition，将数组的指定区间分成两个独立的部分，其中左边的部分所有元素都与右边的部分所有元素相比较都小。

        在quicksort函数中，我们首先会判断当前待排序的数组区间是否有效（即low < high）。如果有效，那么就通过partition函数选取一个基准值，并将数组分割成两部分，然后对每一部分进行递归排序。如果待排序的数组区间无效，那么直接返回。

        快速排序的实际应用很广泛，从各种数据的排序，如学生的分数排序，电子商务平台商品价格排，等等，都可以用到快速排序。

附：实际应用

#include <stdio.h>

typedef struct {
    char name[50];
    int score;
} Student;

void swap(Student* a, Student* b) {
    Student t = *a;
    *a = *b;
    *b = t;
}

int partition(Student arr[], int low, int high) {
    int pivot = arr[high].score;
    int i = low - 1;

    for(int j = low; j <= high - 1; j++) {
        if(arr[j].score > pivot) {  // 对学生成绩进行比较,如果当前元素大于pivot，与i+1位置的元素交换，并将i增加1
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);   // 将pivot移到正确的位置
    return i + 1;  // 返回pivot的位置
}

void quick_sort(Student arr[], int low, int high) {
    if(low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);   // 分别对pivot左侧和右侧的元素进行递归排序
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    int i, len;

    // 定义学生成绩数组
    Student students[] = {{"Alice", 85}, {"Bob", 90}, {"Charlie", 80}, {"Dave", 95}, {"Eve", 92}};
    len = sizeof(students)/sizeof(students[0]);

    // 对学生的成绩进行快速排序
    quick_sort(students, 0, len - 1);

    printf("按照成绩降序排序后的学生成绩为：\n");
    for(i = 0; i < len; i++) {
        printf("%s: %d\n", students[i].name, students[i].score);      // 输出排序后的学生信息
    }

    return 0;
}

        这段代码首先定义了一个学生结构体Student，包含学生的姓名和分数两个字段。然后我们定义了一个快速排序函数quick_sort，该函数接受一个Student类型的数组和两个整数low和high作为输入，分别表示待排序数组区间的起始和结束下标。

        在quick_sort函数中，我们会使用partition函数将待排序的数组区间以一个pivot为界分成两个部分，所有较大的元素都在该pivot左侧，而所有较小的元素都在右侧。然后我们对pivot左侧和右侧的元素分别进行递归排序。最终，我们会得到一个有序的学生成绩列表。

        在主函数main中，我们初始化了一个Student数组，并使用sizeof运算符计算出数组的长度。然后我们调用了quick_sort函数对学生名单进行排序，最后，我们遍历并打印出排序后的学生成绩。

链表

链表的节点定义

        在C语言中，链表的节点通常通过结构体定义。结构体中不仅包含存储数据的变量，还有一个或多个指针指向其它节点，实现链式连接。

示例代码：定义单向链表的节点

typedef struct Node {
    int data;          // 数据部分
    struct Node *next; // 指向下一个节点的指针
} Node;

创建链表

        创建链表通常涉及到初始化头节点，并依次添加新节点。

示例代码：创建链表和添加新节点

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

// 链表节点的定义
typedef struct Node {
    int data;
    struct Node *next;
} Node;

// 创建一个节点并返回其指针
Node* createNode(int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        perror("Unable to allocate memory for new node");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 添加节点到链表末尾
void appendNode(Node **head, int data) {
    Node *newNode = createNode(data);
    if (*head == NULL) { // 如果链表为空，新节点即为头节点
        *head = newNode;
    } else {
        Node *current = *head;
        while (current->next != NULL) { // 遍历到链表末尾
            current = current->next;
        }
        current->next = newNode; // 将新节点添加到链表末尾
    }
}

int main() {
    Node *head = NULL; // 初始化链表头节点为NULL
    appendNode(&head, 1); // 向链表中添加数据
    appendNode(&head, 2);
    appendNode(&head, 3);
    // ...
    
    return 0;
}

遍历链表

        遍历链表通常通过循环结构实现，从头节点开始，通过指针访问链表的每个节点。

示例代码：遍历链表并打印节点数据

void printList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next; // 移至下一个节点
    }
    printf("\n");
}

删除链表节点

        删除链表节点需要注意改变相应节点的指针，确保链表的连续性不被破坏。

示例代码：删除链表中的节点

void deleteNode(Node **head, int key) {
    Node *temp = *head, *prev = NULL;
    
    // 如果头节点就是要删除的节点
    if (temp != NULL && temp->data == key) {
        *head = temp->next; // 改变头指针
        free(temp); // 释放内存
        return;
    }
    
    // 查找需要删除的节点
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    
    // 如果没有找到
    if (temp == NULL) return;
    
    // 从链表中移除节点
    prev->next = temp->next;
    
    // 释放内存
    free(temp);
}