第22节 排序算法二

-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.

第一:

希尔排序

基本思想: 
将待排序列划分为若干组 ， 在每一组内进行插入排序 ， 以使整个序列基本有序 ， 然后再对整个序列进行插入排序

 

希尔排序的实现

#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void ShellSort(int array[], int len) // O(n*n)
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;
    int gap = len;
    
    do
    {
        gap = gap / 3 + 1; //分组
    
        for(i=gap; i<len; i+=gap)//插入排序算法,每次跳动为gap
        {
            k = i;
            temp = array[k];
            
            for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)//gap之前为有序序列,从gap开始
            {
                array[j+gap] = array[j];//移动,插入排序
                k = j;
            }
        
            array[k] = temp;
        }
        
    }while( gap > 1 );
    
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    ShellSort(array, len);
    
    println(array, len);
    
    return 0;
}

 

第二:

快速排序

基本思想: 

1) 任取待排序序列中的某个数据元素( 例如 :第一个元素) 作为基准, , 按照该元素的关键字大小将整个序列划
分为左右两个子序列 ：
      ? 左侧子序列中所有元素都小于或等于基准元素
      ? 右侧子序列中所有元素都大于基准元素
      ? 基准元素排在这两个子序列中间
2) 分别对这两个子序列重复施行上述方法 ， 直到所有的对象都排在相应位置上为止

快速排序的实现:

#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

int partition(int array[], int low, int high)
{
    int pv = array[low];
    
    while( low < high )
    {
        while( (low < high) && (array[high] >= pv) )
        {
            high--;
        }
        
        swap(array, low, high);
        
        while( (low < high) && (array[low] <= pv) )
        {
            low++;
        }
        
        swap(array, low, high);
    }
    
    return low;
}

void QSort(int array[], int low, int high)
{
    if( low < high )
    {
        int pivot = partition(array, low, high);
        
        QSort(array, low, pivot-1);
        QSort(array, pivot+1, high);
    }
}

void QuickSort(int array[], int len) // O(n*logn)
{
    QSort(array, 0, len-1);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    QuickSort(array, len);
    
    println(array, len);
    
    return 0;
}

第三:

归并排序

基本思想: :

将两个或两个以上的有序序列合并成一个新的
有序序列 ：
有序序列 V[1]  … V[m] 和 V[ m +1]  … V[n]

                                 ||

                         V[1]  … V[n ]

这种归并方法称为2路归并。

归并排序的实现

#include <stdio.h>
#include <malloc.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void Merge(int src[], int des[], int low, int mid, int high)
{
    int i = low;
    int j = mid + 1;
    int k = low;
    
    while( (i <= mid) && (j <= high) )
    {
        if( src[i] < src[j] )
        {
            des[k++] = src[i++];
        }
        else
        {
            des[k++] = src[j++];
        }
    }
    
    while( i <= mid )
    {
        des[k++] = src[i++];
    }
    
    while( j <= high )
    {
        des[k++] = src[j++];
    }
}

void MSort(int src[], int des[], int low, int high, int max)
{
    if( low == high )
    {
        des[low] = src[low];
    }
    else
    {
        int mid = (low + high) / 2;
        int* space = (int*)malloc(sizeof(int) * max);
        
        if( space != NULL )
        {
            MSort(src, space, low, mid, max);
            MSort(src, space, mid+1, high, max);
            Merge(space, des, low, mid, high);
        }
        
        free(space);
    }
}

void MergeSort(int array[], int len) // O(n*logn)
{
    MSort(array, array, 0, len-1, len);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    MergeSort(array, len);
    
    println(array, len);
    
    return 0;
}

 

小结

? 希尔排序 ， 快速排序和归并排序将排序算法的时间复杂度提高到了 O(n*  log n  )
? 希尔排序和快速排序的排序结果是不稳定的
? 归并排序的排序结果是稳定的