十大排序算法

一个讲的很全面的博客，每个排序算法都有对应的动画展示排序过程。
十大排序算法

1. 排序算法总览

2.十大排序算法对应的时间复杂度以及空间复杂度

3. 代码实现

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

//1. 比较类排序

//1.1 交换排序
//1.1.1 冒泡排序 时间复杂度 O(n^2) , 空间复杂度 O(1)
void bubblesort(vector<int> &nums)
{
    int length = nums.size();
    int temp = 0;
    for(int i = 1; i <= length-1; ++i)
    {
        for(int j = 0; j < length - i; ++j)
        {
            if(nums[j] > nums[j+1])
            {
                temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
}

//1.1.2 快速排序 时间复杂度 O(n*log2^n) , 空间复杂度 O(1)
void quicksort(vector<int> &nums, int s, int e)
{
    if(s < e)
    {
        int si = s, ei = e;
        int curr = nums[s];
        while(si < ei)
        {
            while(si < ei && nums[ei] > curr)
                --ei;
            if(si < ei)
            {
                nums[si] = nums[ei];
                ++si;
            }

            while(si < ei && nums[si] < curr)
                ++si;
            if(si < ei)
            {
                nums[ei] = nums[si];
                --ei;
            }
        }
        nums[si] = curr;
        //cout<<si<<endl;
        quicksort(nums, s, si-1);
        quicksort(nums, si+1, e);
    }
}

//1.2 选择排序
//1.2.1 选择排序 时间复杂度 O(n^2) , 空间复杂度 O(1)
void chooseSort(vector<int> &nums)
{
    int length = nums.size();

    for(int i = 0; i < length - 1; ++i)
    {
        int minnum = nums[i];
        int minindex = i;
        for(int j = i+1; j < length; ++j)
        {
            if(nums[j] < minnum)
            {
                minnum = nums[j];
                minindex = j;
            }
        }
        int temp = nums[i];
        nums[i] = nums[minindex];
        nums[minindex] = temp;
    }
}

//1.2.2 堆排序
//时间复杂度 O(n^2) , 空间复杂度 O(1)
void heapify(vector<int> &nums, int i, int length)
{
    int left = 2 * i;
    int right = left + 1;
    int largest = i;

    //int length = nums.size();

    if(left < length && nums[left] > nums[largest])
    {
        largest = left;
    }

    if(right < length && nums[right] > nums[largest])
    {
        largest = right;
    }

    if(largest != i)
    {
        int temp = nums[largest];
        nums[largest] = nums[i];
        nums[i] = temp;
        heapify(nums, largest, length);
    }
}

void BuildMaxHeap(vector<int> &nums)
{
    int length = nums.size();
    for(int i = length / 2; i >= 0; --i)
    {
        heapify(nums, i, length);
        /*
        int temp = nums[0];
        nums[0] = nums[length-1];
        nums[length-1] = temp;
        */
    }
}
void heapSort(vector<int> &nums)
{
    BuildMaxHeap(nums);

    int length = nums.size();
    for(int i = length-1; i > 0; --i)
    {
        int temp = nums[0];
        nums[0] = nums[i];
        nums[i] = temp;
        heapify(nums, 0, i);
    }
}


//1.3 插入类排序
//1.3.1 简单插入排序
//时间复杂度 O(n^2) , 空间复杂度 O(1)
void insertSort(vector<int> &nums)
{
    int length = nums.size();
    for(int i = 1; i < length; ++i)
    {
        int j = i-1;
        int temp = nums[i];
        while(j >= 0)
        {
            if(nums[j] > temp)
            {
                nums[j+1] = nums[j];
                 --j;
            }
            else
            {
                break;
            }
        }
        nums[j+1] = temp;
    }
}

//1.3.2 希尔排序   分组的增量排序
//时间复杂度 O(n ^ 1.3), 空间复杂度 O(1)
//时间复杂度需要思考一下
void shellSort(vector<int> &nums)
{
    int length = nums.size();

    for(int add = length / 2; add >= 1; --add)
    {
        for(int i = add; i < length; ++i)
        {
            int j = i - add;
            int temp = nums[i];
            while(j >= 0)
            {
                if(nums[j] > temp)
                {
                    nums[j+add] = nums[j];
                    j = j - add;
                }
                else
                {
                    break;
                }
            }
            nums[j+add] = temp;
        }
    }
}


//1.4 归并排序
//1.4.1 二路归并排序

int main()
{
    vector<int> nums = {23,1,34,21,78,34,99,66,21,100};
    /*
    vector<int> nums;
    int temp;
    while(cin>>temp)
    {
        nums.push_back(temp);
    }
    cin.clear();
    */
    int length = nums.size();
    for(int i = 0; i < length; ++i)
    {
        cout<<nums[i]<<" ";
    }
    cout<<endl;
//比较类排序
    //交换排序 （每次排序交换相邻的两个值）
    //bubblesort(nums);
    //quicksort(nums, 0, length-1);
    //选择排序 （选择其中的最大/最小值，并插入其准确的位置）
    //chooseSort(nums);
    //heapSort(nums);
    //插入排序 （将未排序队列中的元素与顺序队列中的数字比较，并将其插入到排序队列中相对正确的位置)
    //insertSort(nums);
    shellSort(nums);

    for(int i = 0; i < length; ++i)
    {
        cout<<nums[i]<<" ";
    }
    return 0;
}