二分查找和升序排序及利用API（快速排序）的实现

一、升序排序

1.首先我们需要先定义一个数组

int[] arr = {5,1,3,2};

2.之后在排序的时候，需要定义一个变量，来控制循环的次数 j

若变量为 i ，那我们发现 j 永远要比 i 大，且随着 i 的变大，j 每轮遍历的数字就越来越少了

//i=0  j= 1 2 3
//i=1  j= 2 3
//i=2  j= 3

 所以我们可以令：

int j = i+1; j < arr.length; j++

 确定了两个变量之后，我们就开始排序了，也就是交换位置，让相邻的两个数字进行比大小，大的靠右边，小的靠左边，类似冒泡排序，大的慢慢向后靠，i 的每一轮，会经历好几个 j ，目的就是为了让遍历到的每一个 i 都找到合适的位置，这样 i 每向前走一步，就代表着这个数字已经找到正确的位置了

代码演示：

 //1.定义数组
        int[] arr = {5,1,3,2};
        //           0 1 2 3
        //2.定义一个循环控制选择几轮  arr.length - 1

        /**
         * 利用Arrays的API可以实现升序排序
         * Arrays.sort(arr);
           System.out.println(Arrays.toString(arr));
         */

        for (int i = 0; i < arr.length; i++) {
            //i=0  j= 1 2 3
            //i=1  j= 2 3
            //i=2  j= 3
            //定义内部循环，控制选择几次
            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;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

 3.利用API

在数组的API中，我们可以使用sort功能，利用sort的特有属性实现升序排序（sort利用的是快速排序）

 我们直接调用sort方法，既节约了空间，又省了时间，两全其美

         Arrays.sort(arr);
         System.out.println(Arrays.toString(arr));

代码演示：

   public static void main(String[] args) {
    
        int[] arr = {5,1,3,2};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
   }
         

 

二、二分查找，搜索算法

1、定义数组

int[] arr = {10,14,16,25,28,30,35,88,100};

2、定义一个方法

由于二分查找的代码量较多，我们不妨放在一个方法中，到时候直接调用，让main方法显得更加优雅。

public static int binarySearch(int[] arr, int data){

}

传入要进行位置确定的数组和要定位置的数据data 

（1）设定左边位置和右边位置

先确定两边的终点位置

int left = 0;
int right = arr.length - 1;

 （2）确定一个中间值middleIndex（不需要太具体，在偶数个元素时）

进行if判断

1.若data 比 middleIndex 大，

那我们应该往右边找，之后左边位置更新为 = 中间位置索引 +1

left = arr[middleIndex] + 1;

 2.若data 比 middleIndex 小，

那我们应该往左边找，右边位置更新为 = 中间索引 -1

right = arr[middleIndex] - 1;

3.如果data都不符合，与middleIndex 进行比较，不大不小，那么说明这个要找位置的值就是middleIndex

return middleIndex;

 4.若以上3种条件都不满足的话，那么我们就可以断定这个data不在这个数组中

return -1;//查无此元素

 代码演示：

 public static void main(String[] args) {
        
        int[] arr = {10,14,16,25,28,30,35,88,100};
        System.out.println(binarySearch(arr,28));//4
        System.out.println(binarySearch(arr,3000));//-1
    }


    public static int binarySearch(int[] arr, int data){
        
        int left = 0;
        int right = arr.length - 1;
        while(left <= right){
            
            int middleIndex = (left + right)/2;
            if(data > arr[middleIndex] ){
               
                left = arr[middleIndex] + 1;
            }else if(data < arr[middleIndex]){
                
                right = arr[middleIndex] - 1;
            }else{
                return middleIndex;
            }
        }
        return -1;//查无此元素
    }
}

5.利用API

数组的特有API binarySearch 进行查找（二分搜索技术）

 在binarySearch 的内部也是进行比大小，利用中间变量去比的

    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

所以我们在写时可以直接写binarySearch 进行查找

 int index = Arrays.binarySearch(arr,28);
 System.out.println(index);

得到的结果与上面的一样，但代码简洁了不少，显得代码更加优雅美观。

代码演示：

 public static void main(String[] args) {
        //1.定义数组
        int[] arr = {10,14,16,25,28,30,35,88,100};
        System.out.println(binarySearch(arr,28));//4
        System.out.println(binarySearch(arr,3000));//-1
        
         int index = Arrays.binarySearch(arr,28);
         System.out.println(index);
         
    }

NOTE：

在进行二分查找时，我们必须先对数组进行大小排序

才能调用API去找，不然容易报错，或找不到

优势：

二分查找每次砍掉一半的数据，会大大提高运行速度