排序算法(冒泡，快速，选择，堆，插入，归并，桶/箱,计数，基数)

#include <vector>
#include <algorithm>
using namespace std;

void BubbleSort(vector<int>& arr){
    for(int i=0;i<arr.size()-1;i++){
        for(int j=0;j<arr.size()-i-1;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}

int partition(vector<int>& arr,int low,int high){
    int pivot=arr[high];
    int i=low-1;
    for(int j=low;j<high;j++){
        if(arr[i]<pivot){
            i++;
            swap(arr[i],arr[j]);
        }
    }
    swap(arr[i+1],arr[high]);
    return i+1;
}
void QuickSort(vector<int>& arr,int low,int high){
    if(low<high){
        int pi=partition(arr,low,high);
        QuickSort(arr,low,pi-1);
        QuickSort(arr,pi+1,high);
    }
}

void SelectSort(vector<int>& arr){
    for(int i=0;i<arr.size()-1;i++){
        int max=0;
        for(int j=1;j<arr.size()-i;j++){
            if(arr[max]<arr[j]){
                max=j;
            }
        }
        int temp=arr[arr.size()-i-1];
        arr[arr.size()-i-1]=arr[max];
        arr[max]=temp;
    }
}

void heapify(vector<int>& arr,int n,int i){
    int largest=i;
    int left=2*i+1;
    int right=2*i+2;
    if(left<n&&arr[left]>arr[largest]){
        largest=left;
    }
    if(right<n&&arr[right]>arr[largest]){
        largest=right;
    }
    if(largest!=i){
        swap(arr[i],arr[largest]);
        heapify(arr,n,largest);
    }
}
void HeapSort(vector<int>& arr){
    int n=arr.size();
    for(int i=n/2;i>=0;i--){
        heapify(arr,n,i);
    }
    for(int i=n-1;i>0;i--){
        swap(arr[0],arr[i]);//将当前根节点移到末尾
        heapify(arr,i,0);//重新调整堆
    }
}

void insertSort(vector<int>& arr)
{
    for (int i = 1; i < arr.size(); i++)
    {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
} 

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

void bucketSort(vector<int>& arr){
    int n=arr.size();
    if(n<=0) return;
    vector<vector<int>> buckets(n);
    for(int num:arr){
        int bucketIndex=n*num;
        buckets[bucketIndex].push_back(num);
    }
    for(auto& bucket:buckets){
        sort(bucket.begin(),bucket.end());
    }
    arr.clear();
    for(const auto& bucket:buckets){
        arr.insert(arr.end(),bucket.begin(),bucket.end());
    }
}

int main()
{
    vector<int> arr = {3, 6, 8, 5, 9}; // 初始化列表
    mergeSort(arr,0,4);
    for (int i : arr)
    {
        cout << i << " "; // 输出排序后的数组
    }
    return 0;
}```