三大基础排序

1.冒泡排序

• 两两比较大小后交换，正序(最快)，反序(最慢).

public class MaoPao {

    public static void main(String[] args) {
        MaoPao m = new MaoPao();
        int[] a = new int[10000];
        for (int i = 0; i < 10000; i++) {
            a[i] = (int) (Math.random() * 1000);
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(m.maoPao1(a) - m.maoPao2(a));
            System.out.println("--------");
        }



    }

    //冒泡排序，时间复杂度为n*n
    public long maoPao1(int[] nums) {
        long start = System.nanoTime();    //微妙 = 纳秒/1000
        for (int i = 0; i < nums.length; i++) {
            for (int j = 1; j < nums.length; j++) {
                if (nums[j] < nums[j - 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j - 1];
                    nums[j - 1] = temp;
                }
            }
        }
        long end = System.nanoTime();
//        System.out.println(end - start);
        return end - start;
    }

    public Long maoPao2(int[] nums){
        long start = System.nanoTime();
        for (int i = 0; i < nums.length; i++) {
            for (int j = 1; j < nums.length/2; j++) {
                if(nums[j] < nums[j-1]){
                    int temp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = temp;
                }
            }

            for (int m = nums.length-1; m > nums.length/2; m--) {
                if(nums[m] < nums[m-1]){
                    int temp = nums[m];
                    nums[m] = nums[m-1];
                    nums[m-1] = temp;
                }
            }
        }
        long end = System.nanoTime();
//        System.out.println(end-start);
        return end - start;
    }
}
222203299
--------
189292499
--------
38624699
--------

2.选择排序

• 每次循环找到最小值(最大值)，与外层边界数据进行交换。

//最简单实现：每次循环，取最小值进行交换
    public int[] select2(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            int min = i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[j] < nums[min])
                   min = j;
            }
            int temp = nums[min];
            nums[min] = nums[i];
            nums[i] = temp;
        }
        return nums;
    }
//优化方式：同时取最大最小值，后进行交换。
//特殊情况：考虑1.最大值在循环左边界处，最小值在最右边界处，此时，只能做一次交换。2.最大值在最左边界时，交换最小值导致最大值下标发生改变等等......

//他人以实现代码，可用
 public void betterSelectSort(int[] arr) {

        // left指针指向无序边界起点，right指针指向终点，temp用作临时变量交换值
        int left,right,temp;
        // 默认指向无序列表起点
        left = 0;
        // 默认指向无序列表终点
        right = arr.length - 1;
        // 记录每轮找到的最小值的下标
        int min;
        // 记录每轮找到的最大值的下标
        int max;
        // 当right >= left时，列表已经有序
        // 记录循环的次数
        int index = 0;
        while(left < right) {
            min = left;     // 每轮开始前，默认无序列表起点为最小值
            max = right;    // 每轮开始前，默认无序列表终点为最大值
            // 指针i从左往右扫描，找出最小值，最大值
            for (int i=left; i<=right; i++) {
                if (arr[i] <= arr[min]) {
                    min = i;    // 通过比较，记录最小值的下标
                }
                if(arr[i] >= arr[max]) {
                    max = i;    // 通过比较，记录最大值的下标
                }
            }
            index++;
            if (min == left && max == right){
                System.out.println("第" + index + "轮循环没有找到最值，无需交换");
            }else if (min == right && max == left){
                // 交换一次即可，交换两次的话，序列翻转，相当于没有交换
                temp = arr[left];
                arr[left] = arr[min];
                arr[min] = temp;
            }else {
                int minTemp = arr[min];
                int maxTemp = arr[max];
                // 找到最小值，交换
                temp = arr[left];
                arr[left] = minTemp;
                arr[min] = temp;

                // 找到最大值，交换
                if (max == left){
                    max = min;
                }
                temp = arr[right];
                arr[right] = maxTemp;
                arr[max] = temp;
            }
            // 确定最小/大值，指针向中间移动
            left++;right--;
        }
    }

3.插入排序

• 第一层循环的 元素，通过第二层循环，与它自身之前的数据进行比较后互换

public class Insert {

    public static void main(String[] args) {
        Insert i = new Insert();
        int[] a = new int[10];
        for (int j = 0; j < 10; j++) {
            int x = (int) (Math.random()*10);
            a[j] = x;
        }
        i.insert(a);
        System.out.println(Arrays.toString(a));
    }

    public void insert(int[] nums){
        for (int i = 1; i < nums.length; i++) {
            for (int j = i; j > 0 ; j--) {
                if(nums[j] < nums[j-1]){
                    int temp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = temp;
                }
            }
        }
    }
}