八大排序算法

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200530211324498.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0

1，冒泡排序

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

public class BubbleSort {
    public static void main(String[] args) {
        /*冒泡排序：依次比较相邻元素的值，使值较大的元素后移*/
        int[] arr = {3, 8, -1, 10, -2};
        bubbleSort(arr);//冒泡排序
        System.out.println(Arrays.toString(arr));

        //测试冒泡排序时间复杂度O(n^2)
        /*int[] a = new int[80000];
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 80000);//生成[0-80000)
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是："+date1Str);
        bubbleSort(a);
        Date date2=new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是："+date2Str);*/

    }

    /**
     * 冒泡排序 依次比较相邻元素的值，使值较大的元素后移
     *分为无序和有序两个部分！
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        // 改进：如果不发生交换了，则排序一完成！
        boolean flag = false;//是否进行过交换！
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //改进！
            if (!flag) {//没有发生过交换
                break;
            } else {
                flag = false;//重置flag，进行下次判断！
            }
        }
    }
}

2,插入排序

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] a=new int[20];
        for (int i=0;i<20;i++)
            a[i]=(int)(Math.random()*100);//随机生成[0-100)之间的数
        insertSort(a);
        System.out.println(Arrays.toString(a));
    }

    //插入排序：分为有序和无序两个部分,每次取到无序部分第一位插到有序部分
    public static void insertSort(int[] arr) {
        //首次分为arr[0]有序，arr[1]-arr[n-1]无序
        for (int i = 1; i < arr.length; i++) {
           //定义待插入的数
            int insertValue=arr[i];
            int insertIndex=i-1;//待插入数的前一个！(有序部分的最后一个下标)
            //insertValue<arr[insertIndex]，待插入的数比前一个数小
            while (insertIndex>=0&& insertValue<arr[insertIndex]){//找插入的位置
                arr[insertIndex+1]=arr[insertIndex];//因为要新插入数，有序部分中 大于待插入数的部分要后移！
                insertIndex--;//向前找位置！
            }
            //找到位置！注意插入位置！
            arr[insertIndex+1]=insertValue;
        }
    }
}

3，选择排序

import java.util.Arrays;
import java.util.Random;

public class SelectSort {
    public static void main(String[] args) {
        int[] a=new int[20];
        for (int i=0;i<20;i++)
            a[i]=(int)(Math.random()*100);//随机生成[0-100)之间的数
        selectSort2(a);
        System.out.println(Arrays.toString(a));
    }

    /**自定义：
     * 选择排序：找到最小值，放在前面！(分为有序和无序两个部分）
     * @param arr
     */
    public static void selectSort(int[] arr){//时间复杂度 O(n^2)
        for (int i=0;i<arr.length-1;i++){//有序范围增大
           int min=arr[i];//先假设该范围内最小值
            for (int j=i+1;j<arr.length;j++){//找到最小值！
                if (arr[j]<min){//假定的最小值不是最小！
                    int temp=arr[j];//进行了交换！
                    arr[j]=min;
                    min=temp;
                }
            }
           arr[i]=min;//把找到的最小值放在前面！
        }
    }

    /**
     * 教程版：
     * @param arr
     */
    public static void selectSort2(int[] arr){
        for (int i=0;i<arr.length-1;i++){
            int min=arr[i];
            int index=i;
            for (int j=i+1;j<arr.length;j++){//找到最小值！
                if (arr[j]<min){//假定的最小值不是最小！
                    min=arr[j];//这里没有进行交换，只是记录！
                    index=j;
                }
            }
            if (index!=i){//值交换！
                arr[index]=arr[i];
                arr[i]=min;
            }
        }
    }
}

4,快速排序

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] a1 = {6, 3, 2, 3};
        //quickSort_left(a1, 0, a1.length - 1);
        quickSort_mid(a1, 0, a1.length - 1);
        System.out.println(Arrays.toString(a1));
    }

    /*快速排序：找一个数值作为基准，把数据分为两个部分，一部分都比基准大，另一部分都比基准小*/

    //以左边的为基准
    public static void quickSort_left(int[] arr, int left, int right) {
        //检验数据，返回条件
        if (left >= right) {
            return;
        }
        int i = left, j = right, index = arr[i];//取最左边的作为基准数
        while (i < j) {
            while (i < j && arr[j] >= index) {//j向左寻找一个小于index的数
                j--;
            }
            if (i < j) {
                //找到小于index的数，放在左边(i的位置），i++（是否大于index，i是界定
                arr[i++] = arr[j]; //把arr[i]=arr[j]，arr[j]空缺！
            }
            while (i < j && arr[i] <= index) {//i向右寻找一个大于index的数
                i++;
            }
            if (i < j) {
                //找到大于index的数，放在右边(j的位置），j--
                arr[j--] = arr[i];
            }
        }
        arr[i] = index;//把基准放到最后的空缺
        quickSort_left(arr, left, i - 1);//递归调用，分治左边
        quickSort_left(arr, i + 1, right);//递归调用，分治右边
    }

    //以中间的值为基准
    public static void quickSort_mid(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int temp = 0;
        //pivot 中轴值（基准值)
        int pivot = arr[(left + right) / 2];
        //比pivot小的值放在左边，大的值放在右边
        while (l < r) {
            //在pivot的左边找大于等于pivot的值
            while (arr[l] < pivot) {
                l++;
            }

            //在pivot的右边找小于等于pivot的值
            while (arr[r] > pivot) {
                r -= 1;
            }
            //如果l>=r,说明已经符合
            if (l >= r) {
                break;
            }

            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //如果交换后，发现arr[l]==pivot，否则会死循环！
            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        //如果l==r，避免栈溢出
        if (l == r) {
            l++;
            r--;
        }
        //向左递归
        if (left < r) {
            quickSort_mid(arr, left, r);
        }
        //向右递归
        if (right > l) {
            quickSort_mid(arr, l, right);
        }
    }
}

5，希尔排序

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] a = {1, 4, 5, 6, 3, 7, 8, 9, 2, 0};
        shellSort(a);
        System.out.println(Arrays.toString(a));
        int[] a2 = {1, 4, 5, 6, 3, 7, 8, 9, 2, 0};
        shellSort2(a2);
        System.out.println(Arrays.toString(a2));

    }

    /*希尔排序：缩小增量排序，
     * 第一次分为arr.length/2组，步长gap=arr.length/2
     * 第二次分为gap/2组，步长gap=gap/2
     * 直到gap=0退出循环*/

    //交换式（缺点：执行时间并没有缩短，因为还是找一个交换一个）
    public static void shellSort(int[] arr) {
        int temp = 0;//临时变量
        int count = 0;//记录排序的次数
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {//控制分组和步长
            for (int i = gap; i < arr.length; i++) {//分组
                //遍历各组中的所有元素（共gap组）步长为gap
                for (int j = i - gap; j >= 0; j -= gap) {
                    //如果当前元素大于加上步长后的那个元素
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
          //  System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
        }
    }

    //移位法,效率明显提高！
    public static void shellSort2(int[] arr) {
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素，对各个组进行直接排序
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {//前面的数值大
                    //移动，找位置
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        //移位,大的值往后移
                        arr[j] = arr[j - gap];
                        j -= gap;//继续找位置
                    }
                    //找到位置，把temp插入！
                    arr[j] = temp;
                }
            }
        }
    }
}

6，归并排序

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] a = {0, 3, 5, 8, 2, 4, 1, 9, 7, 6};
        int[] temp = new int[a.length];
        mergeSort(a, 0, a.length - 1, temp);
        System.out.println(Arrays.toString(a));
    }

    /**
     * 归并排序：分治算法！
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    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  临时数组
     */
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        //初始变量
        int i = left;//左边有序序列的初始索引
        int j = mid + 1;//右边有序序列的初始索引
        int t = 0;//指向temp数组的当前索引
        //一，先把左右两边有序的数据按照规则填充到temp数组，直到有一边处理完毕
        while (i <= mid && j <= right) {
            //如果左边小于右边
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t++;
                i++;
            } else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
        //二，把剩余的一边数据依次全部填充到temp数组
        while (i <= mid) {//左边还有剩余数据
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= right) {//右边还有剩余数据
            temp[t] = arr[j];
            t++;
            j++;
        }
        //三，将temp数组拷贝到arr（并不是每次都拷贝所有）
        t = 0;//t置零
        int tempLeft = left;
        //t-tempLeft : 0-1,2-3,0-3...0-length-1
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }
}

7，基数排序

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int[] a={0,3,5,8,2,4,1,9,7,6};
        radixSort(a);
        System.out.println(Arrays.toString(a));
    }

    //基数排序：各个位数比较排序！
    public static void radixSort(int[] arr) {
        //1,找出最大值，求其位数(循环次数)
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        //求位数
        int maxLength = (max + "").length();

        //定义10个桶,每个桶长度arr.length
        int[][] bucket = new int[10][arr.length];
        //定义一个记录型数组，每个桶里存放了多少个元素
        int[] bucketCount = new int[10];

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {//总共进行maxLength次大循环;n 表示的是位数的变化!!!
            //每次循环，遍历arr数组，对各个数值对应的位排序
            for (int j = 0; j < arr.length; j++) {//取出各个数值的位
                int digitOfElement = arr[j] / n % 10;
                //放到对应的桶中
                bucket[digitOfElement][bucketCount[digitOfElement]] = arr[j];
                bucketCount[digitOfElement]++;//加1！
            }
            //按顺序从桶中取出数据放回 原数组
            int index = 0;
            for (int k = 0; k < bucketCount.length; k++) {
                if (bucketCount[k] != 0) {//桶中有数据
                    for (int l = 0; l < bucketCount[k]; l++) {
                        arr[index++]=bucket[k][l];
                    }
                }
                bucketCount[k]=0;//数值已经取出！
            }
        }

    }
}

8，堆排序

待完善...