Java 语言实现的八大排序算法

Java 语言实现的八大排序算法

1、直接插入排序

基本思想：

基本思想：在要排序的一组数中，假设前面(n-1)[n>=2]个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

    /**
     * <h2>方法名称：直接插入排序 </h2>
     * <p>
     * 基本思想：
     * </p>
     * <p>
     * 在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，
     * 现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
     * 如此反复循环，直到全部排好顺序。
     * </p>
     * 
     */
    public void insertSort() {
        int a[] = {
                49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51
        };
        System.out.print("原始数据：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
        System.out.println();


        int temp = 0;
        for (int i = 1; i < a.length; i++) {
            int j = i - 1;
            temp = a[i];
            for (; j >= 0 && temp < a[j]; j--) {
                //将大于temp的值整体后移一个单位
                a[j + 1] = a[j];
            }
            a[j + 1] = temp;
        }

        System.out.print("排序结果：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
    }

2、希尔排序（最小增量排序）

基本思想：

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

    /**
     * <h2>
     *     希尔排序（最小增量排序）
     * </h2>
     * <p>
     *     基本思想：
     * </p>
     * <p>
     *     算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，
     *     每组中记录的下标相差d.对每组中全部元素进行直接插入排序，
     *     然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。
     *     当增量减到1时，进行直接插入排序后，排序完成。
     * </p>
     *   
     */
    public void shellSort() {
        int a[] = {1, 54, 6, 3, 78, 34, 12, 45, 56, 100};

        System.out.print("原始数据：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
        System.out.println();

        double d1 = a.length;
        int temp = 0;
        while (true) {
            d1 = Math.ceil(d1 / 2);
            int d = (int) d1;
            for (int x = 0; x < d; x++) {
                for (int i = x + d; i < a.length; i += d) {
                    int j = i - d;
                    temp = a[i];
                    for (; j >= 0 && temp < a[j]; j -= d) {
                        a[j + d] = a[j];
                    }
                    a[j + d] = temp;
                }
            }
            if (d == 1)
                break;
        }

        System.out.print("排序结果：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
    }

3、简单选择排序

基本思想：

在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

/**
     * <h2>
     * 简单选择排序
     * </h2>
     * <p>
     * 基本思想
     * </p>
     * <p>
     * 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
     * 然后在剩下的数当中再找最小的与第二个位置的数交换，
     * 如此循环到倒数第二个数和最后一个数比较为止。
     * </p>
     */
    public static void selectSort() {
        System.out.println(ClassName + "#" + Thread.currentThread().getStackTrace()[1].getMethodName());
        int a[] = {1, 54, 6, 3, 78, 34, 12, 45};
        System.out.print("原始数据：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
        System.out.println();

        int position = 0;
        for (int i = 0; i < a.length; i++) {

            int j = i + 1;
            position = i;
            int temp = a[i];
            for (; j < a.length; j++) {
                if (a[j] < temp) {
                    temp = a[j];
                    position = j;
                }
            }
            a[position] = a[i];
            a[i] = temp;
        }

        System.out.print("排序结果：");
        for (int i = 0; i < a.length; i++)
            System.out.print(String.format("%d;", a[i]));
        System.out.println();
    }

4、堆排序

基本思想：

堆排序是一种树形选择排序，是对直接选择排序的有效改进。 堆的定义如下：具有n个元素的序列（h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

例如：

初始序列：46,79,56,38,40,84
建堆： 交换，从堆中踢出最大数
依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。

////////////////////////堆排序//////////////////////////////////

    /**
     * <a href="http://mushiqianmeng.blog.51cto.com/3970029/738164/">
     * http://mushiqianmeng.blog.51cto.com/3970029/738164/
     * </a>
     * <p>
     * <h2>堆排序</h2>
     * <p>基本思想：</p>
     * <p>
     * 堆排序是一种树形选择排序,是对直接选择排序的有效改进。
     * </p>
     * <p>
     * 堆的定义如下：</p>
     * <p>
     * 具有n个元素的序列（h1,h2,…,hn),
     * 当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)时称之为堆。
     * 在这里只讨论满足前者条件的堆。
     * 由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。
     * 完全二叉树可以很直观地表示堆的结构。
     * 堆顶为根，其它为左子树、右子树。
     * 初始时把要排序的数的序列看作是一棵顺序存储的二叉树，
     * 调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。
     * 然后将根节点与堆的最后一个节点交换。
     * 然后对前面(n-1)个数重新调整使之成为堆。
     * 依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。
     * </p>
     * <p>
     * <p>
     * 从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。
     * 所以堆排序有两个函数组成。
     * 一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
     * </p>
     * <p>
     * <p>实例：</p>
     * <p>
     * 初始序列：46,79,56,38,40,84
     * 建堆： 交换，从堆中踢出最大数
     * 依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。
     * </p>
     * <p>
     * <p>“堆排序”，《算法导论》6.4章节</p>
     * 利用之前实现的构建MaxHeap和MaxHeapify算法完成排序。
     * <p>伪代码：</p>
     * <ul>
     * HEAPSORT(A)
     * <li>1 BUILD-MAX-HEAP(A)                     </li>
     * <li>2 for i ← length[A] downto 2           </li>
     * <li>3 do exchange A[1] ↔ A[i]              </li>
     * <li>4 heap-size[A] ← heap-size[A] - 1      </li>
     * <li>5 MAX-HEAPIFY(A, 1)                     </li>
     * <p>
     * </ul>
     * <p>
     * <p>堆排序，《算法导论》</p>
     * <p>
     * 原文摘要：
     * The heapsort algorithm starts by using BUILD-MAX-HEAP to build a max-heap on the input
     * array A[1  n], where n = length[A]. Since the maximum element of the array is stored at the
     * root A[1], it can be put into its correct final position by exchanging it with A[n].
     * If we now "discard" node n from the heap (by decrementing heap-size[A]), we observe that
     * A[1  (n -1)] can easily be made into a max-heap. The children of the root remain max-heaps,
     * but the new root element may violate the max-heap property. All that is needed to restore
     * the maxheap property, however, is one call to MAX-HEAPIFY(A, 1), which leaves a max-heap
     * in A[1 (n - 1)]. The heapsort algorithm then repeats this process for the max-heap of size
     * n - 1 down to a heap of size 2.
     * </p>
     * <p>
     * 复杂度：
     * </p>
     * <p>
     * 由之前分析可知，buildMaxHeap复杂度为O(n lg n)，运行一次。
     * maxHeapify的复杂度为O(lg n)，运行n-1次。
     * 综上，复杂度为O(n lg n)。
     * </p>
     */
    private static void heapSort() {
        System.out.println(ClassName + "#" + Thread.currentThread().getStackTrace()[1].getMethodName());
        int[] input = new int[]{16, 14, 10, 8, 7, 9, 3, 2, 4, 1};
        System.out.print("原始数据：");
        for (int i = 0; i < input.length; i++)
            System.out.print(String.format("%d;", input[i]));
        System.out.println();

        int length = input.length;
        //构造max-heap
        buildMaxHeap(input, length);//交换位置
        for (int i = length - 1; i > 0; i--) {
            int temp = input[i];
            input[i] = input[0];
            input[0] = temp;
            maxHeapify(input, 1, i);
        }

        System.out.print("排序结果：");
        for (int i = 0; i < input.length; i++)
            System.out.print(String.format("%d;", input[i]));
        System.out.println();
    }

    private static void buildMaxHeap(int[] array, int heapSize) {
        for (int i = heapSize / 2; i > 0; i--) {
            maxHeapify(array, i, heapSize);
        }
    }

    private static void maxHeapify(int[] array, int index, int heapSize) {
        int l = index * 2;
        int r = l + 1;
        int largest;
        //如果左叶子节点索引小于堆大小，比较当前值和左叶子节点的值，取值大的索引值
        if (l <= heapSize && array[l - 1] > array[index - 1]) {
            largest = l;
        } else {
            largest = index;
        }
        //如果右叶子节点索引小于堆大小，比较右叶子节点和之前比较得出的较大值，取大的索引值
        if (r <= heapSize && array[r - 1] > array[largest - 1]) {
            largest = r;
        }
        //交换位置，并继续递归调用该方法调整位置。
        if (largest != index) {
            int temp = array[index - 1];
            array[index - 1] = array[largest - 1];
            array[largest - 1] = temp;
            maxHeapify(array, largest, heapSize);
        }
    }
    ////////////////////////堆排序//////////////////////////////////

5、冒泡排序

基本思想：
>

6、快速排序

基本思想：
>

7、归并排序

基本思想：
>

8、基数排序

基本思想：
>