排序算法学习

前言

算法,其实算术题的解法，如同我们读书时做的数学题。一道关于排序的算术题，有几种解法就有几种思路。一般程序员可能一辈子都用不上排序算法，但是我们可以学习其中的解题思路，融会贯通后，可以对我们实际开发有指导作用。

题目

 数量为10的无序数组，将其按照升序排列。例如

选择排序

如果这样的数组放在面前,要你手工排序,一般人都是先浏览一遍,找出最小的19拿走,再浏览剩下的,再拿走最小的22，直到全部取走，到手的就是有序集合。其实这种做法就是选择排序法。

当然，程序实现上为了节省内存，会用交换代替取的。如

public class SelectSort {
    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        int length = array.length;
        for (int i = 0; i < length-1; i++) {
            int min = i;
            for (int j = i + 1; j < length; j++) {
                if (array[min] > array[j]) {
                    min = j;
                }
            }
            swap(array,i,min);
        }
        return array;
    }

    static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

冒泡排序

冒泡排序形象点描述是用泡泡装着最右的元素，不断向左前进比较，泡泡里面的元素较大就交换，较小就继续前进,直到到达最左。

public class BubbleSort {
    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        int length = array.length;
        for (int i = 0; i < length; i++) {
            for (int j = length - 1; j > i; j--) {
                if (array[j] < array[j - 1]) {
                    swap(array, j, j - 1);
                }
            }
        }
        return array;
    }
    static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

插入排序

插入排序的主要思路是将数组分成有序和无序两虚拟集合。

初始状态时,38是有序集合,19到66都是无序集合。

然后将无序集合的第一个元素19存起来，从右往左对比有序集合中的元素，如

和有序集合中的38比较，38较大，移动38到下一个位置，当19走到有序集合的尽头或者遇到比19小的元素时，插入19，如

现在19和38是有序集合的元素，其余的都是无序集合，循环上述操作，直到无序集合的最后一个元素。代码实现如下

public class InsertSort {
    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        int length = array.length;
        for (int i = 1; i < length; i++) {
            int tmp = array[i];
            int index = i;
            for (int j = i - 1; j >= 0; j--) {
                if (tmp < array[j]) {
                    array[j + 1] = array[j];
                    index = j;
                } else {
                    break;
                }
            }
            array[index] = tmp;
        }
        return array;
    }
}

希尔排序

上面的插入排序是通过不断移动较大的元素后移以达到排序的目的，例如4要移动最前面，要移动5次前面的元素。如果要优化插入排序的话，可以从减少移动次数下手，所以希尔排序应运而生。

 希尔排序引入步长的概念，将数组分成数个虚拟数组，例如步长为10/2=5，那么分组后如下，同色的为一组

然后每一组使用插入排序法排序后，如

然后再缩小步长，例如步长为5/2向下取整2，分成

再对这两组进行插入排序，如

缩小步长，步长为2/1=1，这个时候就相当于普通的插入排序。

代码实现上，和插入排序相似，只不过再最外层加多一个缩小步长的循环，直到步长小于1，如

public class ShellSort {
    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        int gap = array.length/2;
        while (gap >= 1) {
            for (int i = gap; i< array.length; i++) {
                int tmp = array[i];
                int index = i;
                for (int j = i-gap; j >= 0; j = j - gap) {
                    if (tmp < array[j]) {
                        array[j + gap] = array[j];
                        index = j;
                    } else {
                        break;
                    }
                }
                array[index] = tmp;
            }
            gap = gap / 2;
        }
        return array;
    }
}

快速排序

顾名思义,在一般情况下,快速排序是速度最快的排序。

它的解题思路是选一个基准值出来，例如数组第一个位置38，通过移动位置分成三个虚拟数组，左边是小于等于38的，中间是38，右边是大于等于38的。

首先先从右边遍历和对比大小，直到找到小于38的值停下，然后从左边遍历，直到找到大于38的停下，如

这个时候交换左右位置，如下

右边继续遍历，找到小于38的21值停下来，左边开始遍历，到21的位置时，发现左边等于右边，也停下来

这个时候，除了左右到达的位置，左边走过的路都是小于等于38的，右边走过的路都是都是大于等于38，那么只要将基准值和21交换就完成三个虚拟数组的划分了

之后，将左右数组重复上面步骤，最终会得到一个有序数组。

public class QuickSort {

    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        quickSort(array, 0, sourceArray.length - 1);
        return array;
    }

    static void quickSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        int low = left;
        int high = right;
        int tmp = array[left];

        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            while (left < right && array[left] <= tmp) {
                left++;
            }
            if (left != right) {
                swap(array, left, right);
            }
        }
        swap(array, low, left);
        quickSort(array, low, left - 1);
        quickSort(array, left + 1, high);
    }

    static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

归并排序

归并排序常见于数据库排序,将扫描的数据生成多个磁盘文件,再归并排序。

它的主要思路比较简单粗暴，就是是将数组通过递归地方式拆分到单个元素，再通过不断两两合并成为有序数组。

我觉得它的精髓在于递归方式的运用，发散性地递归。

public class MergeSort {
    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);
        int length = array.length;
        if (length == 1) {
            return array;
        }
        int middle = (int) Math.floor(length / 2);

        int[] leftArray = Arrays.copyOfRange(sourceArray, 0, middle);
        int[] rightArray = Arrays.copyOfRange(sourceArray, middle, length);

        return merge(sort(leftArray), sort(rightArray));
    }

    static int[] merge(int[] leftArray, int[] rightArray) {
        int[] array = new int[leftArray.length + rightArray.length];
        int i = 0, j = 0, k = 0;
        while (i < leftArray.length && j < rightArray.length) {
            if (leftArray[i] < rightArray[j]) {
                array[k++] = leftArray[i++];
            } else {
                array[k++] = rightArray[j++];
            }
        }
        while (i < leftArray.length) {
            array[k++] = leftArray[i++];
        }
        while (j < rightArray.length) {
            array[k++] = rightArray[j++];
        }
        return array;
    }
}

堆排序

每一个数组都可以看成一颗完全二叉树,特点是每一个非叶子节点i,左子节点在数组的2i+1位置上,右节点在2i+2位置。简单来说,将数组从上往下从左往右铺满,可以看到非叶子节点都是在数组的前面，如下

而堆也是完全二叉树的一种，分为最大堆和最小堆，最大堆的特点是每一个父节点都大于等于子节点，所以在根节点的元素在数组的第一个位置，同时也是最大值。

所以堆排序的解题思路就是，从最后一个非叶子节点遍历，比较子节点大小，交换最大值位置，就这样将数组调整成最大堆，拿走根节点放在数组的末尾，第二次将剩余的元素继续调整成堆，拿走根节点放在数组的次末尾，重复上述操作，直到剩余元素只有一个。

public class HeapSort {

    public static int[] sort(int[] sourceArray) {
        int[] array = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = array.length - 1; i > 0; i--) {
            buildMaxHeap(array, i);
            swap(array, 0, i);
        }
        return array;
    }

    static void buildMaxHeap(int[] array, int lastLeaf) {
        //计算最后一个非叶子节点的位置
        int lastNonLeaf;
        if (lastLeaf % 2 == 1) {
            lastNonLeaf = (lastLeaf - 1) / 2;
        } else {
            lastNonLeaf = lastLeaf / 2 - 1;
        }
        for (int i = lastNonLeaf; i >= 0; i--) {
            int left = 2 * i + 1;
            int right = 2 * i + 2;
            if (array[left] > array[i]) {
                swap(array, left, i);
            }
            if (right <= lastLeaf && array[right] > array[i]) {
                swap(array, right, i);
            }
        }
    }

    static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

测试代码  https://github.com/mycaizilin/sort