冒泡排序

void bubblesort(vector<int>& nums)
{
	int len = nums.size();
	for(int i = 0; i < len; ++i){
		for(int j = 0; j < len - 1 - i; ++j){
			if(nums[j] > nums[j + 1]) swap(nums[j], nums[j + 1]);
		}
	}
}

选择排序

void selectionsort(vector<int>& nums)
{
	int len = nums.size();
	for(int i = 0; i < len; ++i){
		int minIndex = i;
		for(int j = i + 1; j < len; ++j){
			if(nums[j] < nums[minIndex]){
				minIndex = j;
			}
		}
		swap(nums[i], nums[minIndex]);
	}
}

插入排序

void insertionsort(vector<int>& nums)
{
    int len = nums.size();
    for(int i = 1; i < len; ++i){
        if(nums[i] < nums[i - 1]){
            int index = i - 1;
            int val = nums[i];

            while(index >= 0 && nums[index] > val){
                nums[index + 1] = nums[index];                                                                                          
                --index;
            }   
            nums[index + 1] = val;
        }   
    }   
}

快速排序

void quicksort(vector<int>& nums, int left, int right)
{
    int L = left, R = right, key = nums[left];

    while(L < R){ 
        while(L < R && nums[R] >= key) --R;
        if(L < R) nums[L++] = nums[R];

        while(L < R && nums[L] <= key) ++L;
        if(L < R) nums[R--] = nums[L];
    }   
    nums[L] = key;

    quicksort(nums, left, L - 1); 
    quicksort(nums, L + 1, right);
}

shell排序

void shellsort(vector<int>& nums)
{
    int len = nums.size();
    int i = 0, j = 0;
    for(int gap = len / 2; gap > 0; gap /= 2)
    {   
        for(i = gap; i < len; ++i)
        {   
            int tmp = nums[i];
            for(j = i - gap; j >= 0 && nums[j] > tmp; j -= gap)
            {   
                nums[j + gap] = nums[j];
            }   
            nums[j+gap] = tmp;
        }   
    }   
}

归并排序

void mergesort(vector<int>& nums, vector<int>& dataTmp, int start, int end)
{
    int middle;

    while(start < end)
    {   
        middle = start + (end - start) / 2;

        //[0, middle]
        mergesort(nums, dataTmp, start, middle);
        mergesort(nums, dataTmp, middle + 1, end);

        mergesortCore(nums, dataTmp, start, middle, end);
    }   
}

void mergesortCore(vector<int>& nums, vector<int>& dataTmp, int start, int middle, int end)
{
    // merge tow sorted vector
    int n1 = start, n2 = middle + 1;
    int dataIndex = start;
    while(n1 <= middle && n2 <= end)
    {   
        if(nums[n1] < nums[n2]) dataTmp[dataIndex++] = nums[n1++];
        else dataTmp[dataIndex++] = nums[n2++];
    }

    while(n1 <= middle) dataTmp[dataIndex++] = nums[n1++];

    while(n2 <= end) dataTmp[dataIndex++] = nums[n2++];

    //memcpy(nums, dataTmp)
    for(int i = start; i <= end; ++i) nums[i] = dataTmp[i];
}

堆排序

// 单个节点的操作，n是len，i是当前index
void heapify(vector<int>& nums, int n, int i)
{
    int l = i * 2 + 1, 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)
{
    // 找到第一个非叶节点，也可以是 n / 2 - 1;
    int tmp = (n - 2) / 2;
    for(int i = tmp; i >= 0; --i) heapify(nums, n, i);
}

void heapify_sort(vector<int>& nums)
{
    int len = nums.size();
    heapify_build(nums, len);
    for(int i = 0; i < len; ++i)
    {   
        swap(nums[0], nums[len - 1 - i]);
        // 调整
        heapify(nums, len - 1 - i, 0);
    }
}