各种排序

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

void bubleSort(std::vector<int>& vec)
{
    auto size = vec.size();
    bool flag = false;

    for(decltype(size) i = 0; i < size; i++)
    {
        flag = false;
        for(decltype(size) j = 0; j < size - 1 -i; j++)
        {
            if(vec[j] > vec[j + 1])
            {
                flag = true;
                std::swap(vec[j], vec[j+1]);
            }
        }

        if(not flag)
        {
            break;
        }

    }

}

void selectSort(std::vector<int>& vec)
{
    auto size = vec.size();
    int minIndex;

    for(decltype(size) i = 0; i < size; i++)
    {
        minIndex = i;
        for(decltype(size) j = i + 1; j < size; j++)
        {
            if(vec[minIndex] > vec[j])
            {
                minIndex = j;
            }
        }
        std::swap(vec[minIndex], vec[i]);
    }
}


void insertSort(std::vector<int>& vec)
{
    auto size = vec.size();

    for(decltype(size) i = 1; i < size; i++)
    {
        if(vec[i] < vec[i-1])
        {
            int j = i - 1;
            int tmp = vec[i];

            while(j >= 0 and tmp < vec[j])
            {
                vec[j+1] =vec[j];
                j--;
            }

            vec[j+1] = tmp;
        }
    }
}

void quickSort(std::vector<int>& vec, int low , int high)
{
    if(low >= high)
    {
        return ;
    }

    int first = low;
    int last = high;

    int key = vec[first];

    while( first < last)
    {
        while(first < last and vec[last] > key)
        {
            last--;
        }

        if(first < last)
        {
            vec[first++] = vec[last];
        }

        while(first < last and vec[first] <= key)
        {
            first++;
        }

        if(first < last)
        {
            vec[last--] = vec[first];
        }
    }

    vec[first] = key;

    quickSort(vec, low, first -1);
    quickSort(vec, first + 1, high);
}

void shellSortCore(std::vector<int>& vec, int gap, int i)
{
    int insertNum = vec[i];
    int j;

    for(j = i - gap; j >= 0 and insertNum < vec[j]; j-=gap)
    {
        vec[j+gap] = vec[j];
    }

    vec[j + gap] = insertNum;

}

void shellSort(std::vector<int>& vec)
{
    auto size = vec.size();
    for(decltype(size) gap = size/2; gap > 0; gap /=2)
    {
        for(decltype(size) i = gap; i < size; i++)
        {
            shellSortCore(vec, gap, i);
        }
    }

}

void mergeSort(vector<int>& data)
{
    int size = data.size();
    vector<int> tmp(size, 0);

    for(int seg = 1; seg < size; seg += seg)
    {
        for(int start = 0; start < size; start += seg + seg)
        {
            int low = start;
            int mid = std::min(start + seg, size);
            int high = std::min(start + seg + seg, size);

            int index = low;
            int start1 = low;
            int end1 = mid;
            int start2 = mid;
            int end2 = high;

            while(start1 < end1 and start2 < end2)
            {
                tmp[index++] = data[start1] < data[start2] ? data[start1++] : data[start2++];
            }

            while(start1 < end1)
            {
                tmp[index++] = data[start1++];
            }

            while(start2 < end2)
            {
                tmp[index++] = data[start2++];
            }
        }

        std::swap(data, tmp);
    }

}


void heapify(vector<int>& nums, int n, int i)//对有一定顺序的堆，
//当前第i个结点取根左右的最大值（这个操作称heapfiy）
{
    int l = i * 2 + 1;
    int r = i * 2 + 2;
    int max = i;

    if (l<n && nums[l]>nums[max])
    {
        max = l;
    }
    if (r<n && nums[r]>nums[max])
    {
        max = r;
    }

    if (max != i)
    {
        swap(nums[max], nums[i]);
        heapify(nums, n, max);
    }
}
void heapify_build(vector<int>& nums, int n)//建立大根堆，从树的倒数第二层第一个结点开始，
//对每个结点进行heapify操作，然后向上走
{
    int temp = (n - 2) / 2;
    for (int i = temp; i >= 0; i--)
    {
        heapify(nums, n, i);
    }

    for (int i = 0; i < nums.size(); i++)
        cout << nums[i] << " ";
    cout << endl;
}

void heapify_sort(vector<int>& nums)
//建立大根堆之后，每次交换最后一个结点和根节点（最大值），
//对交换后的根节点继续进行heapify（此时堆的最后一位是最大值，因此不用管他，n变为n-1）
{
    int n = nums.size();
    heapify_build(nums, n);
    for (int i = 0; i < n; i++)
    {
        swap(nums.front(), nums[n - i - 1]);
        heapify(nums, n - i - 1, 0);
    }
}

int main()
{
    std::vector<int> vec = {9, 7, 8, 6, 1, 3, 2, 4};
    //bubleSort(vec);
    //selectSort(vec);

    //insertSort(vec);

    //quickSort(vec, 0, vec.size() - 1);
    //shellSort(vec);
    //mergeSort(vec);
    heapify_sort(vec);

    for(const auto& iter : vec)
    {
        cout << iter << " ";
    }

    cout << endl;


    return 0;
}