java--二分查找，快速排序

例一：

给定数组a[0 : 8]={1, 8, 12, 15, 16, 21, 30, 35, 39}。采用二分搜索算法完成下述任务：

二分搜索是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

方法一：（非递归）

public static int findIndex(int[] arr, int x){

    int index = -1;
    int right = arr.length -1;
    int left = 0;
    while(left <= right)  {
        int middle = (left + right)/2;
        if(x < arr[middle]){
            right = middle-1;
        }else if(x > arr[middle]){
            left = middle+1;

        }else if(x == arr[middle]){
            index = middle;

            break;
        }
    }

//小于x的最大元素位置i和大于x的最小元素位置j。
    if(index == -1){
        if(left < right){
            System.out.println("i="+left+",j="+right);


        }else {
            System.out.println("i="+right+",j="+left);
        }

    }


    return index;
}

方法二：（递归）

递归的算法：首先都是先找到递归结束的条件，此算法递归结束的条件：1）、找到所要找的元素。2）找不到元素，也就是数组为空，那么条件就是left>right

第二：我们知道，这个算法是先比较，在分割成两个数组，也就是，先比较在递归。

public static int find(int[] arr, int left, int right, int key){
    int index = -1;
    if(left <= right){
        int middle = (left + right)/2;
        if(key == arr[middle]){
            index = middle;
        }else if(key < arr[middle]){
            index = find(arr, left, middle - 1, key);
        }else if(key > arr[middle]){
            index = find(arr, middle + 1,right,key);
        }
    }
    return index;
}

例二：

给定数组a[ ]={8，4，3，7，1，5，6，2}，使用快速排序算法对其进行排序

基本思想是：通过一趟排序将要排序的数据分割成独立的两 部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排 序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

此算法是以中间的数为基准

public class sy02 {
    public static void main(String[] args) {
        int[] arr = {8, 4, 3, 7, 1, 5, 6, 2, 5, 5};
        quickSort(arr, 0, arr.length - 1);
        System.out.print(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {

        int l = left;
        int r = right;
        int middle = (l + r) / 2;
        int temp = arr[middle];
        while (l < r) {
            while (temp < arr[r]) {
                r--;
            }
            while (temp > arr[l]) {
                l++;
            }
            if(l < r){
                int t = arr[l];
                arr[l] = arr[r];
                arr[r] = t;

               //如果交换完后，发现这个 arr[l] == temp 值 相等 r--， 后移
                if(arr[l] == temp) {
                    r -= 1;
                }
                //如果交换完后，发现这个 arr[r] == temp 值 相等 l++， 后移
                if(arr[r] == temp) {
                    l += 1;
                }

            }




        }
        //如果l==r，必须l++ r-- 否则为出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }


        //向左递归
        if (left < r) {
            quickSort(arr, left, r);

        }

        //向右递归
        if (right > l) {
//            System.out.println("L"+l+",right"+right);
            quickSort(arr, l, right);

        }
    }


}