分别用选择排序。堆排序，归并排序排序123三个数字（c++）

### 回答1：
好的，下面是 C++ 语言实现选择排序、堆排序和归并排序的代码，以对 1，2，3 这三个数字进行排序。

1. 选择排序

#include <iostream>
using namespace std;

void selectionSort(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]);
    }
}

int main() {
    int arr[] = {3, 1, 2};
    int n = sizeof(arr)/sizeof(arr[0]);
    selectionSort(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

输出结果为：1 2 3

2. 堆排序

#include <iostream>
using namespace std;

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;
 
    if (l < n && arr[l] > arr[largest])
        largest = l;
 
    if (r < n && arr[r] > arr[largest])
        largest = r;
 
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}
 
void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
 
    for (int i=n-1; i>=0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {3, 1, 2};
    int n = sizeof(arr)/sizeof(arr[0]);
    heapSort(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

输出结果为：1 2 3

3. 归并排序

#include <iostream>
using namespace std;

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
 
    int L[n1], R[n2];
 
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
 
    i = 0;
    j = 0;
    k = l;
    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(int arr[], int l, int r) {
    if (l < r) {
        int m = l+(r-l)/2;
 
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
 
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {3, 1, 2};
    int n = sizeof(arr)/sizeof(arr[0]);
    mergeSort(arr, 0, n-1);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

输出结果为：1 2 3

### 回答2：
选择排序是一种简单直观的排序算法。对于给定的一组数字，选择排序的基本思路是，每次从剩余的数字中选出最小的一个，然后与当前位置进行交换。具体的步骤如下：

1. 首先将数字序列设置为123。
2. 从序列中选择最小的数字1，与首位数字进行交换，得到序列213。
3. 接着从剩余的数字中选择最小的数字2，与第二位数字进行交换，得到序列231。
4. 最后，剩余的数字只有3了，不需要进行任何操作，排序完成。

选择排序的时间复杂度较高，为O(n^2)，其中n为数字的个数。

堆排序是一种基于二叉堆数据结构的排序算法。堆排序的基本思路是，将待排序的数字构建成一个最大堆或最小堆，然后依次将堆顶的数字与末尾数字进行交换，并对剩余的数字进行调整，使其重新满足堆的性质。具体的步骤如下：

1. 首先将数字序列设置为123。
2. 将序列构建成一个最小堆。
3. 依次取出堆顶的数字1与末尾的数字进行交换，并对剩余的数字重新进行调整。
4. 重复上述步骤，直到所有数字都被取出，得到排序的结果。

堆排序的时间复杂度为O(nlogn)，其中n为数字的个数。

归并排序是一种分治的排序算法。对于给定的一组数字，归并排序的基本思路是，将序列划分为较小的子序列，然后对这些子序列进行排序，并将排序后的子序列合并，最终得到完全有序的序列。具体的步骤如下：

1. 首先将数字序列设置为123。
2. 将序列划分为较小的子序列，变成[1] [2] [3]。
3. 依次对每个子序列进行排序，得到[1] [2] [3]。
4. 将排序后的子序列合并，得到最终的有序序列123。

归并排序的时间复杂度较低，为O(nlogn)，其中n为数字的个数。

### 回答3：
选择排序是一种简单直观的排序算法。对于给定的三个数字123，选择排序的基本思路是，每次从剩余未排序元素中选出最小的数字，然后将其放到已排序部分的末尾。具体过程如下：
1. 在给定的三个数字中，选择最小的数字1，将其放在第一个位置。
2. 剩下两个数字2和3，选择最小的数字2，将其放在第二个位置。
3. 最后剩下的数字3只能放在最后的位置。
通过选择排序，我们将123按照从小到大的顺序进行了排序。

堆排序是一种高效的排序算法，它使用了堆的数据结构。对于给定的三个数字123，堆排序的基本思路是，首先将数字构建成一个最小堆，然后依次将堆顶元素取出并放置到已排序部分的末尾。具体过程如下：
1. 将三个数字构建成一个最小堆，堆顶元素为1。
2. 将堆顶元素1取出并放置在第一个位置，剩下的数字2和3重新调整为最小堆。
3. 将重新调整后的堆的堆顶元素2取出并放置在第二个位置，剩下的数字3调整为最小堆。
4. 将剩下的数字3取出并放置在第三个位置。
通过堆排序，我们将123按照从小到大的顺序进行了排序。

归并排序是一种分治策略的排序算法。对于给定的三个数字123，归并排序的基本思路是，将数字拆分成最小的单位，然后两两进行合并排序，直到最终得到完全有序的序列。具体过程如下：
1. 将三个数字拆分成单个数字，并认为单个数字是有序的。
2. 将相邻的数字两两合并，并按照从小到大的顺序进行排序。
3. 第一次合并得到的有序序列为12，与3再进行一次合并排序得到最终的有序序列123。
通过归并排序，我们将123按照从小到大的顺序进行了排序。