常见排序算法实现和性能对比

一、相关基本知识
1、稳定排序和非稳定排序
    在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；
    若具有相同关键字的记录之间的相对次序发生改变，则称这种排序方法是不稳定的。
2、内排序和外排序
    在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；
    在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度
    所谓算法的时间复杂度，是指执行算法所需要的计算工作量。 
    所谓算法的空间复杂度，一般是指执行这个算法所需要的内存空间。

二、常见算法列举

1、稳定
冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外空间
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外空间
合并排序 （merge sort）— O(n log n); 需要 O(n) 额外空间
原地合并排序 — O(n2)
二叉排序树排序 （Binary tree sort） — O(n log n)期望时间; O(n2)最坏时间; 需要 O(n) 额外空间
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外空间
Gnome 排序 — O(n2)
图书馆排序 — O(n log n) with high probability, 需要 (1+ε)n 额外空间

2、不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
组合排序 — O(n log n)
堆排序 （heapsort）— O(n log n)sq
平滑排序 — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数列表一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最坏情况时间，需要 额外的 O(n + k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）

3、不实用的排序算法
Bogo排序 — O(n × n!) 期望时间，无穷的最坏情况。
Stupid sort — O(n3); 递归版本需要 O(n2) 额外存储器
珠排序（Bead sort） — O(n) or O(√n), 但需要特别的硬件
Pancake sorting — O(n), 但需要特别的硬件

三、实现代码

/*
*
* Copyright (c) 2012,
* All rights reserved.
*
* 文件名称：sort.cpp
* 文件标识：
* 摘 要：各种常见排序算法实现
*
**************************************************
*
* 当前版本：V0.01
* 作 者： (tojoyccnu@163.com)
* 创建日期：2012.7.11
*
* 修订版本：V0.001
* 作 者：xionghuatao
* 创建日期：2012.7.11
* 修订描述：创建文件
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <windows.h>

void printarray(int *data, int size);

__int64 FileTimeToQuadWord(PFILETIME pft) {
  return (Int64ShllMod32(pft->dwHighDateTime, 32) | pft->dwLowDateTime);

}

/*
 函数名称：select_sort
 算法简述: 选择排序
 1、在待排序序列中选择最小的记录与第一个位置交换。
 2、在剩余待排序序列再次选择最小记录与第二个位置交换。
 3、重复2

 时间复杂度: O(n2)
 空间复杂度: O(1)
 稳定性：不稳定
 */
void select_sort(int *data, int datasize) {
  int index;
  int tmpindex;
  int minindex;

  for (index = 0; index < datasize; ++index) {
    minindex = index;

    //待排序序列中，查找最小关键字数据
    for (tmpindex = index + 1; tmpindex < datasize; ++tmpindex) {
      if (data[minindex] > data[tmpindex]) {
        minindex = tmpindex;
      }
    }

    if (minindex != index) {
      int tmp = data[index];
      data[index] = data[minindex];
      data[minindex] = tmp;
    }
  }
}

/*
 函数名称：gnome_sort 地精算法
 算法简述: 号称最简单的排序算法,只有一层循环,默认情况下前进冒泡,一旦遇到冒泡的情况发生就往回冒,直到把这个数字放好为止。
 时间复杂度: O(n2)
 空间复杂度: O(1)
 稳定性：稳定
 */
void gnome_sort(int *data, int datasize) {
  int i = 0;
  int tmp;

  while (i < datasize) {
    if (i == 0 || data[i - 1] < data[i]) {
      ++i;
    } else {
      tmp = data[i];
      data[i] = data[i - 1];
      data[--i] = tmp;
    }
  }
}

/*
 函数名称：bubble_sort 冒泡排序
 算法简述: 依次比较相邻的两个数，将小数放在前面，大数放在后面
 时间复杂度: O(n2)
 空间复杂度: O(1)
 稳定性：稳定
 */
void bubble_sort(int *data, int datasize) {
  int i, j;
  int flag;

  for (i = datasize - 1; i >= 0; --i) {
    flag = 0;
    for (j = 0; j < i; ++j) {
      if (data[j] > data[j + 1]) {
        int tmp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = tmp;
        flag = 1;
      }
    }

    //flag == 0 表示已排序，为发生交换
    if (!flag)
      return;
  }
}

/*
 函数名称：cocktail_sort
 算法简述: 鸡尾酒排序(冒泡排序的轻微改变，来回排序)
 时间复杂度: O(n2)
 空间复杂度: O(1)
 稳定性：稳定
 */
void cocktail_sort(int *data, int datasize) {
  int bottom = 0;
  int top = datasize - 1;
  int swap = 1;
  int i, tmpdata;

  while (swap) {
    swap = 0;

    //至上而下，冒泡排序最大值
    for (i = 0; i < top; ++i) {
      if (data[i] > data[i + 1]) {
        tmpdata = data[i];
        data[i] = data[i + 1];
        data[i + 1] = tmpdata;
        swap = 1;
      }
    }

    --top;

    //至下而上， 冒泡排序最小值
    for (i = top - 1; i >= bottom; --i) {
      if (data[i] > data[i + 1]) {
        tmpdata = data[i];
        data[i] = data[i + 1];
        data[i + 1] = tmpdata;
        swap = 1;
      }
    }

    ++bottom;
  }
}

/*
 函数名称：insert_sort 简单插入排序
 算法简述: 插入排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。
 希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位

 时间复杂度: O(n2)
 空间复杂度: O(1)
 稳定性：稳定
 */
void insert_sort(int *data, int size) {
  int i, j, t;

  for (i = 1; i < size; ++i) {
    t = data[i];

    for (j = i - 1; j >= 0 && data[j] > t; --j) {
      data[j + 1] = data[j];
    }

    data[j + 1] = t;
  }
}

/*
 函数名称：shell_sort 希尔排序
 算法简述: 希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。
 希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位

 时间复杂度: O(n log n)
 空间复杂度: O(1)
 稳定性：不稳定
 */

void shell_sort(int *data, int size) {
  int i, j;
  int d;
  int tmp;

  for (d = size / 2; d > 0; d /= 2) {
    for (i = d; i < size; ++i) {
      tmp = data[i];
      for (j = i - d; j >= 0 && tmp < data[j]; j -= d) {
        data[j + d] = data[j];
      }
      data[j + d] = tmp;
    }
  }
}

/*
 函数名称：merge_sort 归并排序，二路归并排序， 自底向上
 算法简述: 归并排序是建立在归并操作上的一种有效的排序算法。
 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，
 再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并

 时间复杂度: O(n log n)
 空间复杂度: O(n)
 稳定性：稳定
 */
int merge(int *data, int low, int midd, int high) {
  if (!(NULL != data && low >= 0 && low <= midd && low <= high)) {
    return 1;
  }

  int *tmp = (int *) malloc((high - low + 1) * sizeof(int));

  if (NULL == tmp) {
    return 2;
  }

  int i = low;
  int j = midd + 1;
  int index = 0;

  while (i <= midd && j <= high) {
    if (data[i] <= data[j]) {
      tmp[index++] = data[i++];
    } else {
      tmp[index++] = data[j++];
    }
  }

  while (i <= midd) {
    tmp[index++] = data[i++];
  }

  while (j <= high) {
    tmp[index++] = data[j++];
  }

  memcpy((void *) (data + low), tmp, sizeof(int) * (high - low + 1));
  free(tmp);

  return 0;
}

void merge_pass(int *data, int n, int size) {
  int i;
  int sortlength = 2 * n;

  for (i = 0; (i + sortlength - 1) < size; i = i + sortlength) {
    merge(data, i, i + n - 1, i + sortlength - 1);
  }

  if (i + n - 1 < size - 1) {
    merge(data, i, i + n - 1, size - 1);
  }
}

void merge_sort(int *data, int size) {
  int i;

  for (i = 1; i < size; i = (i << 1)) {
    merge_pass(data, i, size);
  }
}

//堆排序用到的辅助函数
int parent(int i) {
  return (int) ((i - 1) / 2);
}

int left(int i) {
  return (2 * i + 1);
}

int right(int i) {
  return (2 * i + 2);
}

/*
 函数名称：heap_sort 堆排序
 算法简述: 利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，
 使得每次从无序中选择最大记录(最小记录)变得简单

 时间复杂度: O(n log n)
 空间复杂度: O(1)
 稳定性：不稳定
 */
void maxheap_shit(int *data, int index, int size) {
  int i, j;
  int tmp;

  i = index;
  j = 2 * i + 1;  //左子节点

  while (j < size) {
    if (j + 1 < size && data[j + 1] > data[j]) {
      ++j;
    }

    if (data[j] > data[i]) {
      tmp = data[i];
      data[i] = data[j];
      data[j] = tmp;

      i = j;
      j = 2 * i + 1;
    } else {
      break;
    }
  }
}

void heap_sort(int *data, int size) {
  int i, k, tmp;

  for (i = (size - 1) / 2; i >= 0; --i) {
    maxheap_shit(data, i, size);
  }

  for (k = size - 1; k > 0; --k) {
    tmp = data[k];
    data[k] = data[0];
    data[0] = tmp;

    maxheap_shit(data, 0, k);
  }
}

/*
 函数名称：quick_sort 快速排序
 算法简述: 希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。
 希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位

 时间复杂度: O(n log n)
 空间复杂度: O(1)
 稳定性：不稳定
 */

int midian3(int *data, int first, int midian, int end) {
  if (data[first] < data[midian]) {
    if (data[midian] < data[end]) {
      return midian;
    } else if (data[first] < data[end]) {
      return end;
    } else {
      return first;
    }
  } else if (data[first] < data[end]) {
    return first;
  } else if (data[midian] < data[end]) {
    return end;
  } else {
    return midian;
  }

  return first;
}

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

  *a = *b;
  *b = tmp;
}

int partition(int *data, int left, int right, int p) {
  swap_num(&data[p], &data[left]);
  int pivot = data[left];

  while (left < right) {
    while (left < right && data[right] > pivot) {
      --right;
    }

    if (left != right) {
      data[left] = data[right];
      left++;
    }

    while (left < right && data[left] < pivot) {
      ++left;
    }

    if (left != right) {
      data[right] = data[left];
      right--;
    }
  }

  data[left] = pivot;

  return left;
}

void q_sort(int *data, int tmpleft, int tmpright) {
  if (tmpleft >= tmpright)
    return;

  int pivot = partition(
      data, tmpleft, tmpright,
      midian3(data, tmpleft, tmpright, tmpleft + (tmpright - tmpleft) / 2));

  q_sort(data, tmpleft, pivot - 1);

  q_sort(data, pivot + 1, tmpright);
}

void quick_sort(int *data, int size) {
  q_sort(data, 0, size - 1);
}

//log 函数
int lg(int n) {
  int k;
  for (k = 0; n > 1; n >>= 1)
    ++k;
  return k;
}

int partition2(int *data, int tmpleft, int tmpright, int p) {
  int i;
  int index = tmpleft;

  swap_num(&data[p], &data[tmpright]);
  int pivot = data[tmpright];

  for (i = tmpleft; i < tmpright; i++) {
    if (data[i] < pivot)
      swap_num(&data[index++], &data[i]);
  }

  //将标准与index指向的元素交换，返回index，即分割位置
  swap_num(&data[tmpright], &data[index]);
  return index;
}

void intro_q_sort(int *data, int begin, int end, int depthlimt) {
  if (begin >= end)
    return;

  if (end - begin + 1 >= 16) {
    if (depthlimt == 0) {
      //heap_rangesort(data, begin, end);
      heap_sort(&data[begin], end - begin + 1);
      return;
    }

    --depthlimt;

    int pivot = partition(data, begin, end,
                          midian3(data, begin, begin + (end - begin) / 2, end));
    intro_q_sort(data, pivot + 1, end, depthlimt);
    intro_q_sort(data, begin, pivot - 1, depthlimt);

  } else {
    insert_sort(&data[begin], end - begin + 1);
  }
}

void introsort(int *data, int size) {
  if (size != 1) {
    intro_q_sort(data, 0, size - 1, lg(size));

    insert_sort(data, size);
  }
}

void printarray(int *data, int size) {
  int i = 0;

  for (i = 0; i < size; i++) {
    printf("%d ", data[i]);

    if (i && (i % 15 == 0)) {
      printf("\n");
    }
  }

  printf("\n");
}

#define NUMCNT  50000

typedef void (*pfsortfunc)(int *data, int size);

typedef struct sort_item {
  char sortinfo[60];
  pfsortfunc on_sort;
} ST_sort_item;

static struct sort_item sort_list[] = { { "IntroSort 内省排序算法", introsort }, {
    "ShellSort 希尔排序算法", shell_sort }, { "QuickSort 快速排序算法", quick_sort }, {
    "HeapSort  堆排序算法  ", heap_sort }, { "MergeSort 归并排序算法", merge_sort } };

void main() {
  int *beforesort;
  int *tmpsort;
  int i;
  int sizelen = NUMCNT;
  int bytelen = sizelen * sizeof(int);
  int tmp = 0;

  srand (GetTickCount());

  for(  tmp = 0; tmp < 20; tmp++)
  {
    sizelen = NUMCNT * (tmp + 1);
    bytelen = sizelen * sizeof(int);
    beforesort = (int *)malloc(bytelen);
    tmpsort = (int *)malloc(bytelen);

    if (NULL == beforesort || NULL == tmpsort)
    {
      continue;
    }

    //获得原始数据
    for (i = 0; i < sizelen; i++)
    {
      beforesort[i] = rand() %1000000 + rand() % 9000;
    }

    printf("第 %d 次, 数据规模 %d\n", tmp + 1, sizelen);

    int k;
    for (k = 0; k < sizeof(sort_list) / sizeof(struct sort_item); k++)
    {

      struct sort_item *ptmpitem = &sort_list[k];

      memcpy(tmpsort, beforesort, bytelen);

      FILETIME ftKernelTimeStart, ftKernelTimeEnd;
      FILETIME ftUserTimeStart, ftUserTimeEnd;
      FILETIME ftDummy;
      __int64 qwKernelTimeElapsed, qwUserTimeElapsed, qwTotalTimeElapsed;

      int start1 = GetTickCount();

      GetThreadTimes(GetCurrentThread(), &ftDummy, &ftDummy,
      &ftKernelTimeStart, &ftUserTimeStart);    //取得开始时间

      ptmpitem->on_sort(tmpsort, sizelen);

      GetThreadTimes(GetCurrentThread(), &ftDummy, &ftDummy,
      &ftKernelTimeEnd, &ftUserTimeEnd);//取得结束时间
      int end1 = GetTickCount();

      qwKernelTimeElapsed = FileTimeToQuadWord(&ftKernelTimeEnd) - FileTimeToQuadWord(&ftKernelTimeStart);
      qwUserTimeElapsed = FileTimeToQuadWord(&ftUserTimeEnd) - FileTimeToQuadWord(&ftUserTimeStart);

      qwTotalTimeElapsed = qwKernelTimeElapsed + qwUserTimeElapsed;

      printf("%s: 耗时: %8d ms, %8ld 100ns\n", ptmpitem->sortinfo, end1 - start1, qwTotalTimeElapsed);

    }

    printf("\n");

    free(beforesort);
    free(tmpsort);
  }

  getchar();
}

四、各算法性能

第 1 次, 数据规模 50000
IntroSort 内省排序算法: 耗时:       16 ms,   156001 100ns
ShellSort 希尔排序算法: 耗时:       15 ms,   156001 100ns
QuickSort 快速排序算法: 耗时:       16 ms,   156001 100ns
HeapSort  堆排序算法  : 耗时:       16 ms,   156001 100ns
MergeSort 归并排序算法: 耗时:      172 ms,  1560010 100ns

第 2 次, 数据规模 100000
IntroSort 内省排序算法: 耗时:       31 ms,   312002 100ns
ShellSort 希尔排序算法: 耗时:       47 ms,   468003 100ns
QuickSort 快速排序算法: 耗时:       47 ms,   312002 100ns
HeapSort  堆排序算法  : 耗时:       47 ms,   468003 100ns
MergeSort 归并排序算法: 耗时:      577 ms,  5148033 100ns

第 3 次, 数据规模 150000
IntroSort 内省排序算法: 耗时:       31 ms,   312002 100ns
ShellSort 希尔排序算法: 耗时:       78 ms,   780005 100ns
QuickSort 快速排序算法: 耗时:       63 ms,   468003 100ns
HeapSort  堆排序算法  : 耗时:       93 ms,   624004 100ns
MergeSort 归并排序算法: 耗时:      484 ms,  4680030 100ns

第 4 次, 数据规模 200000
IntroSort 内省排序算法: 耗时:       46 ms,   468003 100ns
ShellSort 希尔排序算法: 耗时:      109 ms,  1092007 100ns
QuickSort 快速排序算法: 耗时:       63 ms,   624004 100ns
HeapSort  堆排序算法  : 耗时:       93 ms,   936006 100ns
MergeSort 归并排序算法: 耗时:      609 ms,  6084039 100ns

第 5 次, 数据规模 250000
IntroSort 内省排序算法: 耗时:       62 ms,   624004 100ns
ShellSort 希尔排序算法: 耗时:      141 ms,  1404009 100ns
QuickSort 快速排序算法: 耗时:       78 ms,   780005 100ns
HeapSort  堆排序算法  : 耗时:      124 ms,  1248008 100ns
MergeSort 归并排序算法: 耗时:      765 ms,  7488048 100ns

第 6 次, 数据规模 300000
IntroSort 内省排序算法: 耗时:       78 ms,   780005 100ns
ShellSort 希尔排序算法: 耗时:      172 ms,  1716011 100ns
QuickSort 快速排序算法: 耗时:       93 ms,   780005 100ns
HeapSort  堆排序算法  : 耗时:      141 ms,  1404009 100ns
MergeSort 归并排序算法: 耗时:     1623 ms, 15756101 100ns

第 7 次, 数据规模 350000
IntroSort 内省排序算法: 耗时:       93 ms,   936006 100ns
ShellSort 希尔排序算法: 耗时:      203 ms,  2028013 100ns
QuickSort 快速排序算法: 耗时:      109 ms,  1092007 100ns
HeapSort  堆排序算法  : 耗时:      188 ms,  1872012 100ns
MergeSort 归并排序算法: 耗时:     1965 ms, 19032122 100ns

第 8 次, 数据规模 400000
IntroSort 内省排序算法: 耗时:       94 ms,   936006 100ns
ShellSort 希尔排序算法: 耗时:      249 ms,  2340015 100ns
QuickSort 快速排序算法: 耗时:      125 ms,  1092007 100ns
HeapSort  堆排序算法  : 耗时:      234 ms,  2184014 100ns
MergeSort 归并排序算法: 耗时:     2200 ms, 21372137 100ns

第 9 次, 数据规模 450000
IntroSort 内省排序算法: 耗时:      156 ms,  1404009 100ns
ShellSort 希尔排序算法: 耗时:      266 ms,  2496016 100ns
QuickSort 快速排序算法: 耗时:      140 ms,  1404009 100ns
HeapSort  堆排序算法  : 耗时:      265 ms,  2652017 100ns
MergeSort 归并排序算法: 耗时:     2559 ms, 24960160 100ns

第 10 次, 数据规模 500000
IntroSort 内省排序算法: 耗时:      141 ms,  1404009 100ns
ShellSort 希尔排序算法: 耗时:      312 ms,  2808018 100ns
QuickSort 快速排序算法: 耗时:      156 ms,  1404009 100ns
HeapSort  堆排序算法  : 耗时:      281 ms,  2808018 100ns
MergeSort 归并排序算法: 耗时:     2714 ms, 26520170 100ns

第 11 次, 数据规模 550000
IntroSort 内省排序算法: 耗时:      141 ms,  1404009 100ns
ShellSort 希尔排序算法: 耗时:      343 ms,  3432022 100ns
QuickSort 快速排序算法: 耗时:      172 ms,  1716011 100ns
HeapSort  堆排序算法  : 耗时:      296 ms,  2964019 100ns
MergeSort 归并排序算法: 耗时:     3011 ms, 29484189 100ns

第 12 次, 数据规模 600000
IntroSort 内省排序算法: 耗时:      141 ms,  1404009 100ns
ShellSort 希尔排序算法: 耗时:      390 ms,  3900025 100ns
QuickSort 快速排序算法: 耗时:      187 ms,  1716011 100ns
HeapSort  堆排序算法  : 耗时:      359 ms,  3432022 100ns
MergeSort 归并排序算法: 耗时:     3260 ms, 32760210 100ns

第 13 次, 数据规模 650000
IntroSort 内省排序算法: 耗时:      172 ms,  1716011 100ns
ShellSort 希尔排序算法: 耗时:      390 ms,  3744024 100ns
QuickSort 快速排序算法: 耗时:      218 ms,  2184014 100ns
HeapSort  堆排序算法  : 耗时:      375 ms,  3588023 100ns
MergeSort 归并排序算法: 耗时:     3557 ms, 34476221 100ns

第 14 次, 数据规模 700000
IntroSort 内省排序算法: 耗时:      187 ms,  1872012 100ns
ShellSort 希尔排序算法: 耗时:      437 ms,  4368028 100ns
QuickSort 快速排序算法: 耗时:      218 ms,  2184014 100ns
HeapSort  堆排序算法  : 耗时:      406 ms,  4056026 100ns
MergeSort 归并排序算法: 耗时:     3838 ms, 37440240 100ns

第 15 次, 数据规模 750000
IntroSort 内省排序算法: 耗时:      202 ms,  2028013 100ns
ShellSort 希尔排序算法: 耗时:      468 ms,  4680030 100ns
QuickSort 快速排序算法: 耗时:      234 ms,  2340015 100ns
HeapSort  堆排序算法  : 耗时:      468 ms,  4524029 100ns
MergeSort 归并排序算法: 耗时:     4087 ms, 39936256 100ns

第 16 次, 数据规模 800000
IntroSort 内省排序算法: 耗时:      203 ms,  2028013 100ns
ShellSort 希尔排序算法: 耗时:      577 ms,  5772037 100ns
QuickSort 快速排序算法: 耗时:      250 ms,  2496016 100ns
HeapSort  堆排序算法  : 耗时:      484 ms,  4680030 100ns
MergeSort 归并排序算法: 耗时:     4368 ms, 41808268 100ns

第 17 次, 数据规模 850000
IntroSort 内省排序算法: 耗时:      234 ms,  2340015 100ns
ShellSort 希尔排序算法: 耗时:      561 ms,  5616036 100ns
QuickSort 快速排序算法: 耗时:      281 ms,  2652017 100ns
HeapSort  堆排序算法  : 耗时:      531 ms,  5304034 100ns
MergeSort 归并排序算法: 耗时:     4664 ms, 44772287 100ns

第 18 次, 数据规模 900000
IntroSort 内省排序算法: 耗时:      219 ms,  2184014 100ns
ShellSort 希尔排序算法: 耗时:      593 ms,  5616036 100ns
QuickSort 快速排序算法: 耗时:      297 ms,  2964019 100ns
HeapSort  堆排序算法  : 耗时:      561 ms,  5616036 100ns
MergeSort 归并排序算法: 耗时:     4914 ms, 47268303 100ns

第 19 次, 数据规模 950000
IntroSort 内省排序算法: 耗时:      249 ms,  2496016 100ns
ShellSort 希尔排序算法: 耗时:      624 ms,  6240040 100ns
QuickSort 快速排序算法: 耗时:      296 ms,  2964019 100ns
HeapSort  堆排序算法  : 耗时:      624 ms,  5772037 100ns
MergeSort 归并排序算法: 耗时:     5258 ms, 50388323 100ns

第 20 次, 数据规模 1000000
IntroSort 内省排序算法: 耗时:      281 ms,  2652017 100ns
ShellSort 希尔排序算法: 耗时:      702 ms,  7020045 100ns
QuickSort 快速排序算法: 耗时:      327 ms,  3120020 100ns
HeapSort  堆排序算法  : 耗时:      671 ms,  6708043 100ns
MergeSort 归并排序算法: 耗时:     5819 ms, 52572337 100ns