排序

排序

1.冒泡排序

冒泡排序较为简单,总体思路如下

void Swap(int*a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void BubbleSort(int array[], int size)
{
    if(size <= 1)
    {
        return;
    }
    int bound = 0;
    for(; bound < size; bound++)
    {
        int cur = size - 1;
        for(; cur >= 0; cur--)
        {
            if(array[cur] < array[cur - 1])
            {
                Swap(&array[cur], &array[cur - 1]);
            }
        }
    }//end for(; bound < size; bound++)
}

2.选择排序

选择排序和冒泡排序相似,思路如下图所示

void SelectSort(int array[], int size)
{
    if(size <= 1)
    {
        return;
    }
    int bound = 0;
    for(; bound < size; bound++)
    {
        int cur = bound + 1;
        for(; cur < size; cur++)
        {
            if(array[bound] > array[cur])
            {
                Swap(&array[bound] , &array[cur]);
            }
        }
    }//end for(; bound < size; bound++)
}

3.插入排序

插入排序相比前面的选择排序以及冒泡排序就相对比较复杂了,不过整体还是比较简单的,整体思路如下图所示:

void InsertSort(int array[], int size)
{
    if(size <= 1)
    {
        return;//zhi you yi ge yuan su huo zhe fei fa shu ru
    }
    //定义一个边界值bound
    //其中 [0, bound)表示有序区间
    //[bound, cur)代表无须区间
    int bound = 1;
    for(; bound < size; bound++)
    {
        //定义一个bound_value 保存array[bound] 的值,便于搬运
        int bound_value = array[bound];
        //定义一个cur帮助我们进行搬运
        int cur = bound;
        //cur向前扫描
        for(; cur > 0; cur--)
        {
            //将数组下标为cur-1对应的元素和cur[bound_value]进行比较,如果大于就进行搬运
            if(array[cur - 1] > bound_value)
            {
                array[cur] = array[cur - 1];
            }
            else
            {
                break;
            }
        }
        array[cur] = bound_value;
    }//end for(; bound < size; bound++)
}

4.堆排序

堆排序相对于上面几种排序来说在理解上有所不同,堆排序在将数组在逻辑结构上理解为堆,物理结构上理解为数组,具体思路以及代码如下:

void AdjustDown(int array[], int size, int index)
{
    int parent = index;
    int child = 2 * parent + 1;
    while(child < size)
    {
        if(child + 1 < size && array[child + 1] > array[child])
        {
            child = child + 1;
        }
        if(array[child] > array[parent])
        {
            Swap(&array[child], &array[parent]);
        }
        else if(array[child] < array[parent])
        {
            break;
        }
        parent = child;
        child = 2 * parent + 1;
    }
}

void HeapCreat(int array[], int size)
{
    int i = (size - 1 - 1) / 2;
    for(; i >= 0; i--)
    {
        AdjustDown(array, size, i);
    }
}

void HeapPop(int array[], int index)
{
   Swap(&array[0], &array[index]) ;
   AdjustDown(array, index, 0);
}

void HeapSort(int array[], int size)
{
    if(size <= 1)
    {
        return;
    }
    HeapCreat(array, size);
//    int end = size - 1;
//    for(; end >= 0; --end)
//    {
//        Swap(&array[0], &array[end]);
//        AdjustDown(array, end, 0);
//    }
    int i = 1;
    for (; i < size; i++)
    {
        HeapPop(array, size - i);
    }
}

5.希尔排序

希尔排序和上述排序比较起来有点像上面的插入排序,它首先定义一个步长,每次对数组进行局部内进行插入排序, 不断地缩短步长,当步长变为1的时候对数组进行最后一次的插入排序,此时数组就会编程一个有序数组

void ShellSort(int array[], int size)
{
    if(size <= 1)
    {
        return;
    }
    int gap = size / 2;
    for(; gap > 0; gap /= 2)
    {
        int bound = gap;
        for(; bound < size; bound++)
        {
            int cur = bound;
            int bound_value = array[bound];
            for(; cur >= gap; cur -= gap)
            {
                if(array[cur - gap] > bound_value)
                {
                    array[cur] = array[cur - gap];
                }
                else
                {
                    break;
                }
            }
            array[cur] = bound_value;
        }
    }
}

6.归并排序

将数组进行不断的切分,当数组中只有一个元素的时候,此时就可以认为数组有序了,然后将字数组进行合并,最终就会形成一个有序的数组

void MergArray(int array[], int beg, int mid, int end, int* tmp)
{
    int tmp_index = beg;
    int cur1 = beg;
    int cur2 = mid;
    while(cur1 < mid && cur2 < end)
    {
        if(array[cur1] < array[cur2])
        {
            tmp[tmp_index++] = array[cur1++];
        }
        if(array[cur2] < array[cur1])
        {
            tmp[tmp_index++] = array[cur2++];
        }
    }
    while(cur1 < mid)
    {
        tmp[tmp_index] = array[cur1++];
    }
    while(cur2 < end)
    {
        tmp[tmp_index++] = array[cur2++];
    }
    memcpy(array + beg, tmp + beg, (end - beg) * sizeof(int));
}

//[beg, end)为有效区间
void _MergSort(int array[], int beg, int end, int* tmp)
{
    if(end - beg <= 1)
    {
        return;
    }
    int mid = beg + (end - beg) / 2;
    _MergSort(array, beg, mid, tmp);
    _MergSort(array, mid, end, tmp);
    MergArray(array, beg, mid, end, tmp);
}

void MergSort(int array[], int size)
{
    if(array == NULL || size <= 1)
    {
        return;
    }
    int *tmp = (int*)malloc(sizeof(int) * size);
    _MergSort(array, 0, size, tmp);
    free(tmp);
}

7. 快速排序

int Partion(int array[], int beg, int end)
{

    int left = beg;
    int right = end - 1;
    int base = array[right - 1];
    while(left < right)
    {
        while(left < right && array[left] < base)
        {
            left++;
        }
        while(left < right && array[right] > base)
        {
            right--;
        }
        Swap(&array[left], &array[right]);
    }
    Swap(&array[left], &base);
    return left;
}

void _QuickSort(int array[], int beg, int end)
{
    if(end - beg <= 1)
    {
        return;
    }
    size_t mid = Partion(array, beg, end);
    _QuickSort(array, beg, mid);
    _QuickSort(array, mid + 1, end);
}

void QuickSort(int array[], int size)
{
    if(size <= 1)
    {
        return;
    }
    _QuickSort(array, 0, size);
}