几种排序算法

冒泡排序：
把最大的冒出来。
时间复杂度：O（n^2）
i = arr.length -1; 几次排序
j = arr.length-1-i; 每次排几个

package com.yhc.sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {8, -9, 5, 0, 3};
        int temp = 0;
        //优化
        boolean flag = false;
        System.out.println(arr.length - 1);
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "次排序！");
            System.out.println(Arrays.toString(arr));
            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
    }
}

选择排序：
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]-arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]-arr[n-1]中选取最小值，与arr[2]交换，…，第i 次从arr[i-1]-arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1 次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1 次，得到一个按排序码从小到大排列的有序序列。
每次选出最小的，放到数组第i个；

package com.yhc.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101,4,144,1,0};
        System.out.println(Arrays.toString(arr));
        System.out.println("排序后： ");
        select(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void select(int[] arr){
        for (int i = 0; i < arr.length; i++) {
        //默认第i个最小
            int min = arr[i];
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
            //改变符号可以决定从小到大，还是从大到小。
                if (min > arr[j]){
                    min = arr[j];
                    minIndex = j;
                }
            }
            //如果默认的改变了，说明后面有更小的，最小的和第i个换位置。前面i个是已经固定的。
            if(minIndex != i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

插入排序：

希尔排序：

快速排序：
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

import java.util.Arrays;

public class QiuckSort {
    public static void main(String[] args) {
        int[] arr = {-9,78,0,23,-567,70};

        quick(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }
    public static void quick(int[] arr,int left,int right){
        int l = left;
        int r = right;
        //中轴值
        int pivot = arr[(left + right)/2];
        int temp = 0;
        //比中轴值大的放到右边，小的放到左边
        while (l < r){
            //在pivot 的左边一直找,找到大于等于pivot 值,才退出
            while(arr[l] < pivot){
                l += 1;
            }
            //在pivot 的右边一直找,找到小于等于pivot 值,才退出
            while(arr[r] > pivot){
                r -= 1;
            }
            //如果l >= r 说明pivot 的左右两的值，已经按照左边全部是
            //小于等于pivot 值，右边全部是大于等于pivot 值
            if (l >= r){
                break;
            }
            //交换位置
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;


            //如果交换完后，发现这个arr[l] == pivot 值相等r--， 前移
            if (arr[l] == pivot){
                r -= 1;
            }
            if (arr[r] == pivot){
                l += 1;
            }

        }
        //会发生栈溢出。
        if ( l == r){
            l += 1;
            r -= 1;
        }
        //向左递归
        if(left < r){
            quick(arr,left,r);
        }
        //向右递归
        if (right > l){
            quick(arr,l,right);
        }
    }
}

归并排序：

package com.yhc.sort;

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8,4,5,7,1,3,6,2};
        int[] temp = new int[arr.length];
        mergeSort(arr,0,arr.length-1,temp);
        System.out.println("归并排序 ：" + Arrays.toString(arr));

    }

    //分+合 方法
    public static void mergeSort(int[] arr,int left,int right,int[] temp){
        if (left < right){
            int mid = (left + right) / 2;
            //向左递归进行分解
            mergeSort(arr,left,mid,temp);
            //向右递归进行分解
            mergeSort(arr,mid+1,right,temp);
            //合并
            merge(arr,left,mid,right,temp);
        }
    }

    //合并的方法
    /**
     *
     * @param arr 原始数组
     * @param left 左边有序序列的初始索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp   中转数组   */
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left; //左边序列初始索引
        int j = mid + 1; //右边序列初始索引
        int t = 0; //中专数组的当前索引

        //1、先把左右有序数据按照规则填充到temp 数组
        //直到其中一边处理完毕
        while (i <= mid && j <= right){
            if (arr[i] <= arr[j]){
                temp[t] = arr[i];
                t++;
                i++;
            }else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
        //2、 把有剩余一边的数组全部填充到temp
        while (i <= mid){
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= right){
            temp[t] = arr[j];
            t++;
            j++;
        }
        //3、将temp 数组的元素拷贝到arr
        // 并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right){
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }
}

基数排序：

package com.yhc.sort;

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {53,3,542,748,14,214};
        radixSort(arr);
    }

    //基数排序方法
    public static void radixSort(int[] arr){
        //先得到最大的数，它的位数决定了要排序的次数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++){
            if (max < arr[i]){
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();

        //定义一个二维数组，表示10个桶，每个桶都是一个一维数组
        int[][] bucket = new int[10][arr.length];
        //每个桶元素的个数
        //默认为零
        int[] bucketElementCount = new int[10];


        for (int i = 0,n = 1;i < maxLength;i++, n*=10){
            //第几轮处理， 第一次是个位，第二次是十位，第三次是百位。。。。

            //第 j 个元素
            for (int j = 0;j < arr.length ; j++){
                //取出每个元素对应位的值，放入对应的桶中
                int digitOfElement = arr[j] / n % 10;
                //      第几个桶         第几个元素
                bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[j];
                bucketElementCount[digitOfElement] ++ ;
            }
            //按照这个桶的顺序，一位数组的下标一次取出数据放入原来的数组
            int index = 0;
            //遍历每一桶，并将桶中的数据，放入到原数组
            //bucketElementCount 的长度是10.
            for (int k = 0; k < bucketElementCount.length; k++){
                if(bucketElementCount[k] != 0){
                    //循环桶，
                    for (int l = 0; l < bucketElementCount[k]; l++) {
                        arr[index ++] = bucket[k][l];
                    }
                }
                //最后将桶清空，方便下次循环使用
                bucketElementCount[k] = 0;
            }
            System.out.println("第"+(i+1)+"轮=" + Arrays.toString(arr));

        }
    }

}