排序及二分查找：冒泡排序；选择排序；直接插入排序；快速排序；二分查找

一、排序

1、冒泡排序

2、选择排序

3、直接插入排序

4、快速排序

快速排序算法思想

分治法：比大小，再分区
1.从数组中取出一个数，作为基准数。
2.分区：将比这个数大或等于的数全放到他的右边，小于他的数
全放到他的左边。
3.再对左右区间重复第二步，直到各区间只有一个数

实现思路

挖坑填数

1.将基准数挖出形成第一个坑。
2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
4.再重复执行2，3两步骤。

例如对 5391672408 进行排序

元素	5	3	9	1	6	7	2	4	0	8
坑位	坑位1		坑位3		坑位5	坑位7	坑位6	坑位4	坑位2
第一轮	0	3	4	1	2	5	7	6	9	8

二、二分查找

二分查找前提：数组必须有序

代码演示：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr = {55, 33, 77, 11, 99, 22, 44, -1, 0};
        Tools.bubbleSort(arr);//冒泡排序
        System.out.println(Arrays.toString(arr));

        int[] arr1 = {55, 33, 77, 11, 99, 22, 44, -1, 0};
        Tools.selectSort(arr1);//选择排序
        System.out.println(Arrays.toString(arr1));

        int[] arr2 = {55, 33, 77, 11, 99, 22, 44, -1, 0};
        Tools.directInsertionSort(arr2);//直接插入排序
        System.out.println(Arrays.toString(arr2));

        int[] arr3 = {55, 33, 77, 11, 99, 22, 44, -1, 0};
        Tools.quickSort(arr3, 0, arr3.length - 1);//快速排序
        System.out.println(Arrays.toString(arr3));

        int[] arr4 = {-1, 0, 11, 22, 33, 44, 55, 77, 99};
        int ele = 99;
        int index = Tools.binarySearch(arr4, ele);
        System.out.println(new StringBuilder().append(ele).append("的索引是：").append(index));
    }
}

//定义排序及二分查找工具类
class Tools {
	//私有化构造方法
	private Tools(){}
	//提供公共静态的方法
    //冒泡排序
    public static void bubbleSort(int[] arr) {
        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]) {
                    exchange(arr, j, j + 1);
                }
            }
        }
    }

    //选择排序
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    exchange(arr, i, j);
                }
            }
        }
    }

    //直接插入排序
    public static void directInsertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    exchange(arr, j, j - 1);
                }
            }
        }
    }

    //快速排序
    public static void quickSort(int[] arr, int start, int end) {
        if (start >= end||end<=0||arr==null) {
            return;
        }else {
            int index = getIndex(arr, start, end);
            quickSort(arr, start, index - 1);
            quickSort(arr, index + 1, end);
        }
    }

    public static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        int x = arr[i];
        while (i < j) {
            while (i < j && arr[j] >= x) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            while (i < j && arr[i] < x) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = x;
        return i;
    }

    //交换值
    public static void exchange(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    //二分查找
    public static int binarySearch(int[] arr, int ele) {
        int maxIndex = arr.length - 1;
        int minIndex = 0;
        int midIndex = (maxIndex + minIndex) >>> 1;
        while (minIndex <= maxIndex) {
            if (ele == arr[midIndex]) {
                return midIndex;
            } else if (ele < arr[midIndex]) {
                maxIndex = midIndex - 1;
            } else {
                minIndex = midIndex + 1;
            }
            midIndex = (maxIndex + minIndex) >>> 1;
        }
        return -1;
    }
}
运行结果：
[-1, 0, 11, 22, 33, 44, 55, 77, 99]
[-1, 0, 11, 22, 33, 44, 55, 77, 99]
[-1, 0, 11, 22, 33, 44, 55, 77, 99]
[-1, 0, 11, 22, 33, 44, 55, 77, 99]
99的索引是：8

Process finished with exit code 0