自用六大排序

#include<iostream>
using namespace std; 
/*首先找到数组中最小的元素，将它和数组中第一个元素进行交换
* 然后找到数组中第二小的元素，将它和数组中第二个元素进行交换
* 以此类推
*/
int* SelectSort(int* arr)
{
    for (int i = 0; i < 10; i++)
    {
        int min = i;//最小元素的索引,一开始初始化为i
        //从i的右侧开始寻找最小的元素（因为i左侧的元素是已经排好序的了）
        for (int j = i + 1; j < 10; j++)
        {
            if (arr[j] < arr[min])
                min = j;
        }
        //找到最小的元素arr[min]之后，与arr[i]进行交换
        int item = arr[i];
        arr[i] = arr[min];
        arr[min] = item;
    }
    return arr;
}
/*
为了给插入的元素腾出空间，需要将其余所有元素在插入之前右移一位
*/
int* InsertSort(int* arr)
{
    //当索引i到达右端时，排序就完成了
    for (int i = 0; i < 10; i++)
    {
        //从已排序的元素序列从后往前扫描,若arr[j] < arr[j - 1]，就发生交换
        for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--)
        {
            int temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
        }
    }
    return arr;
}
/*对于升序排列的冒泡排序，索引i每走完一趟，就会有一个最大值被排在数组的末尾
* 对于长度为n的数组来说，需要进行i-1趟的排序(数组长度减1)
*/
int* BubbleSort(int* arr)
{
    
    int times = 10 - 1;//n-1
    for (int i = 0; i < times; i++)
    {
        //j的边界条件是j<times-i;因为每走完一趟，末尾有序的元素就会增加一个
        for (int j = 0; j < times - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
void Merge(int arr[], int temp[], int left, int mid, int right)
{
    int l_pos = left;//左半区第一个未排序的元素
    int r_pos = mid + 1;//右半区第一个未排序的元素
    int pos = left;//临时数组的下标
    //合并
    while (l_pos<=mid&&r_pos<=right)
    {
        if (arr[l_pos] < arr[r_pos]) temp[pos++] = arr[l_pos++];
        else temp[pos++] = arr[r_pos++];
    }
    //合并左半区剩余的元素
    while (l_pos<=mid)
    {
        temp[pos++] = arr[l_pos++];
    }
    //合并右半区剩余的元素
    while (r_pos<=right)
    {
        temp[pos++] = arr[r_pos++];
    }
    while (left<=right)
    {
        arr[left] = temp[left];
        left++;
    }
}
void MergeSort(int arr[], int temp[], int left, int right)
{
    if (left < right)
    {
        //找中间点
        int mid = (left + right) / 2;
        //递归划分左半区
        MergeSort(arr, temp, left, mid);
        //递归划分右半区
        MergeSort(arr, temp, mid + 1, right);
        //合并已经完成排序的部分
        Merge(arr, temp, left, mid, right);
    }
}
void QuickSort(int arr[], int begin, int end)
{
    //只有一个数或者区间不存在时
    if (begin >= end) return;
    int left = begin;
    int right = end;
    //选取左边第一个为key
    int key = begin;
    while (begin<end)
    {
        //右边选小
        while (arr[end] >= arr[key] && begin < end)
        {
            end--;
        }
        //左边选大
        while (arr[begin] <= arr[key] && begin < end)
        {
            begin++;
        }
        swap(arr[begin], arr[end]);
    }
    //此时left和right指针已经相遇
    swap(arr[key], arr[end]);
    //递归左右区间
    key = end;
    QuickSort(arr, left, key - 1);
    QuickSort(arr, key + 1, right);
}
int main()
{
    int temp[10005];
    int test[10] = { 2,6,5,9,3,1,7,8,0,4 };
    MergeSort(test,temp,0,9);
    for (int i = 0; i < 10; i++)
        cout << test[i]<<" ";
}