十大常见排序算法

一、排序算法概述

排序算法最常用操作：交换元素

public void sort(int[] arr, int i, int j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
    }

二、冒泡排序

2.1 实现原理

第一种：元素上浮，从右（大）往左（小）依次确认，相邻元素间，如果右小于左，则交换，每次确认一位最小数。

第二种：元素下沉，从左（小）往右（大）依次确认，相邻元素间，如果左大于右，则交换，每次确认一位最大数。

2.2 动图解析

3.3 代码实现

public static void main(String[] args) {
        Object [] arr = {23,42,21,33,44,55,34,65,77,20,"A","b",90};
        for (Object o : bubbleSort(arr)) {
            System.out.print(o+" ");
        }
}

public static Object[] bubbleSort(Object[] arr){
        //排除空异常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //从末尾元素开始确定
        for (int i = arr.length - 1; i > 0; i--) {
            //判断是否存在交换
            boolean flag = false;
            for (int j = 0; j < i; j++) {
                if (arr[j].hashCode() > arr[j + 1].hashCode()) {
                    sort(arr, j, j + 1);
                    flag = true;
                }
            }
            //如果不再存在交换，则排序完毕，直接退出
            if (!flag) {
                break;
            }
        }

        return arr;
}

结果：

三、选择排序

3.1 实现原理

第一种：拿未确认的最左位元素，依次和右边元素比较，如果右边元素更小，则交换

第二种：拿未确认的最右位元素，依次和左边元素比较，如果左边元素更大，则交换

3.2 动图解析

3.3 代码实现

public static Object[] selectSort(Object[] arr){
        //排除空异常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //从第一位元素开始确定
        for (int i = 0; i < arr.length - 1; i++) {
            //记录当前获得最小值的索引（取代实际交换操作）
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j].hashCode() < arr[min].hashCode()) {
                    min = j;
                }
            }
            sort(arr, i, min);
        }
        return arr;
    }

 结果：

四、插入排序

4.1 实现原理

将某一元素插入已经排序好的数组中，

第一种：元素位于数组右方，则元素依次与左方比较，找出合适位置，被比较元素后移一位，该元素前置

第二种：元素位于数组左方，则元素依次与右方比较，找出合适位置，被比较元素前移一位，该元素后置

4.2 动图解析

 

4.3 代码实现

private static Object[] insertSort(Object[] arr) {
        //排除空异常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //从第二位开始，比较元素前面的元素为排序好的数组
        for (int i = 1; i < arr.length; i++) {
            Object temp = arr[i];
            //定义被比较数组元素所在位
            int j = i - 1;
            while (j >= 0 && temp.hashCode() < arr[j].hashCode()) {
                arr[j + 1] = arr[j];
                j--;
            }
            //将插入元素前置
            arr[j + 1] = temp;
        }
        return arr;
    }

结果：

五、希尔排序

5.1 实现原理

按照一定间隔（记d）执行插入排序

第一种：元素位于数组右方，记索引为x，则元素依次与左方x-d的元素比较，找出合适位置，被比较元素后移一位，该元素前置

第二种：元素位于数组左方，记索引为x，则元素依次与右方x+d的元素比较，找出合适位置，被比较元素前移一位，该元素后置

5.2 动态解析

5.3 代码实现

private static Object[] shellSort(Object[] arr) {
        //排除空异常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //假定初始间隔为数组长度二分之一，每次再乘以二分之一
        int len = arr.length / 2;

        while (len != 0) {
            for (int i = len; i < arr.length; i++) {
                Object temp = arr[i];
                //获取与比较元素间隔len长度的数组元素
                int j = i - len;
                //插入排序
                while (j >= 0 && (temp.hashCode() < arr[j].hashCode())) {
                    arr[j + len] = arr[j];
                    j = j - len;
                }
                arr[len + j] = temp;
            }
            len = len / 2;
        }
        return arr;
    }

结果：

更多详细见解：https://blog.csdn.net/qq_35813653/article/details/83055078