亦有资源网

以下是我认为是史上最优雅的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;
}

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