四种排序算法动画展示：冒泡排序、选择排序、插入排序、快速排序

冒泡排序

🎈 冒泡排序动画

💻 冒泡排序代码实现

/**
 *  冒泡排序:
 *  依次比较相邻的元素，如何和排序规则不同，则交换量元素
 *  从头进行再次循环
 *  直到循环到数组的第一个元素
 */
import java.util.Arrays;
public class sort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 9, 7, 2, 1};
        System.out.println("排序前:" + Arrays.toString(arr));
        new sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
    public sort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {  //第一个元素就不需要再比较了，一共遍历n-1次
            // 优化：加入个布尔判断，如果没有进入下面的排序交换中，则说明已经提前排好序了
            //不需要进行下去了，这是其中一个优化方案
            boolean flag = true;

            for (int j = 0; j < arr.length -1-i; j++) { //依次比较，放到最大位置的元素就不用再比较了
                //如果前一个数比后一个数大,两者交换
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = false;
                }
            }
            //优化时加入此项
            if (flag){
                break;
            }
        }
    }
}

选择排序

🎈 选择排序动画

💻 选择排序代码实现

/**
 *  选择排序:
 *  从未排序的第一个元素开始选择，依次比较，找出最小的值，与未排序的第一个元素进行交换位置
 *  循环排序，每次排序完成一个元素
 */
import java.util.Arrays;
public class sort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 9, 7, 2, 1};//
        System.out.println("排序前:" + Arrays.toString(arr));
        new sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
    public sort(int[] arr) {
        for(int i=0;i<arr.length;i++) {
            int minIndex=i;//未排序最小值标志
            for(int j=i+1;j<arr.length;j++) {
                if(arr[minIndex]>arr[j]) {//如果标志元素大于未排序的元素，则交换标志下标
                    minIndex=j;
                }
            }
            if(i!=minIndex) {//找出最小值之后，和最初的元素进行比较，如果不是之前的元素，则进行位置交换
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
        }
    }
}

插入排序

🎈 插入排序动画

💻 插入排序代码实现

/**
 *  插入排序:
 *  从未排序的第一个元素开始从后到前进行扫描，找到比此元素小位置停止，将此元素插入到此位置+1
 *  循环排序，每次排序完成一个元素
 */
import java.util.Arrays;
public class sort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 9, 7, 2, 1};//
        System.out.println("排序前:" + Arrays.toString(arr));
        new sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
    public sort(int[] arr) {
        //3, 5, 9, 7, 2, 1  当i = 3 temp = arr[i] = 7 向前查询，temp = 7<arr[2]=9
        //先将arr[3]=arr[2]=9  3, 5, 9, 9, 2, 1
        //继续向前查找，发现arr[1]<temp 停止查询
        //将arr[1]赋值 temp =7   3, 5, 7, 9, 2, 1
        for(int i=1;i<arr.length;i++) {
            if(arr[i]<arr[i-1]) {
                int temp=arr[i];
                int j;
                for(j=i-1;j>=0&&temp<arr[j];j--) {
                    arr[j + 1] = arr[j];//此动作就是向后移动一位
                }
                    arr[j+1]=temp;
            }
        }
    }
}

快速排序

🎈 快速排序动画

未找到可以进行演示的自定义动画，已有的和代码逻辑不通，特引用其他博主的（动画演示 基准值以右边为主）

💻 快速排序代码实现

/**
 *  快速排序:
 *  找到一个基准值，先从后（r）向前遍历找到比此基准值小的，然后停止
 *  再从前（l）向后遍历找到比基准值大的
 *  如果都能够顺利找到，且l<f 则交换两个位置
 *  继续查找 直到l = f则停止，将此值与基准值交换 再以此值位置为中点，分为前后两部分，递归继续查询
 */
import java.util.Arrays;
public class sort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 9, 7, 2, 1};
        System.out.println("排序前:" + Arrays.toString(arr));
        new sort(arr,0,arr.length-1);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
    public sort(int[] arr,int left,int right) {

        int l = left;
        int r = right;


        //递归停止的条件
        if(left>=right){
            return;
        }

        //3 4  2 1 5 2 6
        while (l<r) {


            //从后向前查找
            while (l < r && arr[r] >= arr[left]) {
                r--;
            }
            //从前向后查找
            while (l < r && arr[l] <= arr[left]) {
                l++;
            }
            //相等，将此值与基准值调换
            if (l == r){
                int temp = arr[left];
                arr [left] = arr[l];
                arr[l] = temp;
            }else {
                //不相等两值调换，继续循环
                int temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
            }
        }
        //递归查找两个部分
        new sort(arr,left,l-1);
        new sort(arr,r+1,right);
    }
}

归并排序

归并动画图

归并排序代码

//归并排序

面试题

时间复杂度

稳定性

表格一览

排序法	平均时间	最差情形	稳定度	额外空间	备注
冒泡	O(n2)	O(n2)	稳定	O(1)	n小时较好
交换	O(n2)	O(n2)	不稳定	O(1)	n小时较好
选择	O(n2)	O(n2)	不稳定	O(1)	n小时较好
插入	O(n2)	O(n2)	稳定	O(1)	大部分已排序时较好
基数	O(logRB)	O(logRB)	稳定	O(n)	B是真数(0-9)，R是基数(个十百)
Shell	O(nlogn)	O(ns) 1<s<2	不稳定	O(1)	s是所选分组
快速	O(nlogn)	O(n2)	不稳定	O(nlogn)	n大时较好
归并	O(nlogn)	O(nlogn)	稳定	O(1)	n大时较好
堆	O(nlogn)	O(nlogn)	不稳定	O(1)	n大时较好

其他问题