以下是我认为是史上最优雅的10个C语言代码片段，它们展示了C语言的深度和优雅之处：

快速排序算法

void quicksort(int *arr, int low, int high) {    int pivot, i, j, temp;    if (low < high) {        pivot = low;        i = low;        j = high;        while (i < j) {            while (arr[i] <= arr[pivot] && i <= high)                i++;            while (arr[j] > arr[pivot] && j >= low)                j--;            if (i < j) {                temp = arr[i];                arr[i] = arr[j];                arr[j] = temp;            }        }        temp = arr[j];        arr[j] = arr[pivot];        arr[pivot] = temp;        quicksort(arr, low, j - 1);        quicksort(arr, j + 1, high);    }}

快速排序是一种基于分治思想的排序算法，它将一个数组分成两个子数组，再分别对这两个子数组进行排序，最终将子数组合并成一个有序数组。这个代码片段实现了快速排序算法，并且使用了优雅的递归结构。

反转字符串

void reverse(char *str) {    char *end = str;    char tmp;    if (str) {        while (*end) {            ++end;        }        --end;        while (str < end) {            tmp = *str;            *str++ = *end;            *end-- = tmp;        }    }}

这个代码片段实现了反转字符串的功能。它使用了指针来遍历字符串，同时也使用了指针交换的技巧，这些技巧让代码更加优雅。

斐波那契数列

int fibonacci(int n) {    if (n <= 1) {        return n;    }    return fibonacci(n - 1) + fibonacci(n - 2);}

斐波那契数列是一个非常常见的数列，它的每个元素都是前两个元素的和。这个代码片段实现了递归的斐波那契数列计算，代码非常简洁和优雅。

二分查找算法

int binary_search(int arr[], int low, int high, int key) {    if (high < low) {        return -1;    }    int mid = low + (high - low) / 2;    if (key == arr[mid]) {        return mid;    }    if (key < arr[mid]) {        return binary_search(arr, low, mid - 1, key);    } else {        return binary_search(arr, mid + 1, high, key);    }}

二分查找算法是一种高效的查找算法，它的时间复杂度为O(log n)。这个代码片段实现了二分查找算法，并使用了递归的结构。

选择排序算法

void selection_sort(int arr[], int n) {    int i, j, min_idx;    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;            }        }        swap(&arr[min_idx], &arr[i]);    }}

选择排序算法是一种简单直观的排序算法，它的时间复杂度为O(n^2)。这个代码片段实现了选择排序算法，并使用了swap函数来交换元素。

链表反转

void reverse_list(struct ListNode** head) {    struct ListNode* prev = NULL;    struct ListNode* current = *head;    struct ListNode* next = NULL;    while (current != NULL) {        next = current->next;        current->next = prev;        prev = current;        current = next;    }    *head = prev;}

链表反转是一个常见的操作，这个代码片段实现了链表反转，并且使用了指针的技巧来实现。

线性查找算法

int linear_search(int arr[], int n, int x) {    int i;    for (i = 0; i < n; i++) {        if (arr[i] == x) {            return i;        }    }    return -1;}

线性查找算法是一种简单直观的查找算法，它的时间复杂度为O(n)。这个代码片段实现了线性查找算法。

插入排序算法

void insertion_sort(int arr[], int n) {    int i, j, key;    for (i = 1; i < n; i++) {        key = arr[i];        j = i - 1;        while (j >= 0 && arr[j] > key) {            arr[j+1] = arr[j];            j = j - 1;        }        arr[j+1] = key;    }}

插入排序算法是一种简单直观的排序算法，它的时间复杂度为O(n^2)。这个代码片段实现了插入排序算法。

最大公约数

int gcd(int a, int b) {    if (b == 0) {        return a;    }    return gcd(b, a % b);}

最大公约数是两个整数的公共因数中最大的那个数，这个代码片段实现了递归的求最大公约数的算法。

字符串转换为整数

int my_atoi(char *str) {    int res = 0;    int sign = 1;    int i = 0;    if (str[0] == '-') {        sign = -1;        i++;    }    for (; str[i] != '\0'; ++i) {        if (str[i] < '0' || str[i] > '9') {            break;        }        res = res * 10 + str[i] - '0';    }    return sign * res;}

这个代码片段实现了将字符串转换为整数的算法，可以处理负数和正数。这个实现还考虑了非数字字符的情况，一旦遇到非数字字符就停止转换并返回当前已经转换的结果。