常见排序算法_常用排序算法-CSDN博客

本文链接：https://blog.csdn.net/weixin_43659449/article/details/107136623

常见排序算法

选择排序：

package leetcode.sort;

/**
 * 选择排序：
 * 1、首先找到数组中的最小的那个元素，使用一个变量min来维持最小的那个元素
 * 2、当第二层的循环结束后，意味着min就是那个最小的元素
 * 3、交互元素
 * 第二层循环也保证了不会去干扰前面已经排好了的元素
 */
public class Selection {
    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }
    private static void swap(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    public static void sort(Comparable[] a) {
        int len = a.length;
        for (int i = 0; i < len; i++) {
            int min = i;
            //找到后面最小的元素
            for (int j = i + 1; j < len; j++) {
                if (less(a[j], a[min])) {
                    min = j;
                }
            }
            swap(a, i, min);
        }
    }

    /**
     * 包装类都实现了Comparable接口
     * 所以完全是可以用 Comparable[] a，它会帮我们实现自动拆箱和装箱
     */
    public static void main(String[] args) {
        //Integer[] x = new Integer[]{4, 2, 1, 8};
        //Comparable[] a = x;
        //两者相等
        Comparable[] a = {4, 2, 1, 8};
        sort(a);
        show(a);
    }
}

插入排序：

package leetcode.sort;

/**
 * 插入排序
 * 就是把一个元素插入到已经排好顺序的数组里，从后往前，当遇到比自己大的元素的时候，就交换位置，直到遇到比自己小的或者和自己一样大的元素，就退出当层循环
 */
public class Insertion {
    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }
    private static void swap(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    /**
     *这里需要注意一下的是边界的取值，因为一开始就需要有一个元素和它比较，如果从i = 0开始比较，就会溢出边界
     */
    public static void sort(Comparable[] a) {
        int len = a.length;
        for (int i = 1; i < len; i++) {
            for (int j = i; j > 0; j--) {
                //只要是遇到比自己大的元素，那么就交换，否则退出退出当前层次的循环
                if (less(a[j], a[j-1])) {
                    swap(a, j, j-1);
                }else {
                    break;
                }
            }
        }
    }
    public static void sort1(Comparable[] a) {
        int len = a.length;
        for (int i = 1; i < len; i++) {
            //如果满足当前的条件，就进行交换
            for (int j = i; j > 0 && less(a[j], a[j-1]); j--) {
                swap(a, j, j-1);
            }
        }
    }

    /**
     *sort1方法和short方法一样
     */
    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8};
        sort(a);
        show(a);
    }
}

插入排序改良版：

package leetcode.sort;

/**
 * 插入排序改进版本
 * 用一个临时变量，暂存那个可能要交换的值，使得自己的位置被空出来，进入循环，把比这个元素大的值都往后面移，直到找到满足条件的那个元素的位置
 */
public class InsertionSort2 {
    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }

    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    public static void sort(Comparable[] a) {
        int len = a.length;
        for (int i = 1; i < len; i++) {
            Comparable temp = a[i];
            int j = i - 1;
            //需要满足的条件
            while (j >= 0 && less(temp, a[j])) {
                //把当前元素后移一位
                a[j + 1] = a[j];
                //指针向前移
                j--;
            }
            a[j + 1] = temp;
        }
    }

    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8};
        sort(a);
        show(a);
    }
}

希尔排序

定义：

package leetcode.sort;

/**
 * 希尔排序
 */
public class Shell {
    private static void swap(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }

    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static void sort(Comparable[] a) {
        int len = a.length;
        int h = 1;
        //进行分组，增量为3
        while (h < len/3) {
            h = 3*h + 1;
        }
        while (h >= 1) {
            //把数组变成h有序
            for (int i = h; i < len; i++) {
                //进行插入排序
                for (int j = i; j >= h && less(a[j] ,a[j - h]); j -= h) {
                    swap(a, j, j - h);
                }
            }
            h = h/3;
        }
    }

    public static void main(String[] args) {
        Comparable[] a = {"z", "b", "c", "d"};
        sort(a);
        show(a);
    }
}

归并排序（自顶向下）

归并排序的主要难度在于原地归并，就是把两个有序的数组合并成为一个有序的数组

结合个人潦草的图解可以根据代码理解一下

package leetcode.sort;

/**
 * 自顶向下排序
 */
public class Merge {
    //用于合并两个有序数组的辅助数组，防止开辟空间
    private static Comparable[] aux;

    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }

    private static void merge(Comparable[] a, int low, int mid, int hight) {
        int i = low;
        int j = mid + 1;
        for (int k = low; k <= hight; k++) {
            aux[k] = a[k];
        }
        //aux[low, mid]和aux[mid + 1,hight]已经有序了
        for (int k = low; k <= hight; k++) {
            //当左边的已经排序完了，用完了，那么就直接把右边的加进来
            if (i > mid) {
                a[k] = aux[j++];
            }
            //当右边的已经排序完了，用完了，那么就直接把左边的加进来
            else if (j > hight) {
                a[k] = aux[i++];
            }
            //如果aux[j]比aux[i]小的话，那么就进行交换，这里也就造成了不稳定
            else if (less(aux[j], aux[i])) {
                a[k] = aux[j++];
            }else {
                a[k] = aux[i++];
            }
        }
    }

    private static void sort(Comparable[] a, int low, int hight) {
        //递归结束条件
        if (low >= hight) {
            return;
        }
        //防止整数溢出的现象发生
        int mid = low + (hight - low) / 2;
        //int mid = (low + hight) >>> 1;  //这种方法也可以防止溢出
        sort(a, low, mid);//将右边排序
        sort(a, mid + 1, hight);//将左边排序
        merge(a, low, mid, hight);
    }

    private static void sort(Comparable[] a) {
        //分配空间
        aux = new Comparable[a.length];
        //这里需要主要一下它的边界
        sort(a, 0, a.length - 1);
    }

    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8};
        sort(a);
        show(a);
    }
}

归并排序（自低向上）：

package leetcode.sort;

/**
 * 自低向上排序
 *
 * 进行两两归并，把每个元素都想象成为一个子数组，在子数组上进行一个归并排序
 * 子数组大小：1——>2——>4——>8，每个字数组都是有序的
 * 但是有可能最后一个一个子数组会比左边的子数组要小，所以需要对它的长度进行判断，取最小的那个数组长度，但是这对归并排序并没有影响
 */
public class MergeBU {
    //用于合并两个有序数组的辅助数组，防止开辟空间
    private static Comparable[] aux;

    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }

    private static void merge(Comparable[] a, int low, int mid, int hight) {
        int i = low;
        int j = mid + 1;
        for (int k = low; k <= hight; k++) {
            aux[k] = a[k];
        }
        //aux[low, mid]和aux[mid + 1,hight]已经有序了
        for (int k = low; k <= hight; k++) {
            //当左边的已经排序完了，用完了，那么就直接把右边的加进来
            if (i > mid) {
                a[k] = aux[j++];
            }
            //当右边的已经排序完了，用完了，那么就直接把左边的加进来
            else if (j > hight) {
                a[k] = aux[i++];
            }
            //如果aux[j]比aux[i]小的话，那么就进行交换，这里也就造成了不稳定
            else if (less(aux[j], aux[i])) {
                a[k] = aux[j++];
            }else {
                a[k] = aux[i++];
            }
        }
    }

    /**
     * 当sz为1的时候：
     * merge(a, 0, 0, 1)
     * merge(a, 2, 2, 3)
     */
    private static void sort(Comparable[] a) {
        //分配空间
        aux = new Comparable[a.length];
        int len = a.length;

        for (int sz = 1; sz < len; sz = sz*2) {//sz = 1、2、4、8
            for (int i = 0; i < len - sz; i += sz*2) {
                //注意这里的这里的i，第一次循环的时候i = 0，第二次循环的时候i = 2
                //中间的mid长度的大小刚刚好就是上一次子数组的长度sz
                merge(a, i, i + sz -1, Math.min(len - 1, 2*sz + i - 1));
            }
        }
    }

    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8};
        sort(a);
        show(a);
    }
}

快速排序：

package leetcode.sort;

import java.util.Random;

/**
 * 推荐图解可视化链接
 * https://www.bilibili.com/video/BV1Tt411r75A?from=search&seid=14087744357545857630
 *
 * 快速排序采用“分而治之、各个击破”的观念，此为原地（In-place）分区版本。
 * 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
 * 步骤为： 1、从数列中挑出一个元素，称为"基准"（pivot），
 *         2、重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
 *         3、递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
 */
public class Quick {
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static void swap(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    private static boolean less(Comparable v, Comparable w) {
        //通过比较v是否小于w，是的话，返回true
        return v.compareTo(w) < 0;
    }

    private static int partition(Comparable[] a, int low, int hight) {
        int left = low;
        int right = hight + 1;
        Comparable v = a[low];//定义一个基准值

        while (true) {
            //如果左边的元素小于v时，那么就left就往右边走
            while (less(a[++left], v)) {
                //如果左边的元素都走到尾了，就退出循环
                if (left == hight) {
                    break;
                }
            }
            //如果右边的元素大于v时，那么就right就往左边走
            //这里的边界要非常注意，非常注意
            while (less(v, a[--right])) {
                //如果右边的元素都走到头了，就退出循环
                if (right == low) {
                    break;
                }
            }
            //这里要注意一下，结束的时候，left和right的位置可能会进行交换，就是说left本来在right的左边的，当他们相遇的时候，left就可能跑到right的右边去了
            if (left >= right) {
                break;
            }
            //确保left左侧的元素都不大于v，右侧的元素都不小于v
            swap(a, left, right);
        }
        //切分结束
        swap(a, low, right);
        return right;
    }

    public static void sort(Comparable[] a) {
        sort(a, 0, a.length - 1);
    }
    public static void sort(Comparable[] a, int low, int hight) {
        //递归结束条件
        if (low >= hight) {
            return;
        }
        int left = partition(a, low, hight);
        //System.out.println(left);
        //因为基准是大于左边的元素，小于右边的元素，所以不需要再对基准进行排序，选择递归的边界是left - 1和left + 1
        sort(a, low, left - 1);
        sort(a, left + 1, hight);
    }

    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8, 3};
        sort(a);
        show(a);
    }
}

三向切分的快速排序

package leetcode.sort;

/**
 *
 */
public class Quick3way {
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static void swap(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    private static void partition(Comparable[] a, int low, int hight) {
        //递归结束条件
        if (low >= hight){
            return;
        }
        int lt = low;
        int i = low + 1;
        int gt = hight;
        //定义一个基准
        Comparable v = a[low];
        while (i <= gt) {
            int x = a[i].compareTo(v);
            //当a[i]小于基准值的时候，交换位置
            if (x < 0) {
                swap(a, lt++, i++);
            }
            //当a[i]大于基准值的时候，交换位置
            else if (x > 0) {
                swap(a, gt--, i);
            }
            else {
                i++;
            }
        }
        partition(a, low, lt - 1);
        partition(a, gt + 1, hight);
    }

    public static void sort(Comparable[] a) {
        partition(a, 0, a.length - 1);
    }

    public static void main(String[] args) {
        Comparable[] a = {4, 2, 1, 8, 3};
        sort(a);
        show(a);
    }
}