冒泡排序：相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
        public static void bubbleSort(int[] arr) {
                //{24, 69, 57,13 , 80};
                for (int i = 0; i < arr.length - 1; i++) {                //外循环只需要比较arr.length-1次就可以了
                        for (int j = 0; j < arr.length - 1 - i; j++) {        //-1为了防止索引越界,-i为了提高效率
                                if(arr[j] > arr[j+1]) {
                                        int temp = arr[j];
                                        arr[j] = arr[j + 1];
                                        arr[j+1] = temp;
                                }
                        }
                }
        }
        
选择排序：从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

        public static void selectSort(int[] arr) {
                //{24, 69, 80, 57, 13};
                for (int i = 0; i < arr.length - 1; i++) {        //只需要比较arr.length-1次
                        for (int j = i + 1; j < arr.length; j++) {
                                if(arr > arr[j]) {
                                        int temp = arr;
                                        arr = arr[j];
                                        arr[j] = temp;
                                }
                        }
                }
        }

二分法查找：
        前提是数组必须是有序的：
                //int[] arr = {11,22,33,44,55,66,77};
                public static int getIndex(int[] arr, int value) {
                        int min = 0;
                        int max = arr.length - 1;
                        int mid = (min + max) / 2;
                        
                        while(arr[mid] != value) {                //当中间值不等于要找的值,就开始循环查找
                                if(arr[mid] < value) {                //当中间值小于了要找的值
                                        min = mid + 1;                //最小的索引改变
                                }else if (arr[mid] > value){        //当中间值大于了要找的值
                                        max = mid - 1;                //最大的索引改变
                                }
                                
                                mid = (min + max) / 2;                //无论最大还是最小改变,中间索引都会随之改变
                                
                                if(min > max) {                        //如果最小索引大于了最大索引,就没有查找的可能性了
                                        return -1;                //返回-1
                                }
                        }
                        return mid;
                }

留名后学

好绑啊好绑啊好绑啊好绑啊好绑啊好绑啊好绑啊好绑啊

顶一个！