All sorts of sort

void insertSort(vector<int> &arr)
{
    if(arr.size()==0 || arr.size()==1) return;
    for(int i=1;i<(int)arr.size();++i)
        for(int j=i-1; j>=0 && arr[j]>arr[j+1]; --j)
            swap(arr[j],arr[j+1]);
}

void bubbleSort(vector<int> &arr)
{
    if(arr.size()==0 || arr.size()==1) return;
    for(int i=arr.size()-1; i>0; --i)
    {
        for(int j=0; j<i; ++j)
        {
            if(arr[j] > arr[j+1])
                swap(arr[j],arr[j+1]);
        }
    }
}

void selectionSort(vector<int> &arr)
{
    if(arr.size()==0 || arr.size()==1) return;
    for(int i=0; i<(int)arr.size(); ++i)
    {
        int minidx = i;
        for(int j=i+1; j<(int)arr.size(); ++j)
        {
            minidx = arr[j] <. arr[minidx] ? j : minidx;
        }
        swap(arr[i], arr[minidx]);
    }
}

void buildBigHeap(vector<int>& arr, int idx)
{
    while(arr[idx] > arr[(idx-1)/2])
    {
        swap(arr[idx], arr[(idx-1)/2]);
        idx = (idx-1)/2;
    }
}

void rebulidBigHeap(vector<int>& arr, int idx, int heapSize)
{
    int leftidx = idx*2+1;
    while(leftidx < heapSize)
    {
        int largest = leftidx+1<heapSize && arr[leftidx] < arr[leftidx+1] ? leftidx+1 : leftidx;
        largest = arr[largest] > arr[idx] ? largest : idx;
        if(largest == idx)
            break;
        swap(arr[idx], arr[largest]);
        idx = largest;
        leftidx = idx*2+1;
    }
}

void heapSort(vector<int>& arr)
{
    if(arr.size()==0 || arr.size()==1)
        return ;

    for(int i=0;i<(int)arr.size();++i)
        buildBigHeap(arr,i);

    int heapSize = arr.size();
    swap(arr[0], arr[--heapSize]);

    while(heapSize > 1)
    {
        rebulidBigHeap(arr, 0, heapSize);
        swap(arr[0], arr[--heapSize]);
    }
}

void quickSort(vector<int> &arr)
{
    if (arr.size()==0 || arr.size()==1) return;
    quickSort(arr, 0, arr.size()-1);
}

void quickSort(vector<int> &arr, int L, int R)
{
    if (L < R)
    {
        vector<int> p = partition(arr, L, R);
        quickSort(arr, L, p[0] - 1);
        quickSort(arr, p[1] + 1, R);
    }
}

vector<int> partition(vector<int> &arr, int L, int R)
{
    int small = L - 1;
    int biger = R;
    while (L < biger)
    {
        if (arr[L] < arr[R])
        {
            swap(arr[++small], arr[L++]);
        }
        else if(arr[L] > arr[R])
        {
            swap(arr[--biger], arr[L]);
        }
        else
        {
            L++;
        }
    }
    swap(arr[biger], arr[R]);
    return vector<int>{small + 1, biger };
}

void mergePart(vector<int> &arr, int L, int mid, int R)
{
    vector<int> help((R-L+1),0);
    int i=0;
    int p1 = L;
    int p2 = mid+1;
    while(p1<=mid && p2<=R)
    {
        if(arr[p1] < arr[p2])
            help[i++] = arr[p1++];
        else
            help[i++] = arr[p2++];
    }
    while(p1<=mid)
        help[i++] = arr[p1++];
    while(p2<=R)
        help[i++] = arr[p2++];
    for(int i=0; i<(int)help.size();++i)
        arr[L+i] = help[i];
}


void mergeSort(vector<int> &arr, int L, int R)
{
    if(L==R)
        return;
    int mid = L + (R-L)/2;
    mergeSort(arr, L, mid);
    mergeSort(arr, mid+1, R);
    mergePart(arr, L, mid, R);
}


void mergeSort(vector<int> &arr)
{
    mergeSort(arr, 0, arr.size()-1);
}