学习知识

  • 排序基本概念
  • 插入排序的实现方法及性能分析
  • 交换排序的实现方法及性能分析
  • 选择排序的实现方法及性能分析
  • 归并排序的实现方法及性能分析
  • 基数排序的实现方法及性能分析
  • 内部排序比较

一、 内排序

1. 概念

排序分类

1. 内部排序
  • 插入排序
  • 交换排序
  • 选择排序
  • 归并排序

2. 外部排序

3. 稳定排序: 若相同关键字间的前后位置关系在排序前与排序后保持一致，则称为稳定排序; 反之为不稳地排序

2. 直接插入排序(插入排序，稳定排序方法)

步骤： 假设待排序的记录存放在数组r[0…n-1]中

  1. 将r[i] 暂存在临时变量temp中
  2. 将temp 与r[j] (j=i-1,i-2,…,0)依次比较，若temp < r[j], 则将r[j]后移，直到temp>=r[j]为止
  3. 将temp插入第（j+1）的位置上
  4. 令i=1,2,..,n重复步骤2，3

示意图

数据结构基础学习之（内排序） - 图1

代码实现：

  1. /**
  2.      * 没有设置哨兵的插入排序
  3.      *
  4.      * @param elements
  5.      */
  6.     public void sortNoGuard(int[] elements) {
  7.         int i, j;
  8.         for (i = 1; i < elements.length; i++) {
  9.             //1. 将r[i]存放在临时变量temp中
  10.             int temp = elements[i];
  11.             //2. 将r[j] 与temp比较，当temp <=r[j], 将r[j]往后移
  12.             for (j = i - 1; j >= 0 && temp < elements[j]; j--) {
  13.                 elements[j + 1] = elements[j];
  14.             }
  15.             //3. 将temp插入j+1的位置
  16.             elements[j + 1] = temp;
  17.         }
  18.     }
  20.     /**
  21.      * 插入算法改进
  22.      */
  23.     public void sortWithGuard(int[] elements) {
  24.         int i, j;
  25.         int len = elements.length;
  26.         for (i = 1; i < len; i++) {
  27.             //elements[0]充当哨兵，避免边界判断
  28.             elements[0] = elements[i];
  30.             for (j = i - 1;  elements[0] < elements[j]; j--) {
  31.                 elements[j + 1] = elements[j];
  32.             }
  33.             //3. 将elements[i]插入j+1的位置
  34.             elements[j + 1] = elements[0];
  36.         }
  37.     }

算法分析

  1. 空间复杂度为： O(1)
  2. 时间复杂度：
  • 最好情况: 待排序序列为有序状态，则时间复杂度为：O(n)
  • 最坏和平均情况：
    比较次数： 数据结构基础学习之（内排序） - 图2#card=math&code=%5Csum%7Bi%3D1%7D%5E%7Bn-1%7Di%20%3D%20%5Cfrac12%20n%28n-1%29&id=JsRka) ; 移动次数为：![](https://g.yuque.com/gr/latex?%5Csum%7Bi%3D1%7D%5E%7Bn-1%7D(i%2B2)%20%3D%20%5Cfrac12%20n(n-1)%2B2n#card=math&code=%5Csum_%7Bi%3D1%7D%5E%7Bn-1%7D%28i%2B2%29%20%3D%20%5Cfrac12%20n%28n-1%29%2B2n&id=f5pUo)
    每次移动次数（i+2）:多出的两次移动次数是临时变量(如temp）保存待插入元素，最后又将temp移动到相应位置上
  • 所以总的平均比较与移动次数：
    数据结构基础学习之（内排序） - 图3
  • 因此，插入排序的时间复杂度为O(n^2)

3. 希尔排序(插入排序，不稳定排序)

步骤：

  1. 选择一个增量序列{d0,d1,d2,d3,…, dk-1}
  2. 根据当前的增量di将n条记录分成di个子表，每个子表中记录的下标相隔为di
  3. 对各个子表中的记录进行直接插入排序
  4. 令i=1，1,…, k-1, 重复步骤2~4

示意图

数据结构基础学习之（内排序） - 图4

代码实现

  1. /**
  2.      * 希尔排序
  3.      * <p>
  4.      * 时间复杂度： O(nlog2n)
  5.      *
  6.      * @param elements 待排序的序列
  7.      * @param d        增量集合
  8.      */
  9.     public static void sort(int[] elements, int[] d) {
  10.         int i, j;
  11.         for (int k = 0; k < d.length; k++) {
  13.             //对每个子表中的记录进行直接插入排序
  14.             int dk = d[k];
  15.             for (i = 0; i < elements.length; i++) {
  16.                 //存临时变量
  17.                 int temp = elements[i];
  18.                 //移动
  19.                 for (j = i - dk; j >= 0 && temp < elements[j]; j -= dk) {
  20.                     elements[j + dk] = elements[j];
  21.                 }
  22.                 elements[j + dk] = temp;
  23.             }
  24.         }
  25.     }

复杂度分析

  1. 空间复杂度：O(1)
  2. 时间复杂度：O(nlog2n)

4. 冒泡排序（交换排序，稳定）

步骤：

  1. 置初值 i=1
  2. 在无序序列{r[0],r[1],…, r[n-i]}中，从头至尾依次比较相邻的两个记录r[j]与r[j+1] (0<=j<=n-i-1), 若r[j]>r[j+1]则置换位置
  3. i=i+1
  4. 重复步骤2，3

示意图

数据结构基础学习之（内排序） - 图5

代码实现

  1. /**
  2.      * 冒泡排序
  3.      * <p>
  4.      * 空间复杂度：O(1)
  5.      * 时间复杂度： O(n^2)
  6.      *
  7.      * @param elements
  8.      */
  9.     public void sort(int[] elements) {
  11.         //标识序列是否发生交换
  12.         boolean swap_flag = true;
  13.         for (int i = 1, len = elements.length; i < len && swap_flag; i++) {
  14.             //标识没有发生交换
  15.             swap_flag = false;
  16.             for (int j = 0; j < len - i; j++) {
  17.                 if (elements[j] > elements[j + 1]) {
  18.                     int temp = elements[j];
  19.                     elements[j] = elements[j + 1];
  20.                     elements[j + 1] = temp;
  21.                     //标识交换
  22.                     swap_flag = true;
  23.                 }
  24.             }
  25.         }
  26.     }

复杂度

  1. 空间复杂度：O(1)
  2. 时间复杂度：
  • 最好情况：在已有序情况下，一趟比较下，没有发生交换，只需比较了n-1次，时间复杂度：O(n)
  • 最坏情况：在逆序情况下，总共要比较次数为(n-1)次，第 i 趟排序中，比较次数n-i, 移动次数为3*(n-i); 总比较次数为：$\sum{i=1}^{n-1} (n-i) = \frac12 n(n-1) $ ; 总移动次数：$\sum{i=1}^{n-1} 3(n-i) = \frac32 n(n-1) $
  • 平均时间复杂度：O(n^2)

5. 快速排序（交换，不稳定排序）

步骤：(partition 函数)

  1. 设置两个变量i,j, 初始值为low和hight，分别代表待排序序列的起始位置和终止位置
  2. 将第i个记录暂存在变量pivot中，即pivot=r[i]
  3. 从下标j的位置开始由后向前依次搜索，当找到一个比pivot的关键字值小的元素时，则将该元素 替换第 i 个 元素，然后i=i+1
  4. 从下标i的位置开始由前向后依次搜索，当找到一个比pivot的关键字值大的记录时，则将该该元素 替换第 j 个元素，然后j=j+1
  5. 重复步骤：3, 4 步，直到i==j为止
  6. r[i] = pivot

示意图

数据结构基础学习之（内排序） - 图6

代码实现

  1. /**
  2.      * @param i
  3.      * @param j
  4.      * @return
  5.      */
  6.     public static int partition(int[] elements, int i, int j) {
  7.         //把第i个元素作为支点
  8.         int pivot = elements[i];
  9.         ////从表的两端向中间扫描
  10.         while (i < j) {
  11.             //找到elements[i] <= elements[j]的下标
  12.             while (i < j && pivot <= elements[j]) {
  13.                 j--;
  14.             }
  16.             //当elements[i] <= elements[j], 交换位置
  17.             if (i < j) {
  18.                 elements[i] = elements[j];
  19.                 i++;
  20.             }
  22.             // elements[i] > elements[j]的下标
  23.             while (i < j && pivot > elements[j]) {
  24.                 i++;
  25.             }
  27.             //当elements[i] > elements[j], 交换位置
  28.             if (i < j) {
  29.                 elements[j] = elements[i];
  30.                 j--;
  31.             }
  32.         }
  33.         //支点记录到位
  34.         elements[i] = pivot;
  35.         //返回支点下标
  36.         return i;
  37.     }
  39.     /**
  40.      * 快速排序
  41.      *
  42.      * @param elements 待排序列
  43.      * @param low
  44.      * @param hight
  45.      */
  46.     public static void qSort(int[] elements, int low, int hight) {
  47.         if (low < hight) {
  48.             int pivotloc = partition(elements, low, hight);
  49.             // 低子表排序
  50.             qSort(elements, low, pivotloc - 1);
  51.             //高子表排序
  52.             qSort(elements, pivotloc + 1, hight);
  53.         }
  54.     }

算法分析

  • 空间复杂度：平均O(nlog2n)，最坏情况：O(n)
  • 时间复杂度：
    • 最好情况： O(nlog2n)
    • 最坏情况：O(n^2)
    • 平均： O(nlog2n)

6. 直接选择排序（Straight Selection sort不稳定排序）

算法步骤：

  1. 置i值为0
  2. 当i<n-1时，重复下列步骤：
  • 在无序子序列{r[i+1],…, r[n-1]}中选出一个关键字最小的记录r[min]
  • 若min != i , 则交换r[i]和r[min]的位置，否则不交换
  • i++

示意图

数据结构基础学习之（内排序） - 图7

代码实现

  1. public static void straightSelectionSort(int[] elements) {
  2.         int i, j, minIndex;
  3.         //n-1趟排序
  4.         for (i = 0; i < elements.length - 1; i++) {
  5.             //定义最小值索引为 i
  6.             minIndex = i;
  7.             //从i+1开始，找最小值
  8.             for (j = i + 1; j < elements.length; j++) {
  9.                 if (elements[j] < elements[minIndex]) {
  10.                     //记录最小值索引
  11.                     minIndex = j;
  12.                 }
  13.             }
  15.             //如果最小值索引不等于i, 则与i交换位置
  16.             if (minIndex != i) {
  17.                 int temp = elements[i];
  18.                 elements[i] = elements[minIndex];
  19.                 elements[minIndex] = temp;
  20.             }
  22.         }
  23.     }

算法分析

  • 空间复杂度: O(1)
  • 时间复杂度：
    • 外循环执行：n-1次； 内循环执行：n-1-i次
    • 总比较次数： $ \frac 12 n(n-1) $
    • 时间复杂度：O(n^2)

7. 树形选择排序(选择，稳定排序) :解决直接选择排序关键字多次比较问题

基本思想

  1. 首先对n各记录进行两两比较，比较的结果时把关键字值较小者作为优胜者上升为父结点，得到n/2个优胜者，然后再对这n/2个优胜者进行两两比较，重复直到选出一个最小关键字为止。这个过程可以用完全二叉树表示，称为胜者树

算法步骤：

  1. 初始化，令待排序结点的个数为n, 完全二叉树的叶子数leafSize(必须为2的幂), 胜者树所有结点TreeSize = 2* leafSize - 1; 叶结点开始下标loadIndex = leafSize - 1;
  2. 将待排序列复制到胜者树的叶结点中
  3. 构造胜利树，即叶结点两两比较，得到n/2个关键字值小的结点，保存为叶结点的父结点中，再对这些结点进行两两比较，直到得到最小的关键字保存再根结点为止。
  4. 调整胜者树： 先把胜者树的根结点保存到原数组中，再把具有根结点值所对叶子结点的值修改为“最大值”，然后从该结点开始，和其左（右）兄弟结点进行比较，修改从该叶结点到根的路径上各结点的值，直到根结点。
  5. 重复步骤4，直到得到n个结点为止。

示意图

数据结构基础学习之（内排序） - 图8

代码实现

  1. enum ActiveFlag {
  2.         ACTIVE,//参选
  3.         UNACTIVE;//不参选
  4.     }
  6.     /**
  7.      * 胜者树节点
  8.      */
  9.     class TreeNode {
  10.         //数据
  11.         public int data;
  12.         //该节点的索引
  13.         public int index;
  14.         //标识
  15.         public ActiveFlag active;
  16.     }
  19.     public void treeSelectionSort(int[] elements) {
  20.         //胜者树结点数组
  21.         TreeNode[] tree;
  22.         // 叶子节点数
  23.         int leafSize = 1;
  25.         //得到胜者树的叶子结点数， 该结点数必须为2的幂，才能构造成满二叉树
  26.         while (leafSize < elements.length) {
  27.             leafSize = leafSize * 2;
  28.         }
  31.         //胜者树的所有结点数
  32.         //二叉树的第i层结点数最多： 2^i
  33.         //二叉树的所有结点数最多： 2^k-1 = 2*2^i-1 (k为深度)
  34.         int treeSize = 2 * leafSize - 1;
  36.         // 叶子结点数存放的起始位置
  37.         int loadIndex = leafSize - 1;
  38.         //创建胜者树数组
  39.         tree = new TreeNode[treeSize];
  40.         // 待排序序列下标
  41.         int j = 0;
  42.         //把待排序结点复制到胜者树的叶子结点中
  43.         for (int i = loadIndex; i < treeSize; i++) {
  44.             tree[i] = new TreeNode();
  45.             tree[i].index = i;
  47.             if (j < elements.length) {
  48.                 tree[i].active = ActiveFlag.ACTIVE;
  49.                 tree[i].data = elements[j++];
  50.             } else {
  51.                 tree[i].active = ActiveFlag.UNACTIVE;
  52.             }
  53.         }
  55.         //先进行一次比较查找关键字值最小的结点
  56.         int i = loadIndex;
  57.         while (i > 0) {
  58.             j = i;
  59.             //处理各对比赛对手
  60.             while (j < 2 * i) {
  61.                 //完全二叉树的性质：
  62.                 //若i=0,则结点为根结点，没有双亲，若i>0,则它的双亲结点编号为 (i-1)/2
  63.                 if (tree[j + 1].active == ActiveFlag.UNACTIVE || (tree[j].data <= tree[j + 1].data)) {
  64.                     //左孩子胜者，晋级（成为父节点）
  65.                     tree[(j - 1) / 2] = tree[j];
  66.                 } else {
  67.                     //右孩子胜者，晋级（成为父节点）
  68.                     tree[(j - 1) / 2] = tree[j + 1];
  69.                 }
  70.                 //下一对比赛选手
  71.                 j += 2;
  72.             }
  73.             i = (i - 1) / 2;
  74.         }
  76.         //继续找出剩余最小
  77.         for (i = 0; i < elements.length - 1; i++) {
  78.             //将胜者树的根(最小者)存入数组
  79.             elements[i] = tree[0].data;
  80.             //该结点选手落选，不再比赛
  81.             tree[tree[0].index].active = ActiveFlag.UNACTIVE;
  82.             //调整胜者树，再次两两比赛，筛选出最小值
  83.             updateTree(tree, tree[0].index);
  84.         }
  85.         elements[elements.length - 1] = tree[0].data;
  86.     }
  89.     private void updateTree(TreeNode[] tree, int index) {
  90.         // 比赛对手的索引
  91.         int j;
  93.         if (index % 2 == 0) {
  94.             //index 为偶数，对手为左结点
  95.             tree[(index - 1) / 2] = tree[index - 1];
  96.         } else {
  97.             //index 为奇数，对手为右结点
  98.             tree[(index - 1) / 2] = tree[index + 1];
  99.         }
  100.         //最小记录输出，其对手上升到父结点
  101.         index = (index - 1) / 2;
  102.         while (index > 0) {
  103.             if (index % 2 == 0) {
  104.                 //index 为偶数，对手为左结点
  105.                 j = index - 1;
  106.             } else {
  107.                 //index 为奇数，对手为右结点
  108.                 j = index + 1;
  109.             }
  111.             //比赛对手中有一个为空
  112.             if (tree[index].active == ActiveFlag.UNACTIVE || tree[j].active == ActiveFlag.UNACTIVE) {
  113.                 if (tree[index].active == ActiveFlag.ACTIVE) {
  114.                     //i晋级，
  115.                     tree[(index - 1) / 2] = tree[index];
  116.                 } else {
  117.                     //落选
  118.                     tree[(index - 1) / 2] = tree[j];
  119.                 }
  120.             } else {
  121.                 if (tree[index].data <= tree[j].data) {
  122.                     tree[(index - 1) / 2] = tree[index];
  123.                 } else {
  124.                     tree[(index - 1) / 2] = tree[j];
  125.                 }
  126.             }
  127.             index = (index - 1) / 2;
  128.         }
  129.     }

算法分析

  • 空间复杂度：当对于含有n个记录的顺序表，当数据结构基础学习之（内排序） - 图9, 需要使用2n-1个结点来存放胜者树；当数据结构基础学习之（内排序） - 图10时， 需要使用数据结构基础学习之（内排序） - 图11个结点
  • 时间复杂度：树形选择排序过程可以用满二叉树来表示，对于有n个结点的满二叉树，其高度为数据结构基础学习之（内排序） - 图12, 除第一次筛选最小关键值的记录，需要比较n-1次，调整胜利树的比较次数为O(log2n),总的关键字比较次数为O(nlog2n)

8. 堆排序(不稳定排序)：解决树形排序占空间大问题

基本思想：

  1. 首先将这n条记录按关键字值的大小建成堆（初始堆），将堆顶元素r[0]与r[n-1]交换（或输出）；然后，将剩下的r[0]…r[n-2]序调整成堆，再r[0]与r[n-2]交换，又将剩下的r[0]…r[n-3]序列调整成堆，如此反复，便可以得到一个按关键字值有序的记录序列

a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
b.将堆顶元素与末尾元素交换，将最大元素”沉”到数组末端;
c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

  • 大顶堆可用于升序堆排序，将大顶堆的根节点值与最后一个节点值交换，剩余的元素在构建大顶堆，依次构建形成升序。具体可以看后面的堆排序。
  • 小顶堆用来找前K个最大值，用于堆排序的降序。

示意图

数据结构基础学习之（内排序） - 图13

算法步骤：

  • 筛选法调整堆步骤：
  1. 置初始值 i = low,j = 2*i+1,temp = r[i];
  2. 当j < hight时，重复以下操作
    1. 若j r[j+1], 则 j ++
    2. 若temp > r[j] , 则r[i] = r[j], j = 2*i+1; 否则j= higth +1
  3. r[i] = temp;

数据结构基础学习之（内排序） - 图14

  • 堆排序的步骤：
  1. 将待排序序列{r[0],r[1],r[2],…, r[n-1]}构造成一棵完全二叉树
  2. 将下标(n/2 - 1) 的记录作为开始调整的子树的根结点
  3. 找出此结点的两个孩子结点中的关键字值较小的，将其与父结点比较，若父结点的关键字值较大，则交换，然后以交换的子结点作为新的父结点，重复此步骤，直到没有子结点为止
  4. 以步骤3 中原来父结点所在位置往前推一个位置，作为新的调整的子树的根结点。继续重复步骤3，直到调整到树根。此时初始堆已形成
  5. 堆建成后，将树根与二叉树的最后一个结点交换后，再将最后一个结点输出(即输出原本的树根)，然后比较根结点的两个子结点，若左子结点的关键字值较小，则调整左子树；反之，调整右子树，使它再成为堆。
  6. 重复步骤5，直到二叉树仅剩下一个结点为止

数据结构基础学习之（内排序） - 图15

数据结构基础学习之（内排序） - 图16

代码实现：

  1. /**
  2.      * 筛选法调整堆
  3.      * <p>
  4.      * 以low为根结点的子树调整为小顶堆
  5.      */
  6.     public static void sift(int low, int hight, int[] elements) {
  7.         //定义根结点的索引
  8.         int i = low;
  9.         int j = 2 * i + 1;
  10.         //暂时值
  11.         int temp = elements[i];
  12.         //
  13.         while (j < hight) {
  15.             //比较左右子孩子的大小，找出最小的结点
  16.             if (j < hight - 1 && elements[j] > elements[j + 1]) {
  17.                 j++;
  18.             }
  19.             //父结点与最小子结点比较，如果父结点大于子节点，则交换位置
  20.             if (temp > elements[j]) {
  21.                 elements[i] = elements[j];
  22.                 //以j为父结点的子树，再次调整堆
  23.                 i = j;
  24.                 j = 2 * i + 1;
  25.             } else {
  26.                 //退出循环
  27.                 j = hight + 1;
  28.             }
  29.         }
  30.         elements[i] = temp;
  31.     }
  33.     /**
  34.      * 堆排序
  35.      *
  36.      * @param elements
  37.      */
  38.     public static void headSort(int[] elements) {
  39.         //创建堆
  40.         int len = elements.length;
  41.         //2. 以下标(n/2-1) 作为开始调整子树的根结点，进行筛选法调整堆
  42.         for (int i = (len / 2 - 1); i >= 0; i--) {
  43.             sift(i, len, elements);
  44.         }
  45.         for (int i = len - 1; i > 0; i--) {
  46.             //将根结点与二叉树最后一个结点交换
  47.             int temp = elements[0];
  48.             elements[0] = elements[i];
  49.             elements[i] = temp;
  50.             //使用筛选法调整堆法，调整为大顶堆
  51.             sift(0, i, elements);
  52.         }
  53.     }

算法分析：

  • 空间复杂度： 堆排序需要一个记录的辅助存储空间，空间复杂度为：O(1)
  • 时间复杂度：假设堆排序过程产生的二叉树高度为k, 则k = log2n + 1. 从树的根结点到叶子结点的筛选，关键字的比较次数至多2(k-1)次， 交换记录至多为k次。
    所以，在建好堆后，排序过程中的筛选次数不超过2 * [log2(n-1) + log2(n-2)+…+log2(2)]<2nlog2n. 在最坏的情况下，堆排序算法的时间复杂度O(nlog2n)

9. 归并排序(Merging Sort, 稳定排序)

基本思想

  1. 将待排序记录r[0] 到r[n-1] 看成是一个含有n个长度为1的有序子表
  2. 把这些子表依次进行两两归并，得到n/2个有序的子表；
  3. 然后，再把这n/2个有序的子表进行两两归并，
  4. 如此重复，直到最后得到一个长度为n的有序表为止

示意图

数据结构基础学习之（内排序） - 图17

代码实现

  1. /**
  2.      * 归并两个相邻的有序表r[h]-r[m] 和r[m+1]-r[t] 归并为r[h]-r[t]
  3.      *
  4.      * @param r     待排序序列
  5.      * @param order 归并后序列
  6.      * @param h     第一个有序表第一个元素的下标
  7.      * @param m     第一个有序表第最后元素的下标
  8.      * @param t     第二个有序表第最后元素的下标
  9.      */
  10.     public void merge(int[] r, int[] order, int h, int m, int t) {
  11.         int i = h, j = m + 1, k = h;
  13.         //将r中两个相邻子序列归并到order中
  14.         while (i <= m && j <= t) {
  15.             //较小值复制到order中
  16.             if (r[i] <= r[j]) {
  17.                 order[k++] = r[i++];
  18.             } else {
  19.                 order[k++] = r[j++];
  20.             }
  21.         }
  23.         //将前一个子序列剩余元素复制到order中
  24.         while (i <= m) {
  25.             order[k++] = r[i++];
  26.         }
  28.         //将后一个子序列剩余元素复制到order中
  29.         while (j <= t) {
  30.             order[k++] = r[j++];
  31.         }
  32.     }
  34.     /**
  35.      * 归并排序
  36.      *
  37.      * @param r     待排序序列
  38.      * @param order 归并结果序列
  39.      * @param s     待归并有序子序列的长度
  40.      * @param n     待排序序列长度
  41.      */
  42.     public void mergepass(int[] r, int[] order, int s, int n) {
  43.         //定义每对待合并表的第一个元素的下标，初始值为0
  44.         int p = 0;
  45.         //两两归并长度均为s的有序表
  46.         //p: 有序表的开始元素下标，p+s-1: 有序表的结束元素下标
  47.         while (p + 2 * s - 1 <= n - 1) {
  48.             merge(r, order, p, p + s - 1, p + 2 * s - 1);
  49.             p = p + 2 * s;
  50.         }
  51.         //归并最后两个长度不等的有序表
  52.         if (p + s - 1 < n - 1) {
  53.             merge(r, order, p, p + s - 1, n - 1);
  54.         } else {
  55.             //将剩余有序表复制到order中
  56.             for (int i = p; i <= n - 1; i++) {
  57.                 order[i] = r[i];
  58.             }
  59.         }
  60.     }
  63.     /**
  64.      * 二路归并算法
  65.      */
  66.     public void mergeSort(int[] elements) {
  67.         int s = 1;
  68.         int len = elements.length;
  69.         int[] temp = new int[len];
  70.         while (s < len) {
  72.             mergepass(elements, temp, s, len);
  73.             s = s * 2;
  74.             mergepass(temp, elements, s, len);
  75.             s = s * 2;
  76.         }
  77.     }

算法分析

  • 空间复制度：二路归并排序需要一个与待排序记录序列等长的辅助数组来存放排序过程，所以空间复杂度为O(n)
  • 时间复杂度：归并趟数：log2n, 每趟移动的次数为n , 所以二路归并排序的时间复杂度为O(nlog2n)

10. 基数排序(Radix Sort，稳定排序)

概念：

  1. 基数排序是一种借助于多关键字进行排序

示意图（图来自 skywang12345）

数据结构基础学习之（内排序） - 图18

基本思想

  1. 将一个序列中的逻辑关键字看成由d个关键字复合而成，并采用最低位优先方法对该序列进行多个关键字排序，即从最低关键字开始，将整个序列中的元素“分配”到rd个队列中，再依次“收集”成一个新的序列，如此重复进行d次，即完成排序过程

代码实现：

  1. /**
  2.      * 获取序列最大值
  3.      */
  4.     private static int getMax(int[] array) {
  5.         int max = array[0];
  6.         for (int i = 1; i < array.length; i++)
  7.             if (max < array[i])
  8.                 max = array[i];
  9.         return max;
  11.     }
  13.     /**
  14.      * 按对数组按照"某个位数"进行排序
  15.      *
  16.      * @param arr 数组
  17.      * @param n   数组长度
  18.      * @param exp 排序的位数
  19.      */
  20.     private static void countSort(int[] arr, int n, int exp) {
  21.         int output[] = new int[n]; //输出的数组
  22.         int i;
  23.         int count[] = new int[10];
  25.         // 保存出现的次数
  26.         //如：179,589 按个位排序（9） ；在count数组中的最后一个count[9] = 2;
  27.         for (i = 0; i < n; i++)
  28.             count[(arr[i] / exp) % 10]++;
  30.         // 更改count[i]。目的是让更改后的count[i]的值，是该数据在output[]中的位置。
  31.         for (i = 1; i < 10; i++)
  32.             count[i] += count[i - 1];
  34.         // 将数据存储到临时数组output[]中
  35.         for (i = n - 1; i >= 0; i--) {
  36.             output[count[(arr[i] / exp) % 10] - 1] = arr[i];
  37.             count[(arr[i] / exp) % 10]--;
  38.         }
  40.         // 将排序好的数据赋值给a[]
  41.         for (i = 0; i < n; i++)
  42.             arr[i] = output[i];
  43.     }
  45.     public static void radixSort(int arr[]) {
  46.         //获取最大值
  47.         int m = getMax(arr);
  48.         //长度
  49.         int n = arr.length;
  51.         // 从个位开始，对数组a按"指数"进行排序
  52.         for (int exp = 1; m / exp > 0; exp *= 10)
  53.             countSort(arr, n, exp);
  54.     }

11. 总结

  1. 各种内部排序算法的性能比较
  2. 选择排序算法建议：
  • 简单算法： 冒泡、直接选择，直接插入
  • 改进算法：希尔、堆、归并、快速
  • 若待排序记录的个数n越小，采用简单排序算法合适，反之，采用改进排序算法合适
  • 若记录序列初始状态基本有序，则应选择直接插入排序、冒泡排序
  1. 各个排序比较
    数据结构基础学习之（内排序） - 图19