C++ 实现冒泡排序、归并排序和折半查找算法并合并两个无序集合

下面是基于 C++ 的冒泡排序、归并排序和折半查找算法的实现：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 冒泡排序函数
void BubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// 归并排序函数
void Merge(vector<int>& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    vector<int> L(n1), R(n2);

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

    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++;
    }
}

void MergeSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        MergeSort(arr, left, mid);
        MergeSort(arr, mid + 1, right);

        Merge(arr, left, mid, right);
    }
}

// 折半查找函数
int BinarySearch(const vector<int>& arr, int target) {
    int left = 0;
    int right = arr.size() - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target) {
            return mid;
        }

        if (arr[mid] < target) {
            left = mid + 1;
        }
        else {
            right = mid - 1;
        }
    }

    return -1;
}

// 主程序
int main() {
    // 输入两个无序集合
    vector<int> set1 = { 1, 3, 5, 2, 4 };
    vector<int> set2 = { 2, 4, 6, 8, 10, 4 };

    // 初始化结果集合
    vector<int> mergedSet;

    // 合并两个集合并去除重复元素
    mergedSet.insert(mergedSet.end(), set1.begin(), set1.end());
    mergedSet.insert(mergedSet.end(), set2.begin(), set2.end());
    sort(mergedSet.begin(), mergedSet.end());
    mergedSet.erase(unique(mergedSet.begin(), mergedSet.end()), mergedSet.end());

    // 输出合并后的有序集合
    cout << "Merged Set: ";
    for (int num : mergedSet) {
        cout << num << " ";
    }
    cout << endl;

    // 在合并后的集合中查找某个元素
    int target = 8;
    int index = BinarySearch(mergedSet, target);

    if (index != -1) {
        cout << "Element '" << target << " ' found at index '" << index << " '" << endl;
    }
    else {
        cout << "Element '" << target << " ' not found" << endl;
    }

    return 0;
}

这段代码实现了冒泡排序、归并排序和折半查找算法的子函数，并且通过主程序将两个无序集合合并成一个有序序列，并在新的序列中查找某个元素。

希望这能帮助到您！如果有任何问题，请随时提问。