JAVA 之数组的高级操作 二分查找 冒泡排序 递归 快速排序 Arrays类

二分查找   相当于每次去掉一半的查找范围 （适用于数组成员按大小排列）

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.

public class Test {

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10,11};
        int num = 6;
        int index =getIndex(arr,num);
        System.out.println(index);
    }
    public static int getIndex(int[] arr,int num){
        int index=-1;
        int min = 0;
        int max = arr.length-1;
        while1:while (min<=max){  for (int i = 0; i < arr.length; i++) {
            int mid = (min+max)/2;
            if(arr[mid]<num){
                min=mid+1;

            } else if (arr[mid] > num) {
                max=mid-1;
            }else {
                index = mid;
                return index;
            }
        }}
        return index;
    }
}

冒泡排序 

排序：将一组数据按照固定的规则进行排列

冒泡排序：相邻的数据两两比较，小的放前面，大的放后面。

public class Test {

    public static void main(String[] args) {
        int[] arr = {1,6,6,8,7,9,10,4};
        int[] arr2 =paiXu(arr);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
    public static int[] paiXu(int[] arr){
         //外层控制循环次数，只需要循环长度减一次   
        for (int j = 0; j < arr.length-1; j++) {
         //z这里 -1 是防止索引溢出，-j是每循环一次，比较的次数就少一次
        //内循环为，如果前面的数大于后面的 则交换位置
            for (int i = 0; i < arr.length-1-j; i++) {
                if(arr[i]>=arr[i+1]){
                    int temp =arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
      return arr;
    }
}

递归

递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象

递归解决问题的思路： 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容：

递归出口：否则会出现内存溢出

递归规则：与原问题相似的规模较小的问题

例子，递归求阶乘

public class Test {

    public static void main(String[] args) {
        int a = diGui(5);
        System.out.println(a);
    }
    private static int diGui(int i) {
        if(i==1){
            return 1;
        }else {
            return i*diGui(i-1);
        }
    }
}

用递归实现快速排序

public class Test {

    public static void main(String[] args) {
        int[] arr = {5, 2, 4, 7, 6, 12, 3, 9, 8, 7,1};
       quiteSort(arr,0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    private static void quiteSort(int[] arr, int left, int right) {
        // 递归结束条件
        if (right < left) {
            return ;
        }
        int left0 = left;
        int right0 = right;
        //计算出基准数
        int baseNumber = arr[left0];
        while (left != right) {
            // 1，从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            // 2，从左开始找比基准数大的
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            // 3，交换两个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        // 基准数归位
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;

        // 递归调用自己,将左边排好
        quiteSort(arr, left0, left-1);

        //  递归调用自己将右边排好
        quiteSort(arr, left +1, right0);

    }

}

Arrays 类

public static String toString​(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort​(int[] a)	按照数字顺序排列指定的数组
public static int binarySearch​(int[] a, int key)	利用二分查找返回指定元素的索引

当使用binarySearch的时候如果元素不存在，则返回-该插的位置-1；