选择，插入，冒泡，二分法，归并，希尔排序算法合集演示及标注

1.选择排序

理解核心思想，取出一个元素，在它后面的每一位中进行比较，选择出一个最小/最大的元素，来与它交换。

代码示例

//比较    public static boolean less(int a, int b) {        if (a > b)            return true;        return false;    }    //交换    public static void exch(int[] num, int i, int j) {        int temp = num[i];        num[i] = num[j];        num[j] = temp;    }    //排序    public static void sort(int[] num) {        for (int i = 0; i < num.length; i++) {            int min = i;            // 除开i坐标的前面的元素            for (int j = i + 1; j < num.length; j++)                // 注意理解这里两个比较对象。                // 后面的每一个元素与min坐标比较。                // 目的是找出比min坐标还小/大的值                if (less(num[j], num[min]))                    min = j;            // 进行交换            exch(num, i, min);        }    }

总结

第一步，设置标记

比较出最小/最大

交换标记点下标与比较的元素。

2.插入排序

理解核心思想，取出一个元素，比较它之前的元素，进行两两交换。由于一开始就是这样操作，保证了前面的数组具有有序性，从而进行交换后一样保持有序。

代码示例

//比较    public static boolean less(int a, int b) {        if (a > b)            return true;        return false;    }    //交换    public static void exch(int[] num, int i, int j) {        int temp = num[i];        num[i] = num[j];        num[j] = temp;    }    //排序    public static void sort(int[] num) {        for (int i = 0; i < num.length; i++) {            //比较当前i，之前的元素，进行两两交换操作。（关键）            for (int j = i; j > 0 && less(num[j], num[j - 1]); j--)                exch(num, j, j - 1);        }    }

总结

比较两两元素，满足条件交换。

3.快速排序（二分法排序）

理解核心思想，选取第一位作为标记，经过一次排序后，将这个数组分为两个部分（无序的），左边的小于标记，右边的大于标记。选取第二位，重复上面操作。最终整个数组有序。

fd

public static void sort(int[] num) {        sort(num, 0, num.length - 1);    }    public static void sort(int[] num, int left, int right) {        int pos;        if (left < right) {            //算出中间位置            pos = pos(num, left, right);            //以中间位置进行分割成两部分            sort(num, left, pos - 1);            sort(num, pos + 1, right);        }    }    public static int pos(int[] num, int left, int right) {        int temp = num[left];        while (left < right) {            //右边开始寻找，与标记点比较            while (left < right && num[right] >= temp)                right--;            //发现比标记点小。将右边的小值赋值给左边，并且将左边的下标向前移位。因为下面代码要从左边搜索了。            if (left < right)                num[left++] = num[right];            //左边开始寻找，与标记点比较            while (left < right && num[left] <= temp)                left++;            //发现比标记点大，将左边的大值赋值给右边，并且将右边的下标--，因为代码要从右边搜索了。            if (left < right)                num[right--] = num[left];        }        //最终完成，最后一步是左边的值赋值给右边，所以此时的left就处于中间位置。我们将标记点值赋值给它，        num[left] = temp;        //返回分割点。        return left;    }    public static void main(String[] args) {        int[] num = new int[20];        Random random = new Random();        for (int i = 0; i < 20; i++) {            num[i] = random.nextInt(100);        }        sort(num);        for (int i :                num) {            System.out.print(i + "\t");        }        System.out.println();    }

总结

标记点

右边小的赋值给左边，左边大的赋值给右边

确定中间点，赋值标记点值，返回下标

4.希尔排序

理解核心思想，增量概念，每次在增量间比较，以及交换。缩小增量，重复比较，交换。利用的插入排序算法。

public void sort(int[] nums) {        /** 结合了插入排序 **/        /** 数字长度N **/        int N = nums.length;        /** 确认间隔长度 **/        int h = 3;        while (h < N / 3) h = 3 * h + 1;        while (h >= 1) {            /** 注意需要从i=h开始 i++ **/            for (int i = h; i < N; i++)            /** j=i开始 **/                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h)//插入排序                    exch(nums, j, j - h);            h = h / 3;        }    }

总结

理解快速排序，改变其增量即可。

5.归并排序

理解核心思想，归并排序，类似于分支法解决问题，将一个长度很长的数组，从中间分开，分成两半，取一半，重复上述操作即可。最终变成长度为2的数组，比较后，进行交换，在末端保持了有序性。继而整体保持了有序性。

    /**     * @param nums     */    public void sort(int[] nums) {        sort(nums, 0, nums.length - 1);    }    public void sort(int[] nums, int low, int high) {        int mid = low + (high - low) / 2;        if (low < high) {            /** 左边排序 **/            sort(nums, low, mid);            /** 右边排序 **/            sort(nums, mid + 1, high);            merge(nums, low, mid, high);        }    }    private void merge(int[] nums, int low, int mid, int high) {        int[] temp = new int[high - low + 1];        int i = low;        int j = mid + 1;        int k = 0;        /** 两边合并**/        while (i <= mid && j <= high) {            if (nums[i] < nums[j]) {                temp[k++] = nums[i++];            } else {                temp[k++] = nums[j++];            }        }        /** 左边多余的合并 **/        while (i <= mid) {            temp[k++] = nums[i++];        }        /**  右边多余的合并 **/        while (j <= high) {            temp[k++] = nums[j++];        }        /** 拷贝合并后的数到原数组 **/        for (int k2 = 0; k2 < temp.length; k2++)            nums[low + k2] = temp[k2];    }

总结

实现末端长度为2的数组，进行比较交换，保持了底层有序，进而整体有序。

 6.堆排序

理解核心思想，将数组理解成逻辑完全二叉树结构。仅仅是逻辑结构，实际还是以数组形式保存。有逻辑关系式，父节点与子节点之间关系，p(i)=c(2*i+1)|c(2*i+2),很重要。

public static void sort(int[] n) {        for (int i = 0; i < n.length; i++) {            createMaxHeap(n, n.length - 1 - i);            exch(n, 0, n.length - 1 - i);        }    }    public static void createMaxHeap(int[] n, int lastIndex) {        int pIndex = (lastIndex - 1) / 2;        for (int i = pIndex; i >= 0; i--) {            int k = i;            while (2 * k + 1 <= lastIndex) {                int cIndex = 2 * k + 1;                if (cIndex < lastIndex)                    if (n[cIndex] < n[cIndex + 1])                        cIndex++;                if (n[k] < n[cIndex]) {                    exch(n, cIndex, k);                    k = cIndex;                } else {                    //关键的，跳过，上一级父节点                    break;                }            }        }    }

总结

堆排序，没什么的说的。自己跟着代码逻辑，自己画图，理解，自然就理会了。一定要自己跟着代码走一遍。化图解。

7.计数排序

理解核心思想，统计每个元素出现的个数，然后以n-m有序数，来排序。（讲起来有点难懂）

public static void sort(int[] n) {        int max = n[0];        int min = max;        for (int i = 0; i < n.length; i++) {            if (max < n[i])                max = n[i];            if (min > n[i])                min = n[i];        }        int[] c = new int[max - min + 1];        for (int i = 0; i < n.length; i++) {            c[n[i] - min] += 1;        }        for (int i = 0, index = 0; i < max - min + 1; i++) {            for (int j = 0; j < c[i]; j++) {                n[index++] = i + min;            }        }    }

总结

总结什么呢？看代码理会。不懂@我