常见排序算法

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

void print(const vector<int>& a) {      //打印vector数组
    for(int i = 0; i < a.size(); i++) {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

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

void quickSort(vector<int>& vec, int left, int right) {     //快速排序 (双边循环法)
    if(left > right)    return;

    int pivot = vec[left];
    int i = left;
    int j = right;

    while(i!=j) {
        while(i < j && vec[j] >=pivot) {    //必须先从右往左找
            j--;
        }
        while(i < j && vec[i] <=pivot) {
            i++;
        }

        if(i < j) {
            swap(vec[i], vec[j]);
        }
    }
        swap(vec[left], vec[i]);
        quickSort(vec, left, i-1);
        quickSort(vec, i+1, right);
        return;
}

//堆排序
void downAdjust(vector<int>& arr, int start, int end) {     //构建大顶堆
    int father = start;
    int child = father*2+1;
    while(child < end) {
        if(child+1 < end && arr[child+1] > arr[child]) {    //若右孩子大于左孩子，则左孩子下标+1=右孩子下标
            child++;
        }

        if(arr[child] > arr[father]) {  判断较大的孩子的值是否大于父节点的值，若大，则完成交换
            swap(arr[child], arr[father]);
        } else {
            return;
        }
        如果发生了交换则将当前孩子的下标作为父节点下标
        father = child;
        child = father*2+1;
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    for(int i = n/2-1;i >= 0; i-- ) {
        downAdjust(arr,i,n);    //从最后一个非叶子结点开始调整
    }
    for(int i = n-1; i > 0; i--) {
        swap(arr[0], arr[i]);
        downAdjust(arr,0,i);
    }
}


//归并排序
void merge(vector<int>& array, int start, int mid, int end) {
    //开辟额外大集合，设置指针
    vector<int> tmp(end-start+1);
    int p1 = start;
    int p2 = mid+1;
    int p = 0;

    while((p1 <= mid) && (p2<=end)) {
        if(array[p1]<array[p2]) {
            tmp[p++] = array[p1++];
        } else {
            tmp[p++] = array[p2++];
        }
    }

    //左侧小集合还有剩余，依次放入大集合尾部
    while(p1 <= mid) {
        tmp[p++] = array[p1++];
    }
    //右侧小集合还有剩余，依次放入大集合尾部
    while(p2 <= end) {
        tmp[p++] = array[p2++];
    }

    //把大集合的元素复制回原数组
    for(int i = 0; i < tmp.size(); i++) {
        array[i+start] = tmp[i];
    }
}

void mergeSort(vector<int>& array, int start, int end) {
    if(start < end) {
        //折半成两个小集合，分别进行递归
        int mid = (start+end)/2;
        mergeSort(array, start, mid);
        mergeSort(array, mid+1, end);
        //把两个有序小集合，归并成一个大集合
        merge(array, start, mid, end);
    }
}



int main() {
    vector<int> arr{4,1,6,8,0,3,4,7,2,8};
    print(arr);

    //bubbleSort(arr);
    //quickSort(arr, 0, arr.size()-1);
    //heapSort(arr);
    mergeSort(arr,0,arr.size()-1);

    print(arr);

    return 0;
}