C语言算法问答集：算法教育的最佳实践

问题和回答：冒泡排序算法：采用两个循环，比较相邻元素，将较大的元素后移。二分查找算法：在排序数组中寻找目标元素，通过二分法缩小搜索范围。动态规划算法：用于解决斐波那契数列，使用循环计算并存储中间值。贪心算法：解决背包问题，通过排序物品单位价值，尽可能选择高价值物品。递归算法：求解归并排序，将数组分为两部分，递归排序后再合并。

C 语言算法问答集：算法教育的最佳实践

问题 1：如何实现冒泡排序算法？

回答：

OpenCV

开源计算机视觉库拥有超过2500个算法，提供详细的文档和实时计算机视觉的示例代码。它可以在Windows、Linux、Mac OS X、Android、iOS上运行，并通过JavaScript在您的浏览器中使用。语言：C++、Python、Julia、Javascript主页：https://opencv.org问答论坛：https://forum.opencv.org/文档：https://docs.opencv.org源代码：https://github.com/opencv请特别关注我们的教程！ht

下载

立即学习“C语言免费学习笔记（深入）”；

void bubble_sort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

问题 2：如何使用二分查找算法在排序数组中查找目标元素？

回答：

立即学习“C语言免费学习笔记（深入）”；

int binary_search(int arr[], int n, int target) {
    int left = 0, right = n - 1;

    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1;  // 目标元素不存在
}

问题 3：如何实现动态规划算法解决斐波那契数列问题？

回答：

立即学习“C语言免费学习笔记（深入）”；

int fibonacci(int n) {
    int dp[n + 1];
    dp[0] = 0;
    dp[1] = 1;

    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}

问题 4：如何使用贪心算法解决背包问题？

回答：

立即学习“C语言免费学习笔记（深入）”；

// 物品结构体
typedef struct Item {
    int value;  // 价值
    int weight;  // 重量
} Item;

int greedy_knapsack(Item items[], int n, int W) {
    // 排序物品，价值/重量比降序
    qsort(items, n, sizeof(Item), compare_by_value_per_weight);

    int max_value = 0, current_weight = 0;

    for (int i = 0; i < n; i++) {
        if (current_weight + items[i].weight <= W) {
            max_value += items[i].value;
            current_weight += items[i].weight;
        } else {
            break;
        }
    }

    return max_value;
}

// 比较物品的价值/重量比
int compare_by_value_per_weight(const void* a, const void* b) {
    const Item* item1 = (const Item*)a;
    const Item* item2 = (const Item*)b;

    return (item2->value / item2->weight) - (item1->value / item1->weight);
}

问题 5：如何实现递归算法求解归并排序问题？

回答：

立即学习“C语言免费学习笔记（深入）”；

void merge_sort(int arr[], int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int L[n1], R[n2];

    for (int i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }

    for (int i = 0; i < n2; i++) {
        R[i] = arr[mid + 1 + i];
    }

    int i = 0, j = 0, k = left;

    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}