数组的高级操作

二分查找

二分查找相当于每次去掉一半的查找范围
步骤：

1. 定义两个变量，表示要查找的范围，默认min = 0， max = 最大索引
2. 循环查找，但是min <= max
3. 计算出mid的值
4. 判断mid的位置元素是否为要查找的元素，如果是直接返回对应索引
5. 如果要查找的值在mid的左半边，那么min值不变，max = mid -1，继续下次循环查找
6. 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1，继续下次循环查找

7. 当min > max时，表示要查找的元素在数组中不存在，返回-1. ```java public class BinarySearch { public static void main(String[] args) {

    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16};
    int target = 1;
    int index = BinarySearchCore(arr, target);
    System.out.println(index);

   }

   private static int BinarySearchCore(int[] arr, int target) {

    int min = 0;
    int max = arr.length - 1;
    int index = -1;
    int mid = 0;
    while (min <= max){
        mid = (min + max) / 2;
        if (arr[mid] == target){
                index = mid;
                break;
        }else if(target < arr[mid]) {
                max = mid - 1;
   
        }else if(target > arr[mid]) {
                min = mid + 1;
   
        }
        }
    return index;
   

   }

}

<a name="nDptd"></a>
## 冒泡排序
```java
import java.util.Arrays;

public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {12,15,15,464,8,151,4,8,741,1,51,45,4584};
        BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void BubbleSort(int[] arr) {
        for (int n = arr.length - 1; n > 0; n--){
            for (int i = 0; i < n; i++) {
                if (arr[i] > arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

    }
}

递归

递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象
递归解决问题的思路：
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
递归解决问题要找到两个内容：

• 递归出口：否则会出现内存溢出
• 递归规则：与原问题相似的规模较小的问题

递归求阶乘

public class RecursionTest2 {
    public static void main(String[] args) {
        int result = getJc(5);
        System.out.println(result);
    }

    private static int getJc(int i) {
        if (i == 1){
            return 1;
        }
        return i * getJc(i - 1);
    }


}

快速排序

import java.util.Arrays;

public class QuickSortDemo1 {
    public static void main(String[] args) {
        int[] arr = {2,15,15,468,4,615,5,156,16,54,68,4,651,456,468,486,46,44,4,87,8,9,84,456};
        QuickSort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private static void QuickSort(int[] A, int p, int r) {
        if (p < r){
            int q = Partition(A,p,r);
            QuickSort(A,p,q-1);
            QuickSort(A,q+1,r);
        }
    }

    private static int Partition(int[] A, int p, int r) {
        int x = A[r];
        int i = p - 1;
        for (int j = p; j <= r - 1; j++){
            if (A[j] <= x){
                i += 1;
                int temp = A[i];
                A[i] = A[j];
                A[j] = temp;
            }
        }
        int temp = A[i + 1];
        A[i + 1] = A[r];
        A[r] = temp;
        return i + 1;
    }


}

Arrays类的概述和常用方法