Java☞排序算法

冒泡排序

冒泡排序的思路：如果有n个元素，需要进行n-1轮的比较，每一轮比较都是对比相邻两个数字，把大数放后面（假设是升序），那么一轮比较之后，最大的数就放到了数组末尾，依次进行第2轮，3轮。。。
冒泡排序代码：

package cn.ihep.sort;

import org.junit.Test;

/**
 * 排序算法
 * 
 * @author xiaoming
 *
 */
public class SortedClass {
    private int[] nums = { 18, 3, 20, 45, 0, -1, 11, 9, 4 };

    // 冒泡排序--重点：每一轮都会把余下数里面最大的那个数挪到右边
    @Test
    public void bubble() {
        int temp = 0;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < nums.length - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        for (int n : nums) {
            System.out.print(n + ",");
        }
    }

    //上面的方法是最原始的，我们可以稍微改进一点，如下：
    @Test
    public void bubble2() {
        int temp = 0;
        boolean flag = false;
        for (int i = 1; i < nums.length; i++) {
            flag = false;
            for (int j = 0; j < nums.length - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false) {
                //这个时候证明在上一轮的排序中没有发生位置互换，也就意味着整个数组已经有序。
                break;
            }
        }
        for (int n : nums) {
            System.out.print(n + ",");
        }
    }
}

时间复杂度分析：
最坏情况下，数组刚好是逆序的，那么需要对比n(n-1)/2次，移动3n(n-1)/2次，因此最坏情况下时间复杂度为O(n^2).
最好情况下，数组刚好有序，那么需要对比n(n-1)/2次，移动0次，因此最好情况下时间复杂度为O(n).
稳定性：因为比较过程中两个相邻元素相等我们不会将他们交换位置，所以冒泡算法不会改变相同元素的下标，所以冒泡排序是一个稳定的排序。

快速排序

快速排序的原理：找一个基准值（一般是第一个元素），把比基准值大的放后面，比基准值小的放前面，具体的步骤是：先从后往前对比，如果发现第一个比基准值小的，交换位置；然后从前往后比，发现第一个比基准值大的，交换位置。这是一轮操作，一轮操作之后会把基准值放到应该放的位置，然后从基准值这把数组分成左右两部分，分别进行上述操作，直至每一部分都有序。代码如下：

package sortedTest;

public class FastSorted {

    public static void main(String[] args) {
        int[] num = { 54, 2, -2, 0, 1, 20 };
        FastSorted f = new FastSorted();
        f.quickSort(num, 0, num.length - 1);
        for (int n : num) {
            System.out.print(n + " ,");
        }
    }

    /**
     * 递归，快速排序
     * 
     * @param num
     * @param low
     * @param high
     * @return
     */
    public void quickSort(int[] num, int low, int high) {
        if (low < high) {
            int mid = getMiddle(num, low, high);
            quickSort(num, low, mid - 1);
            quickSort(num, mid + 1, high);
        }
    }

    /**
     * 获取基准值的位置（中轴位置）
     * 
     * @param num
     * @param low
     * @param high
     * @return
     */
    public int getMiddle(int[] num, int low, int high) {
        int temp = num[low];
        while (low < high) {
            while (low < high && num[high] >= temp)
                high--;
            num[low] = num[high];
            while (low < high && num[low] <= temp)
                low++;
            num[high] = num[low];
        }
        num[low] = temp;
        return low;
    }
}

在最优的情况下，快速排序算法的时间复杂度为O(nlogn)。
在最坏的情况下，快速排序算法的时间复杂度为O(n^2)。
平均时间复杂度O(nlogn)。
快速排序是个不稳定的排序。

插入排序

原理：将一个记录插入到一个已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

package cn.ihep.sort;

import org.junit.Test;

/**
 * 插入排序
 * 
 * @author xiaoming
 *
 */
public class InsertSort {

    public void insertSort(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            int key = nums[i];
            int j = i-1;
            while (j >= 0 && nums[j]>key) {
                nums[j+1]=nums[j];
                j--;
            }
            nums[j+1] = key;
        }
    }

    public void print(int[] nums) {
        for (int n : nums) {
            System.out.print(n + " ");
        }
    }

    @Test
    public void test() {
        int[] nums = { 234, 0, -1, 56, 2, 89 };
        insertSort(nums);
        print(nums);
    }
}
----------------
输出结果：
-1 0 2 56 89 234 

直接插入排序的时间复杂度
最好情况:O(n^2)
最坏情况: O(n^2)
平均时间复杂度:O(n^2)
空间复杂度:O(1)

希尔排序

希尔排序又叫递减增量排序，是插入排序的一种更高效的改进版本。希尔排序是非稳定 排序。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一一个位置
  希尔排序是先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

基本思想：
初始时设定一个较大步长gap，然后将数组中的元素按照这个步长进行两个元素的对比，按照这个步长比较完整个数组算是一趟；然后将步长gap缩小（可能是缩小一倍），再进行第二趟比较，知道步长gap等于1，也就是直接插入排序的算法，完成排序。
步长gap的选择是希尔排序的关键，一般来说最简单的步长取值是初次取数组长度一半为增量，之后依次减半，直到增量为1.更好的步长序列，参考维基百科：已知的最好步长序列是由Sedgewick提出的(1, 5, 19, 41, 109,...);
另一个在大数组中表现优异的步长序列是：(1, 9, 34, 182, 836, 4025, 19001, 90358, 428481, 2034035, 9651787, 45806244, 217378076, 1031612713,…)
算法步骤：

image.png

代码实现

package cn.ihep.sort;

import org.junit.Test;

/**
 * 希尔排序
 * 
 * @author xiaoming
 *
 */
public class HillSortTest {

    @Test
    public void hillSortTest() {
        int[] nums = { 110, 1, -1, 0, 45, 78, 23, 4, 9 };
        hillSort(nums);
        print(nums);
    }

    public void hillSort(int[] nums) {
        int h = 1;
        while (h < nums.length/3) {
            h = 3 * h + 1;
        }
        for (; h > 0; h /= 3) {
            for (int i = h; i < nums.length; i++) {
                int temp = nums[i];
                int j = i - h;
                while (j >= 0 && nums[j] > temp) {
                    nums[j + h] = nums[j];
                    j -= h;
                }
                nums[j + h] = temp;
            }
        }
    }

    public void print(int[] nums) {
        for (int n : nums) {
            System.out.print(n+" ");
        }
    }
}
-------------------------
输出结果：
-1 0 1 4 9 23 45 78 110 

希尔排序的复杂度分析：
最好情况：O(log2 n)
最坏情况：O(log2 n)
平均情况：O(log2 n)
空间复杂度：O(1)
最后， 希尔排序更高效的原因是它权衡了子数组的规模和有序性。排序之初，各个子数组都很短，排序之后子数组都是部分有序的，这两种情况都很适合插入排序。

简单选择排序

选择排序是一种简单直观的排序算法。它的工作原理是，首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末位。以此类推，直到所有元素均排序完毕。
代码实现

package cn.ihep.sort;

import org.junit.Test;

/**
 * 简单选择排序
 * 
 * @author xiaoming
 *
 */
public class SelectSortTest {

    @Test
    public void testSelectSort() {
        int[] nums = { 110, 1, -1, 0, 45, 78, 23, 4, 9 };
        selectSort(nums);
        print(nums);
    }

    public void selectSort(int[] nums) {
        int n = 0;
        while (n < nums.length - 1) {
            int key = n;
            for (int i = n + 1; i < nums.length; i++) {
                if (nums[i] < nums[key])
                    key = i;
            }
            if (key != n) {
                int temp = nums[n];
                nums[n] = nums[key];
                nums[key] = temp;
            }
            n++;
        }
    }

    public void print(int[] nums) {
        for (int n : nums) {
            System.out.print(n + " ");
        }
    }
}
----------------------
输出结果：
-1 0 1 4 9 23 45 78 110 

复杂度分析：
最好情况：O(n^2)
最坏情况：O(n^2)
平均时间复杂度：O(n^2)
空间复杂度：O(1)
总结：选择排序的简单和直观名副其实，这也造就了它”出了名的慢性子”，无论是哪种情况，哪怕原数组已排序完成，它也将花费将近n²/2次遍历来确认一遍。即便是这样，它的排序结果也还是不稳定的。 唯一值得高兴的是，它并不耗费额外的内存空间。

堆排序

堆的定义如下：n个元素的序列{k1,k2,..,kn}
当且仅当满足下关系时，称之为堆。

image.png

把此序列对应的二维数组看成一个完全二叉树。那么堆的含义就是：完全二叉树中任何一个非叶子节点的值均不大于（或不小于）其左，右孩子节点的值。 由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。因此我们可使用大顶堆进行升序排序, 使用小顶堆进行降序排序。
基本思想
以大顶堆为例，堆排序的过程就是将待排序的序列构造成一个堆，选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序。

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆函数，二是反复调用建堆函数以选择出剩余未排元素中最大的数来实现排序的函数。

对于堆节点的访问：

• 父节点i的左子节点在位置：(2*i+1);
• 父节点i的右子节点在位置：(2*i+2);
• 子节点i的父节点在位置：floor((i-1)/2);

代码如下：

package cn.ihep.sort;

import org.junit.Test;

/**
 * 堆排序---大顶
 * 
 * @author xiaoming
 *
 */
public class HeapSortTest {

    @Test
    public void test() {
        int[] nums = { 110, 1, -1, 0, 45, 78, 23, 4, 9 };
        heapChange(nums);
        print(nums);
    }

    // 大顶堆调整--堆顶与最后一个元素换位置
    public void heapChange(int[] nums) {
        for (int i = nums.length - 1; i > 0; i--) {
            buildHeap(nums, i);
            int temp = nums[0];
            nums[0] = nums[i];
            nums[i] = temp;
        }
    }

    // 构建大顶堆
    public void buildHeap(int[] nums, int n) {
        int child;
        for (int i = (n - 1) / 2; i >= 0; i--) {
            // 左子节点
            child = 2 * i + 1;
            // 如果右节点存在，且右节点大于左节点
            if (child != n && nums[child] < nums[child + 1]) {
                int temp = nums[child];
                nums[child] = nums[child + 1];
                nums[child + 1] = temp;
            }
            // 对比根节点和子节点
            if (nums[i] < nums[child]) {
                int temp = nums[i];
                nums[i] = nums[child];
                nums[child] = temp;
            }
        }
    }

    public void print(int[] nums) {
        for (int n : nums) {
            System.out.print(n + " ");
        }
    }
}
-----------------------
output:
-1 0 1 4 9 23 45 78 110 

复杂度分析
最好情况：O(nlog2 n)
最坏情况：O(nlog2 n)
平均复杂度：O(nlog2 n)
空间复杂度：O(1)
总结：
由于堆排序中初始化堆的过程中比较次数较多, 因此它不太适用于小序列。 同时由于多次任意下标相互交换位置, 相同元素之间原本相对的顺序被破坏了, 因此, 它是不稳定的排序。

归并排序

归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即第一步先把待排序序列分成若干个子序列，每个子序列都是有序的，第二步在再把有序子序列合并为整体有序序列。
主要就是：拆分+合并
代码实现：

package cn.ihep.sort;

import org.junit.Test;

/**
 * 归并排序
 * 
 * @author xiaoming
 *
 */
package cn.ihep.sort;

import org.junit.Test;

/**
 * 归并排序
 * 
 * @author xiaoming
 *
 */
public class MergeSortTest {

    static int[] temp;

    @Test
    public void test() {
        int[] nums = { 345, 1, 0, -1, -57, 34, 2 };
        // 一次性分配空间
        temp = new int[nums.length];
        sort(nums, 0, nums.length - 1);
        for (int n : nums)
            System.out.print(n + " ");
    }

    public void sort(int[] nums, int low, int high) {
        // 递归划分+合并
        if (low < high) {
            int mid = (low + high) / 2;
            sort(nums, low, mid);
            sort(nums, mid + 1, high);
            merge(nums, low, mid, high);
        }
    }

    public void merge(int[] nums, int low, int mid, int high) {
        int i = low;
        int j = mid + 1;
        int t = low;
        while (i != mid + 1 && j != high + 1) {
            // i和j相当于两个子序列的头部指针，依次对比其值
            if (nums[i] > nums[j]) {
                temp[t++] = nums[j++];
            } else {
                temp[t++] = nums[i++];
            }
        }
        // 两个子序列可能有一个先合并完到temp中
        while (i != mid + 1)
            temp[t++] = nums[i++];
        while (j != high + 1)
            temp[t++] = nums[j++];
        for (int x = low; x <= high; x++)
            nums[x] = temp[x];
    }
}
------------------------
output:
-57 -1 0 1 2 34 345 

复杂度分析：
最好情况：O(nlog2 n)
最坏情况：O(nlog2 n)
平均时间复杂度：O(nlog2 n)
空间复杂度：O(n)

基数排序

原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
基数排序按照优先从高位或低位来排序有两种实现方案：

• MSD（Most significant digital） 从最左侧高位开始进行排序。
• LSD （Least significant digital）从最右侧低位开始进行排序。

算法描述：
我们以LSD为例，从最低位开始，具体算法描述如下：

• 取得数组中的最大数，并取得位数；
• arr为原始数组，从最低位开始取每个位组成radix数组；
• 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
  代码如下：

package cn.ihep.sort;

import org.junit.Test;

/**
 * 基数排序
 * 
 * @author xiaoming
 *
 */
public class RadixSortTest {

    @Test
    public void test() {
        int[] nums = { 89, 234, 0, 78, 13, 34, 5 };
        radixSort(nums);
        for (int n : nums)
            System.out.print(n + " ");
    }

    public int getMax(int[] nums) {
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (max < nums[i])
                max = nums[i];
        }
        return max;
    }

    public void radixSort(int[] nums) {
        int times;
        int max = getMax(nums);
        int k = 0;
        int[][] bucket = new int[10][nums.length];
        // order保存 每个桶里有多少数字
        int[] order = new int[10];
        // 根据各个位数，分析要对比的次数
        for (times = 1; max / times > 0; times *= 10) {
            for (int n : nums) {
                // digit为某个位上的值
                int digit = (n / times) % 10;
                // 把原数组中的值n放到bucket二维数组上
                bucket[digit][order[digit]] = n;
                order[digit]++;
            }
            for (int i = 0; i < nums.length; i++) {
                if (order[i] != 0) {
                    // 说明在某个位上，有i出现
                    for (int j = 0; j < order[i]; j++) {
                        nums[k] = bucket[i][j];
                        k++;
                    }
                }
                //桶子置零，方便下一轮使用
                order[i]=0;
            }
            k = 0;
        }
    }
}

复杂度分析：(d为位数，r为基数，n为原数组元素个数)
最好情况：O(d(n+r))
最坏情况：O(d(n+r))
平均时间复杂度：O(d*(n+r))
空间复杂度：O(n+r)
在基数排序中，因为没有比较操作，所以在复杂度上，最好的情况与最坏的情况在时间上是一致的。