Java中的排序

Java中的排序

排序方法的选择

1.若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。

2.若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；

3.若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

衡量排序算法的优劣：

1.时间复杂度：分析关键字的比较次数和记录的移动次数

2.空间复杂度：分析排序算法中需要多少辅助内存

3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类：内部排序和外部排序。

1.内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。

2.外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

常用的内部排序

选择排序

基本原理：将待排序的元素分为已排序（初始为空）和未排序两组，依次将未排序的元素中值最小的元素放入已排序的组中。直接选择排序简单直观，但性能略差；堆排序是一种较为高效的选择排序方法，但实现起来略微复杂。

基本过程：1.在一组元素R[i]到R[n]中选择具有最小关键字的元素。2.若它与这组元素中的第一个元素，则将它与这组元素中的第一个元素对调。3.去除具有最小关键字的元素，在剩下的元素中重复1、2步，直到剩余元素只有一个为止。

算法的时间效率：无论初始状态如何，在第i趟排序中选择最小关键码的元素，需做n-i次比较，因此总的比较次数为：n(n-1)/2 = O(n^2)

算法的空间效率：空间效率很高，只需要一个附加程序单元用于交换，其空间效率为：O(1)

算法的稳定性：不稳定

public class SelectSort {    public static void selectSort(DataWrap[] data) {        System.out.println("开始排序");        int arrayLength = data.length;        for (int i = 0; i < arrayLength - 1; i++) {            for (int j = i + 1; j < arrayLength; j++) {                if (data[i].compareTo(data[j]) > 0) {                    DataWrap temp = data[i];                    data[i] = data[j];                    data[j] = temp;                }            }            System.out.println(java.util.Arrays.toString(data));        }    }    public static void main(String[] args) {        DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),                new DataWrap(21, "*"), new DataWrap(23, ""),                new DataWrap(-30, ""), new DataWrap(-49, ""),                new DataWrap(21, ""), new DataWrap(30, "*"),                new DataWrap(30, "") };        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));        selectSort(data);        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));    }}

堆排序

算法的时间效率：假设有n个数据，需要进行n-1次建堆，每次建堆本身耗时 logn，则其时间效率为O(nlogn)

算法的空间效率：空间效率很高，只需要一个附加程序单元用于交换，其空间效率为O(1)

算法的稳定性：不稳定

public class HeapSort {    public static void heapSort(DataWrap[] data) {        System.out.println("开始排序");        int arrayLength = data.length;        // 循环建堆        for (int i = 0; i < arrayLength - 1; i++) {            // 建堆            builMaxdHeap(data, arrayLength - 1 - i);            // 交换堆顶和最后一个元素            swap(data, 0, arrayLength - 1 - i);            System.out.println(java.util.Arrays.toString(data));        }    }    // 对data数组从0到lastIndex建大顶堆    private static void builMaxdHeap(DataWrap[] data, int lastIndex) {        // 从lastIndex处节点（最后一个节点）的父节点开始        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {            // k保存当前正在判断的节点            int k = i;            // 如果当前k节点的子节点存在            while (k * 2 + 1 <= lastIndex) {                // k节点的左子节点的索引                int biggerIndex = 2 * k + 1;                // 如果biggerIndex小于lastIndex，即biggerIndex +1                // 代表k节点的右子节点存在                if (biggerIndex < lastIndex) {                    // 如果右子节点的值较大                    if (data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0) {                        // biggerIndex总是记录较大子节点的索引                        biggerIndex++;                    }                }                // 如果k节点的值小于其较大子节点的值                if (data[k].compareTo(data[biggerIndex]) < 0) {                    // 交换它们                    swap(data, k, biggerIndex);                    // 将biggerIndex赋给k，开始while循环的下一次循环                    // 重新保证k节点的值大于其左、右节点的值                    k = biggerIndex;                } else {                    break;                }            }        }    }    // 交换data数组中i、j两个索引处的元素    private static void swap(DataWrap[] data, int i, int j) {        DataWrap temp = data[i];        data[i] = data[j];        data[j] = temp;    }    public static void main(String[] args) {        DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),                new DataWrap(21, "*"), new DataWrap(23, ""),                new DataWrap(-30, ""), new DataWrap(-49, ""),                new DataWrap(21, ""), new DataWrap(30, "*"),                new DataWrap(30, "")};        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));        heapSort(data);        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));    }}

冒泡排序

相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。

算法的时间效率：从冒泡排序的算法可以看出，若待排序的元素为正序，则只需进行一趟排序，比较次数为n-1次，移动元素次数为0；若待排序的元素为逆序，则需要进行n-1趟排序，比较次数为(n^2-n)/2 ，移动次数为3(n^2-n)/2，因此时间复杂度为O(n^2)

算法的空间效率：空间效率很高，只需要一个附加程序单元用于交换，其空间效率为O(1)

算法的稳定性：稳定

public class BubbleSort {    public static void bubbleSort(DataWrap[] data) {        System.out.println("开始排序");        int arrayLength = data.length;        for (int i = 0; i < arrayLength - 1; i++) {            boolean flag = false;            for (int j = 0; j < arrayLength - 1 - i; j++) {                if (data[j].compareTo(data[j + 1]) > 0) {                    DataWrap temp = data[j + 1];                    data[j + 1] = data[j];                    data[j] = temp;                    flag = true;                }            }            System.out.println(java.util.Arrays.toString(data));            if (!flag)                break;        }    }    public static void main(String[] args) {        DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),                new DataWrap(21, "*"), new DataWrap(23, ""),                new DataWrap(-30, ""), new DataWrap(-49, ""),                new DataWrap(21, ""), new DataWrap(30, "*"),                new DataWrap(30, "")};        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));        bubbleSort(data);        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));    }}

快速排序

算法的时间效率：时间效率很好，因为每趟能确定的元素都呈指数增长，故时间复杂度为log(n+1)

算法的空间效率：由于使用递归，而递归使用栈，因此空间效率最优时为log(n)

算法的稳定性：由于包含跳跃式交换，因此不稳定

public class QuickSort {    private static void swap(DataWrap[] data, int i, int j) {        DataWrap temp = data[i];        data[i] = data[j];        data[j] = temp;    }    private static void subSort(DataWrap[] data, int start, int end) {        if (start < end) {            DataWrap base = data[start];            int i = start;            int j = end + 1;            while (true) {                while (i < end && data[++i].compareTo(base) <= 0)                    ;                while (j > start && data[--j].compareTo(base) >= 0)                    ;                if (i < j) {                    swap(data, i, j);                } else {                    break;                }            }            swap(data, start, j);            subSort(data, start, j - 1);            subSort(data, j + 1, end);        }    }    public static void quickSort(DataWrap[] data){        subSort(data,0,data.length-1);    }    public static void main(String[] args) {        DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),                new DataWrap(21, "*"), new DataWrap(23, ""),                new DataWrap(-30, ""), new DataWrap(-49, ""),                new DataWrap(21, ""), new DataWrap(30, "*"),                new DataWrap(30, "") };        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));        quickSort(data);        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));    }}