多种排序算法的实现与比较

排序算法的分类有多种分法. 是否是基于比较的; 是否是稳定排序; 当然也可按照时间复杂度和空间复杂度来进行划分. 而本文关注的重点在于时间复杂度及基于比较的排序. 基排序和计数排序等在此就不进行讨论了.

头文件 sort.h

#include <iostream>

class sort
{
public:
    static bool bubble_sort(int* arry, int n);//冒泡排序
    static bool insert_sort_no(int* arry, int n);//插入排序,非递归
    static bool insert_sort_re(int* arry, int n);//插入排序,递归
    static bool select_sort(int* arry, int n);//选择排序
    static bool merge_sort(int* arry, int n);//归并排序
    static bool heap_sort(int* arry, int n);//堆排序
    static bool quick_sort(int* arry, int n);//快速排序
};

 

排序算法实现代码 

#include "sort.h"


//功能: 插入排序,非递归
//输入: 数组
//输出: 已排序数组
//版本: 1.0 
//最后修改时间: 2012-7-5
//修订人: 陈飞
bool sort::insert_sort_no(int* num, int n)
{
    if (n<1)
    {
        return false;
    }

    //插入排序
    int temp;
    for (int i=1; i<n; i++)
    {
        temp = num[i];
        int j;
        for(j=i-1; j>=0 && num[j]>temp; j--)
        {
            num[j+1]=num[j];
        }
        num[j+1] = temp;
        
    }
    return true;
}

//插入排序,递归
//2012-7-14
//大于一定数时栈溢出
bool sort::insert_sort_re(int *arry, int n)
{
    if (0==n)
    {
        return true;
    } 
    else
    {
        insert_sort_re(arry, n-1);
        //
        int temp = arry[n-1];
        int i;
        for (i=n-2; i>=0 && arry[i]>temp; i--)
        {
            arry[i+1]=arry[i];
        }
        arry[i+1]=temp;
    }
    return true;
}


//功能: 归并排序,递归
//输入: 乱序数组
//输出: 已排序数组
//版本: 1.0
//最后修改时间: 2012-7-9
//修订人: 陈飞

//归并辅助函数
void merge_assist(int *arry1, int n1, int *arry2, int n2, int* whole)
{
    //int* whole = (int *)malloc((n2+n1)*sizeof(int));
    int i1, i2;
    for (i1=0, i2=0; i1<n1 && i2<n2;)
    {//从两个数组中取小的到whole数组中
        if (arry1[i1]<arry2[i2])
        {
            whole[i1+i2] = arry1[i1++];
        } 
        else
        {
            whole[i1+i2] = arry2[i2++];
        }
    }
    //剩余排序的加到whole末尾
    if (i1==n1)
    {
        for (;i2<n2;i2++)
        {
            whole[i1+i2] = arry2[i2];
        }
    } 
    else
    {
        for (;i1<n1; i1++)
        {
            whole[i1+i2] = arry1[i1];
        }
    }

    //复制回原数组
    for(int i=0; i<n1+n2; i++)
    {
        arry1[i] = whole[i];
    }
    //free(whole);
}

void  merge_main(int *arry, int n, int* assist)
{
    if (n>1)
    {
        merge_main(arry, n/2, assist);
        merge_main(arry+n/2, n-n/2, assist);
        merge_assist(arry, n/2, arry+n/2, n-n/2, assist);
    }
}

bool sort::merge_sort(int *arry, int n)
{
    //辅助数组的生成
    int* assist = (int*)malloc(sizeof(int)*n);
    merge_main(arry, n, assist);
    free(assist);
    return true;
}


//冒泡排序 2012-7-31 v1.0
bool sort::bubble_sort(int *arry, int n)
{
    int i, j, t;
    for (i=0; i<n; i++)
    {
        for (j=0; j<n-i-1; j++)
        {
            if (arry[j]>arry[j+1])
            {
                t=arry[j];
                arry[j]=arry[j+1];
                arry[j+1]=t;
            }
        }
    }
    return true;
}
//选择排序 2012-7-31 v1.0
bool sort::select_sort(int *arry, int n)
{
    int i, j, t;
    for (i=0;i<n;i++)
    {
        for (j=i+1;j<n;j++)
        {
            if (arry[j]<arry[i])
            {
                t=arry[j];
                arry[j]=arry[i];
                arry[i]=t;
            }
        }
    }
    return true;
}



//快排 2012-7-31 v1.0
bool sort::quick_sort(int *a, int n)
{
    if(n<=1) return true;
    else
    {
        //随机化快排
        //swap(a[0], a[random(0,n-1)]);
        int i=0, j=1,t;
        for (;j<n;)
        {
            if (a[j]<a[0])
            {
                t=a[i+1]; a[i+1]=a[j];a[j]=t;
                i++; j++;
            } 
            else
            {
                j++;
            }
        }
        t=a[i]; a[i]=a[0];a[0]=t;
        quick_sort(a, i);
        quick_sort(a+i+1, n-i-1);
        return true;
    }
}

//堆排序
//2012-7-31 v1.0
void max_heapify(int* a, int n, int i)
{//最大堆的保持
    int l = 2*i;
    int r = 2*i + 1;
    int max_value = i;
    if (l<=n && a[l-1]>a[i-1])
    {
        max_value = l;
    }
    if (r<=n && a[r-1]>a[max_value-1])
    {
        max_value = r;
    }
    if (max_value != i)
    {
        int t=a[max_value-1];
        a[max_value-1]=a[i-1];
        a[i-1]=t;
        max_heapify(a, n, max_value);
    }
}

void build_max_heap(int* a, int n)
{
    int i;
    for (i=n/2; i>0; i--)
    {
        max_heapify(a, n, i);
    }
}

bool sort::heap_sort(int *a, int n)
{
    build_max_heap(a,n);
    for (int i=n; n>1; n--)
    {
        int t = a[0]; a[0]=a[n-1]; a[n-1]=t;
        max_heapify(a, n-1, 1);
    }
    return true;
}

 

冒泡排序

　　最早学习的算法, 通过相邻两个数比较与交换. 最终达到排序的目的. 名为冒泡的原由在于比较过程当中犹如一个气泡不断上冒. 我在实现的时间却一直用着它的下沉. 时间复杂度为O(n), 空间复杂度为O(1).

选择排序

　　不断选择最值放于其中一侧. 如:第一个数与后续逐个比较, 若小于(或大于)第一个数则交换. 一遍后第二个数如是行.时间复杂度为O(n*n), 空间复杂度为O(1).

插入排序

　　假设先前的数已排好序, 通过不断将后一个数插入到先前有序数组中最终实现排序. 时间复杂度为O(n*n), 空间复杂度为O(1).

归并排序

　　要排序一个数组,先排序其均分的两个子数组. 递归. 合并两个已排序的数组. 时间复杂度为O(nlog(n)), 空间复杂度为O(n).

快速排序

　　随机选择一个数为轴, 大于该数的放于一端, 小于该数的放于另一端. 对两端的数组继续如是行. 直到数小于等于1为止.  平均时间复杂度为(nlog(n)), 空间复杂度为O(1).

堆排序

　　构造堆, 通过不断取最值,重构进行排序. 时间复杂度为O(nlog(n)), 空间复杂度为O(1).

 

以下为其性能比较. 

单位毫秒. 计时方式误差较大. 

	冒泡	选择	插入	归并	快排	堆排
2W	1478	1450	358
20W			26450	78	47	200
200W				800	810	2330

 全部代码请见:https://github.com/uglyfly/sort