常见的排序算法及性能比较

常见的排序算法

本文把常见的排序算法总结了一些，并用C++语言实现了一遍，都是从小到大排序。
各种算法的时间复杂度和空间复杂度如下，用程序又粗略的记录了一下每种算法的运行时间。

直接插入排序

直接插入排序就是前面一堆数据已经排好了，从后面的数据中依次选择一个插入到排序好的数据中的一个合适的位置。
代码如下：

for (int i = 1; i < MAX_SIZE; i++)
    {
        int temp = b[i];
        int j;
        for (j=i-1; j>=0&&temp<b[j]; j--)
        {
            b[j+1] = b[j];
        }
        b[j+1] = temp;
    }

希尔排序

希尔排序的原理稍微复杂点，简单理解的话就是每隔固定的间隔的两个数作比较交换，就会逐渐变成一种有序的状态。

for(int gap=MAX_SIZE/2; gap>0; gap/=2)
    {
        //从第gap个元素，逐个对其所在组进行直接插入排序操作
        for(int i=gap; i<MAX_SIZE; i++)
        {
            int j = i;
            int temp = b[j];
            if(b[j]<b[j-gap])
            {
                while(j-gap>=0 && temp<b[j-gap])
                {
                    //移动法
                    b[j] = b[j-gap];
                    j-=gap;
                }
                b[j] = temp;
            }
        }
    }

直接选择排序

从一堆数里面选出最小的，然后与前面的数交换位置。

 for(int i=0; i<MAX_SIZE-1; i++)
    {
        int minIndex = i;
        for(int j=i+1; j<MAX_SIZE; j++)
        {
            if(b[j]<b[minIndex])
                minIndex=j;
        }
        if(minIndex!=i)
        {
            int temp = b[i];
            b[i] = b[minIndex];
            b[minIndex] = temp;
        }
    }

堆排序

有关堆排序的原理可以参考这篇图解排序算法(三)之堆排序

//1.构建大顶堆
    for(int i=MAX_SIZE/2-1; i>=0; i--)
    {
        //从第一个非叶子结点从下至上，从右至左调整结构
        //adjustHeap(arr,i,arr.length);
        int temp = b[i];//先取出当前元素i
        for(int k=i*2+1; k<MAX_SIZE; k=k*2+1)
        {//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<MAX_SIZE && b[k]<b[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(b[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                b[i] = b[k];
                i = k;
            }else{
                break;
            }
        }
        b[i] = temp;//将temp值放到最终的位置
    }
    //2.调整堆结构+交换堆顶元素与末尾元素
    for(int j=MAX_SIZE-1; j>0; j--)
    {
        //将堆顶元素与末尾元素进行交换
        int temp = b[0];
        b[0] = b[j];
        b[j] = temp;
        //重新对堆进行调整
        int i = 0;
        int temp = b[i];//先取出当前元素i
        for(int k=i*2+1; k<j; k=k*2+1)
        {//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<j && b[k]<b[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(b[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                b[i] = b[k];
                i = k;
            }else{
                break;
            }
        }
        b[i] = temp;//将temp值放到最终的位置
    }

冒泡排序

相邻的两个数比较大小，每一趟排序之后最大值都会跑到最后。

for(int i=0; i<MAX_SIZE; i++)
    {
        int flag = 0;
        for(int j=0; j<MAX_SIZE-1-i; j++)
        {
            if(b[j]>b[j+1])
            {
                int temp = b[j];
                b[j] = b[j+1];
                b[j+1] = temp;
                flag = 1;
            }
        }
        if(flag == 0)
            break;
    }

快速排序

快速排序算法的基本思想是从数组中取出一个数，作为基准数，比它大的放在右边，比它小的放在左边，再对左右区间一直重复这个过程，直到每个区间只有一个数。

//快速排序
void QuickSort(int a[], int begin, int end)
{
    if (begin < end)
    {
        int key = a[begin];
        int i = begin;
        int j = end;
        while (i < j)
        {
            while (i < j && a[j] > key)
            {
                j--;
            }
            if (i < j)
            {
                a[i] = a[j];
                i++;
            }
            while (i < j && a[i] < key)
            {
                i++;
            }
            if (i < j)
            {
                a[j] = a[i];
                j--;
            }
        }
        a[i] = key;
        QuickSort(a, begin, i - 1);
        QuickSort(a, i + 1, end);
    }
}

用了一个简单的数据测试了一下，排序结果都是对的。

然后接下来是对大数据进行排序测试一下性能。随机的6万个数据。这个数据只是粗略的测了一下，很多细节都没考虑到。

主程序在这，欢迎各位提bug。

//首先建立了一个数据
//采用各种排序方法排序，并对性能进行比较

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

#define MAX_SIZE 60000

float InsertSort(int a[]); //直接插入排序
float ShellSort(int a[]); //shell 排序
float SelectSort(int a[]); //直接选择排序
float HeapSort(int a[]); //堆排序
float BubbleSort(int a[]); //冒泡排序
void QuickSort(int a[], int begin, int end); //快速排序


int main()
{
    //开辟一个数组，随机赋值
    int *a = new int[MAX_SIZE];
    srand((unsigned)time(0)); //初始化随机数种子
    for(int i=0; i<MAX_SIZE; i++)
    {
        a[i] = rand(); //范围在0-65535
    }
    //int a[10] = {5, 9, 1, 9, 5, 3, 7, 6, 1, 10};

    cout << "各种排序的花费时间：\n" << endl;
    float time = InsertSort(a);
    cout << "直接插入排序：" << time <<"\n"<< endl;

    time = ShellSort(a);
    cout << "希尔排序：" << time <<"\n"<< endl;

    time = SelectSort(a);
    cout << "选择排序：" << time << "\n" << endl;

    time = HeapSort(a);
    cout << "堆排序：" << time << "\n" << endl;

    time = BubbleSort(a);
    cout << "冒泡排序：" << time << "\n" << endl;

    clock_t beginTime, endTime;
    beginTime = clock();
    QuickSort(a, 0, MAX_SIZE);
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<a[m]<<",";
//    }
    cout << "快速排序" << (endTime-beginTime)*1000/CLOCKS_PER_SEC << "\n" << endl;


    delete [] a;
    return 0;
}
//直接插入排序
float InsertSort(int a[])
{
    //为了不破坏原始数组，新开辟空间，程序结束时释放
    //这一段程序不计入排序时间
    int *b = new int[MAX_SIZE];
    for(int i=0; i<MAX_SIZE; i++)
    {
        b[i] = a[i];
    }

    clock_t beginTime, endTime;
    beginTime = clock();
    //开始排序
    for (int i = 1; i < MAX_SIZE; i++)
    {
        int temp = b[i];
        int j;
        for (j=i-1; j>=0&&temp<b[j]; j--)
        {
            b[j+1] = b[j];
        }
        b[j+1] = temp;
    }
    //结束排序
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<b[m]<<",";
//    }
    delete [] b;
    return (endTime-beginTime)*1000/CLOCKS_PER_SEC;
}
//shell 排序
float ShellSort(int a[])
{
    int *b = new int[MAX_SIZE];
    for(int i=0; i<MAX_SIZE; i++)
    {
        b[i] = a[i];
    }

    clock_t beginTime, endTime;
    beginTime = clock();
    //开始排序
    for(int gap=MAX_SIZE/2; gap>0; gap/=2)
    {
        //从第gap个元素，逐个对其所在组进行直接插入排序操作
        for(int i=gap; i<MAX_SIZE; i++)
        {
            int j = i;
            int temp = b[j];
            if(b[j]<b[j-gap])
            {
                while(j-gap>=0 && temp<b[j-gap])
                {
                    //移动法
                    b[j] = b[j-gap];
                    j-=gap;
                }
                b[j] = temp;
            }
        }
    }
    //结束排序
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<b[m]<<",";
//    }
    delete [] b;
    return (endTime-beginTime)*1000/CLOCKS_PER_SEC;
}

//选择排序
float SelectSort(int a[])
{
    int *b = new int[MAX_SIZE];
    for(int i=0; i<MAX_SIZE; i++)
    {
        b[i] = a[i];
    }

    clock_t beginTime, endTime;
    beginTime = clock();
    //开始排序
    for(int i=0; i<MAX_SIZE-1; i++)
    {
        int minIndex = i;
        for(int j=i+1; j<MAX_SIZE; j++)
        {
            if(b[j]<b[minIndex])
                minIndex=j;
        }
        if(minIndex!=i)
        {
            int temp = b[i];
            b[i] = b[minIndex];
            b[minIndex] = temp;
        }
    }
    //结束排序
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<b[m]<<",";
//    }
    delete [] b;
    return (endTime-beginTime)*1000/CLOCKS_PER_SEC;
}
//堆排序
float HeapSort(int a[])
{
    int *b = new int[MAX_SIZE];
    for(int i=0; i<MAX_SIZE; i++)
    {
        b[i] = a[i];
    }

    clock_t beginTime, endTime;
    beginTime = clock();
    //开始排序

    //1.构建大顶堆
    for(int i=MAX_SIZE/2-1; i>=0; i--)
    {
        //从第一个非叶子结点从下至上，从右至左调整结构
        //adjustHeap(arr,i,arr.length);
        int temp = b[i];//先取出当前元素i
        for(int k=i*2+1; k<MAX_SIZE; k=k*2+1)
        {//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<MAX_SIZE && b[k]<b[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(b[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                b[i] = b[k];
                i = k;
            }else{
                break;
            }
        }
        b[i] = temp;//将temp值放到最终的位置
    }
    //2.调整堆结构+交换堆顶元素与末尾元素
    for(int j=MAX_SIZE-1; j>0; j--)
    {
        //将堆顶元素与末尾元素进行交换
        int tmp = b[0];
        b[0] = b[j];
        b[j] = tmp;
        //重新对堆进行调整
        int i = 0;
        int temp = b[i];//先取出当前元素i
        for(int k=i*2+1; k<j; k=k*2+1)
        {//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<j && b[k]<b[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(b[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                b[i] = b[k];
                i = k;
            }else{
                break;
            }
        }
        b[i] = temp;//将temp值放到最终的位置
    }

    //结束排序
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<b[m]<<",";
//    }
    delete [] b;
    return (endTime-beginTime)*1000/CLOCKS_PER_SEC;
}
//冒泡排序
float BubbleSort(int a[])
{
    int *b = new int[MAX_SIZE];
    for(int i=0; i<MAX_SIZE; i++)
    {
        b[i] = a[i];
    }

    clock_t beginTime, endTime;
    beginTime = clock();
    //开始排序
    for(int i=0; i<MAX_SIZE; i++)
    {
        int flag = 0;
        for(int j=0; j<MAX_SIZE-1-i; j++)
        {
            if(b[j]>b[j+1])
            {
                int temp = b[j];
                b[j] = b[j+1];
                b[j+1] = temp;
                flag = 1;
            }
        }
        if(flag == 0)
            break;
    }
    //结束排序
    endTime = clock();
//    for(int m=0; m<MAX_SIZE; m++)
//    {
//        cout<<b[m]<<",";
//    }
    delete [] b;
    return (endTime-beginTime)*1000/CLOCKS_PER_SEC;
}
//快速排序
void QuickSort(int a[], int begin, int end)
{
    if (begin < end)
    {
        int key = a[begin];
        int i = begin;
        int j = end;
        while (i < j)
        {
            while (i < j && a[j] > key)
            {
                j--;
            }
            if (i < j)
            {
                a[i] = a[j];
                i++;
            }
            while (i < j && a[i] < key)
            {
                i++;
            }
            if (i < j)
            {
                a[j] = a[i];
                j--;
            }
        }
        a[i] = key;
        QuickSort(a, begin, i - 1);
        QuickSort(a, i + 1, end);
    }
}