八大基本排序

内部排序：在排序期间数据对象全部存放在内存的排序

外部排序：指在排序期间对象太多，不能同时存放在内存中，必须根据排序过程的要求，不断在内、外存间移动。

效率的衡量：

　　内部排序：比较的次数（即时间复杂度）

　　外部排序：IO次数

性能比较：

稳定：待排序序列中相同数字的顺序 在 排好序后，顺序不发生改变。

直接插入排序：

/**
 * 直接插入排序
 * 思想： 将待排元素 与 已经排好序的元素进行比较
 * 升序：（逆序比较）若待排元素 小于 已排元素，则交换位置； 若待排元素 大于 已排元素，则不交换，停止比较。
 */
public class InsertSort {
    public static void main(String[] args){
        int[] arr = new int[]{12, 3, 9, 24, 45, 17};
        for(int i = 1; i < arr.length; i++){ //待比较元素的小标 从第二个元素开始
            // 如果j是 从0~(i-1) 那么比较会涉及到元素后移，增加时间复杂度
                    for(int j = i-1; j >= 0; j--){
                        if(arr[i] < arr[j]){   // 直接插入排序稳定 如果是arr[i] <= arr[j] 则不稳定
                            int temp = arr[i];   
                            arr[i] = arr[j];
                            arr[j] = temp;
                }
            }
        }
        for(int x : arr){
            System.out.print(x + " ");
        }
    }
}

最好的情况：待排数组已经排好序， 待排元素只需跟已排元素比较一次   O(n)

最坏情况： 待排数组与预期顺序全部逆序，每个待排元素需要与全部的已排元素比较一次   O()

使用场景：规模较小或者基本有序

希尔排序：是插入排序的改进版

public class SheelSort {
    public static void main(String[] args){
        int[] arr = new int[]{12, 3, 9, 24, 45, 17, 33, 7, 11, 15};
        for(int gap = arr.length/2; gap >= 1; gap /= 2){
            // 将arr[i]插入到每组 对应的位置
            for(int i = gap; i < arr.length; i++){ // i 是每组元素的第二个元素
                int d = arr[i];
                int j;
                // 待排元素是： arr[i], 已排元素是： i-gap, i-2gap.... 逆着比较
                for(j = i-gap; j >= 0 && d < arr[j]; j -= gap){
                    arr[j+gap] = arr[j]; // 若已排元素大于待排元素temp 则往后移动
                }
                arr[j+gap] = d;
            }
        }
        for(int x : arr){
            System.out.print(x + " ");
        }
    }
}

在进行排序的过程中，并不是对某组排完序后再对另一组排序，而是各组轮流排序。（可以设个断点看看变化）

直接选择排序：

/**
 * 算法思想：进行n-1次循环，在第i(从0开始)次循环中，在待排序列中找到最小(大)值的下标，看是否与i相等，
 * 如果不相等，则两个位置上的元素进行交换
 */
public class SelectSort {
    public static void main(String[] args){
        int[] arr = new int[]{12, 3, 9, 24, 45, 17};
        for(int i = 0; i < arr.length-1; i++){ // 循环次数
            int min = i;
            for(int j = i+1; j < arr.length; j++){ //在待排序列中 找到最小元素的小标
                if(arr[j] < arr[min]){
                    min = j;
                }
            }
            if(min != i){ // 如果最小元素不是 arr[i]  则arr[i]与最小元素进行交换
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
        for(int x : arr){
            System.out.print(x + " ");
        }
    }
}

堆排序：

冒泡排序：

/**
 * 冒泡排序
 * 算法思想：比较交换
 */
public class BubbleSort {
    public static void main(String[] args){
        int[] arr = new int[]{12, 3, 9, 24, 45, 17};
        for(int i = 0; i < arr.length-1; i++){
            boolean flag = false; // 看序列是否已经有序  没有交换就表示序列已经有序
            for(int j = 0; j < arr.length-i-1; j++){ //从下标0开始，只需要比较到待排序列的倒数第二个元素即可
                if(arr[j] > arr[j+1]){
                    flag = true;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(flag == false) {
                break;
            }
        }
        for(int x : arr){
            System.out.print(x + " ");
        }
    }
}

最好情况： 待排序列已经有序，就只需要一个循环的比较即可  O(n)

最坏情况： 待排序列与想象中的序列完全逆序  O()

快速排序：

/**
 * 算法思想：找一个基准数，把比基准数小的数往左移， 比基准数大的往右移，每一次的排序都会把基准数放在正确位置
 */
public class QuickSort {
    public static void quickSort(int[] arr, int start, int end){
        if(start >= end) return ;
        int point = arr[start];
        int low = start, high = end;
        while(low < high){
            while(low < high && arr[high] >= point){
                high--;
            } // 循环结束时， arr[high] < point
            if(low < high){
                arr[low] = arr[high];
                low++;
            }
            while(low < high && arr[low] <= point){
                low++;
            } // 循环结束时，arr[low] > point
            if(low < high){
                arr[high] = arr[low];
                high--;
            }
        }
        arr[high] = point;  //把point放在正确的位置上  point左边就是比point小的数 右边就是比point大的数
        quickSort(arr, start, high-1);
        quickSort(arr, high+1, end);
    }
    public static void main(String[] args){
        int[] arr = new int[]{12, 3, 9, 24, 45, 17};
        quickSort(arr, 0, arr.length-1);
        for(int x : arr){
            System.out.print(x + " ");
        }
    }
}

归并排序：

基数排序：