Java 排序

冒泡排序

• 最出名的排序算法之一。总共有八大排序
• 时间复杂度 O(n2)
• 利用flag进行优化

动图演示

![\]](https://img-blog.csdnimg.cn/565d0639353e40e8a8caa1fb6408f69e.gif)

package com.wang.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {

        int[] a = {1,2,4,5,6,6745,4,5435,9};
        //调用自己写的排序方法以后，返回一个排序后的数组
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }

    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
    //2.每一次比较，都会产生一个最大或最小的数字；
    //3.下一轮，可以少一次排序
    //4.依次循环，直到结束
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {

            boolean flag = false;//通过flag标识减少没有意义的比较

            //内层循环，比较两个数，如果第一个数比第二个数大，就交换他们的位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }

            if (flag == false){
                break;
            }

        }

        return array;
    }

}

选择排序

• 从0索引开始，拿着每一个索引上的元素跟后面的元素比较，小的放前面，大的放后面，以此类推

动画图示

package com.mysort;

public class SelectionDemo {
    public static void main (String[] args) {
        /**
         * 从0索引开始，拿着每一个索引上的元素跟后面的元素比较，小的放前面，大的放后面
         */

        //定义数组
        int[] arr = {2,4,5,3,1};

        //利用选择排序，让数组变成1,2,3,4,5
/*        for (int i = 1; i < arr.length; i++) {
            if (arr[0]>arr[i]){
                int temp = arr[0];
                arr[0] = arr[i];
                arr[i] = temp;
            }
        }*/
        printArr (arr);

        for (int i = 0; i < arr.length - 1; i++) {
            //内循环：每一轮我要干什么
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr (arr);

    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print (arr[i]+"");
        }
        System.out.println ();
    }
}

插入排序

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个元素当成无序的
遍历无序的数据，将遍历到的元素插入到有序序列中适当的位置，如果遇到相同数据，插在后面
N的范围：0~最大索引

动画图示

package com.mysort;

public class InsertDemo {
    public static void main (String[] args) {
        /**
         * 	将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个元素当成无序的
         * 	遍历无序的数据，将遍历到的元素插入到有序序列中适当的位置，如果遇到相同数据，插在后面
         * 	N的范围：0~最大索引
         */

        int[] arr = {3,44,38,5,47,25,36,26,27,2,4,29,50,48};

        //1. 找到无序的哪一组数据是从哪个索引开始的
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i+1]){
                startIndex = i + 1;
                break;
            }
        }

        //遍历从startIndex开始的到最后一个元素，以此得到无序的那一组数据中的每一个元素、
        for (int i = startIndex; i < arr.length; i++) {
            //如何把遍历到的数据插入到有序序列

            //记录当前要插入数据的索引
            int j = i;

            while (j > 0 && arr[j]<arr[j-1]){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                j--;
            }
        }
        printArr(arr);
    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print (arr[i]+" ");
        }
        System.out.println ();
    }
}

快速排序

第一轮：把 0 索引的数字作为基准数，确定基准数在数组中的正确的位置。
把比基准数小的全部放在左边，比基准数大的全部放在右边
后面以此类推

动画图示

package com.mysort;

import java.util.Random;

public class QuickSort {
    public static void main (String[] args) {
        /**
         * 	第一轮：把 0 索引的数字作为基准数，确定基准数在数组中的正确的位置。
         * 	把比基准数小的全部放在左边，比基准数大的全部放在右边
         * 	后面以此类推
         */

        /*int[] arr = {6,1,2,7,9,3,4,5,10,8};

        quickSort (arr,0,arr.length - 1);

        printArr (arr);*/

        int[] arr = new int[1000000];
        Random r = new Random ();

        for (int i = 0; i < arr.length; i++) {
            arr[i]=r.nextInt ();
        }

        long start = System.currentTimeMillis ();
        quickSort (arr,0,arr.length - 1);
        long end = System.currentTimeMillis ();

        System.out.println (end-start);

    }

    public static void quickSort(int[] arr,int i,int j){
        /**
         * 参数一：我们要排序的数组
         * 参数二：要排序的数组的启示索引
         * 参数三：要排序数组的结束索引
         */

        //定义两个变量，记录要查找的范围
        int start = i;
        int end = j;

        if (start>end){
            //递归出口
            return;
        }

        //记录基准数
        int baseNumber = arr[i];

        //利用循环找到要交换的数字
        while (start != end){
            //利用end，从后往前开始找，找比基准数小的数字
            while (true){
                if (end <= start || arr[end] < baseNumber){
                    break;
                }
                end--;
            }
            //利用start从前往后找，比基准数大的数字
            while (true){
                if (end <= start || arr[start] > baseNumber){
                    break;
                }
                start++;
            }
            //把end和start指向的元素，进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

        //当start和end指向同一个元素的时候，那么循环停止：表示已经找到了基准数应该存入的位置（基准数归位）
        //就是拿着这个范围中的第一个数字和start交换
        int temp = arr[i];
        arr[i] =  arr[start];
        arr[end] = temp;

        //第一轮结束后，确定基准数左边的范围，重复刚刚所做的事情
        quickSort (arr,i,start-1);

        //第一轮结束后，确定基准数右边的范围，重复刚刚所做的事情
        quickSort (arr,start+1,j);

    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print (arr[i]+" ");
        }
        System.out.println ();
    }
}