快速排序，二分查找（以后自己看）

1.快速排序

public class QuickSort {

    public static void main(String[] args) {
        int x[] = {6, 1, 2, 7, 9, 100, 100, 4, 5, 10, 8}; //i = 0, j = 10
        quickSort(x, 0, x.length - 1);
        for (int i = 0; i < x.length; i++) {
            System.out.print(x[i] + " ");
        }

    }

    private static void quickSort(int[] arr, int low, int high) {

        if (low >= high) {
            return;
        }

        // 选择一个基准值（为了简单，选择数组中第一个数作为基准值）
        int mid = arr[low];

        /**
         * 为什么用left和right表示low和high呢？
         * 因为low和high要用在最后面的递归调用，所以不能更改这两个变量的值。
         */

        // 申明一个从左往右找值的哨兵
        int left = low;
        // 申明一个从右往左找值的哨兵
        int right = high;

        while (left < right) {
            // 从右往左找比中位数小的值
            // 注意：包含等于！！！
            while (arr[right] >= mid && left < right) {
                right--;
            }
            // 从左往右找比中位数大的值
            // 注意：包含等于！！！
            while (arr[left] <= mid && left < right) {
                left++;
            }

            // 当找到两个想要的值，交换
            if (left < right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }
        }

        /**
         * 到此一个while结束后，left = right,而且此时arr[left]的值小于middle，
         * 因为我们先从右边开始找的,所以肯定是right-1后碰到的left，
         * 如果left经历过交换的话，arr[left]的值肯定小于middle，
         * 如果没经历过交换的话arr[left]的值就是middle，
         * 所以把arr[left] 和 middle交换是没问题的
         */
        arr[low] = arr[left];
        arr[left] = mid;
        // 分治递归
        quickSort(arr, low, left - 1);
        quickSort(arr, left + 1, high);

    }
}

2.二分查找（递归与非递归）

/**
 * 二分查找（折半查找）
 * 要求：按照关键字有序
 * 非递归
 *  * T(n)=O(logn)
 *  * S(n)=0(1)
 */
public class TestSearch1 {
    public static void main(String[] args) {
        //给定数组
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //给定要查找的值
        int key = 2;

        //进行二分查找

        int index = binarySerarch(array, key);

        //输出结果
        if (index == -1) {
            System.out.println("不存在");
        } else {
            System.out.println(key + "的索引是" + index);
        }
    }

    //非递归
    private static int binarySerarch(int[] array, int key) {
        //指定low,high
        int low = 0;
        /*
         *注意：因为high表示的是数组下标，所以长度是10的数组，最多下标是9
         */
        int high = array.length - 1;

        //折半查找
        while (low <= high) {//小于等于，不然如果10才是要查找的，就会报不存在
            //求mid
            int mid = (low + high) / 2;
            if (key == array[mid]) {
                return mid;
            } else if (key < array[mid]) {
                //比如10个数，第一次比较的是2和（0+10）/2=5的大小，小于5，所以再比较应当是0-4，也就是mid-1
                high = mid - 1;//
            } else {
                low = mid + 1;
            }
        }
        return -1;

    }

}

package search;

/**
 * 二分查找（折半查找）
 * 要求：按照关键字有序
 * 递归
 * T(n)=O(logn)
 * S(n)=0(logn)
 */
public class TestSearch2 {
    public static void main(String[] args) {
        //给定数组
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //给定要查找的值
        int key = 2;

        //进行二分查找

        int index = binarySerarch(array, key);

        //输出结果
        if (index == -1) {
            System.out.println("不存在");
        } else {
            System.out.println(key + "的索引是" + index);
        }
    }

    //非递归
    private static int binarySerarch(int[] array, int key) {
        //指定low,high
        int low = 0;
        int high = array.length - 1;
        return binarySerarch(array, key, low, high);


    }

    private static int binarySerarch(int[] array, int key, int low, int high) {
        //结束条件
        if (low > high) {
            return -1;
        }
        int mid = (low + high) / 2;

        if (key == array[mid]) {
            return mid;
        } else if (key < array[mid]) {
            return binarySerarch(array, key, low, mid - 1);
        } else {
            return binarySerarch(array, key, mid + 1, high);
        }


    }
}