三种常见算法：冒泡，二分查找，选择排序

1、冒泡排序算法：

思路：
1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
2、核心：拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。

模拟代码运行过程
原始数据：3, 2, 7, 6, 8 (n个数据 外层循环n-1次)
第1次循环：(最大的跑到最右边。)
2, 3, 7, 6, 8（3和2比较，2 < 3，所以2和3交换位置）
2, 3, 7, 6, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）
2, 3, 6, 7, 8 （7和6交换位置）
2, 3, 6, 7, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）
经过第1次循环，此时剩下参与比较的数据：2, 3, 6, 7

第2次循环：2, 3, 6, 7 (2和3比较，3和6比较,6和7比较，都不需要交换位置) 经过第2次循环，此时剩下参与比较的数据：2, 3, 6

第3次循环：2, 3, 6 (2和3比较，3和6比较，都不需要交换位置)
经过第3次循环，此时剩下参与比较的数据：2,3

第4次循环： 2, 3 (2和3比较，不需要交换位置)

代码如下：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 2, 7, 6, 8};

        //数组长度为5，外层循环四次
        for(int i = arr.length-1; i > 0; i--){
        	//内层循环 5个数比四次  
            for(int j = 0; j < i; j++){  //j=0代表元素下标
                // 不管是否需要交换位置，总之是要比较一次的。
                if(arr[j] > arr[j+1]){
                    // 交换位置。
                    // arr[j] 和 arr[j+1] 交换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

2、二分查找

思路：
因为二分查找是基于排序好的基础之上的，所以选择两个起始下标，一个在最左边left，一个最右边right，相加除2，取中间位置的数字，与目标数字相比较，如果比目标数字大的话，证明想要找的目标数字在中间数与最大数之间，所以可以调整left下标 = mid + 1.如此循环，直至找出目标数字
模拟代码运行过程：
arr数组：10(下标0) 11 12 13 14 15 16 17 18 19 20(下标10)

要求：通过二分法查找，找出18这个元素的下标：
(0 + 10) / 2 --> 中间元素的下标： 5
拿着中间这个元素和目标要查找的元素进行对比：中间元素是：arr[5] --> 15
15 < 18(被查找的元素)，被查找的元素18在目前中间元素15的右边。所以开始元素的下标从0变成 5 + 1.

再重新计算一个中间元素的下标：
开始下标是：5 + 1，结束下标是：10；(6 + 10) / 2 --> 8
8下标对应的元素arr[8]是18，找到的中间元素正好和被找的的元素18相等，表示找到了：下标为8。

public class ArrayUtil {
    public static void main(String[] args) {
        int[] arr={100,200,230,235,600,1000,2000,9999};

        // 找出arr这个数组中200所在的下标
        int index=binarySearch(arr,200);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标为： "+index);
    }

    /**
     * 从数组中查找目标元素的下标。
     * @param arr 被查找的数组（这个必须是已经排序的。）
     * @param dest 目标元素
     * @return -1表示该元素不存在，其它表示返回该元素的下标。
     */
    public static int binarySearch(int[] arr, int dest) {
        int begin = 0;// 开始下标
        int end = arr.length - 1;// 结束下标
        //开始元素的下标只要在结束元素下标的左边，就会循环
        while (begin <= end) {
            int mid = (begin + end) / 2;
            if (arr[mid] == dest) {
                return mid;
            } else if (arr[mid] < dest) {
                // 目标在“中间”的右边
                // 开始元素下标需要发生变化（开始元素的下标需要重新赋值）
                begin = mid + 1;
            } else {
                //目标元素在"中间"的左边
                end = mid - 1;
            }
        }
        return -1;
    }
}

3、选择排序

思路：每一次从这堆“参与比较的数据当中”找出最小值，拿着这个最小值和“参与比较的这堆最前面的元素”交换位置。
选择排序比冒泡排序好在：每一次的交换位置都是有意义的。
关键点：选择排序中的关键在于，你怎么找出一堆数据中最小的。

模拟代码运行过程：
3 2 6 1 5
假设：第一个3是最小的。
3和2比较，发现2更小，所以此时最小的是2.
继续拿着2往下比对，2和6比较，2仍然是最小的。
继续拿着2往下比对，2和1比对，发现1更小，所以此时最小的是1.
继续拿着1往下比对，1和5比对，发现1还是小的，所以1就是最小的。
拿着1和最左边的3交换位置。

参与比较的数据：3 1 6 2 5 （参加比较的数据中最左边的元素下标是0）
第1次循环之后的结果是：1 3 6 2 5

参与比较的数据：3 6 2 5 （参加比较的数据中最左边的元素下标是1）第2次循环之后的结果是： 2 6 3 5

参与比较的数据：6 3 5 （参加比较的数据中最左边的元素下标是2）
第3次循环之后的结果是：3 6 5

参与比较的数据：6 5 （参加比较的数据中最左边的元素下标是3）
第4次循环之后的结果是： 5 6

public class SelectSort {
    public static void main(String[] args) {
        int[] arr={3,1,6,2,5};
        
        //选择排序 5条数据循环四次 （外层）
        for (int i = 0; i <arr.length ; i++) {
            // i是一个参与比较的这堆数据中的起点下标。
            // 假设起点i下标位置上的元素是最小的。
            int min = i;
            for (int j =i+1; j <arr.length ; j++) {
                if(arr[j]<arr[min]){
                    min=j; //最小值的元素下标是j
                }
            }
            // 当i和min相等时，表示当前的就是最小的元素。
            // 当i和min不相等时，表示最初猜测是错的，有比这个元素更小的元素，需要拿着这个更小的元素和最左边的元素交换位置。
            if (min != i){
                // 表示存在更小的数据，arr[min]就是最小的数据
                int temp=arr[min];
                arr[min]=arr[i];
                arr[i]=temp;
            }
        }
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}