学习笔记，排序 查找

选择排序：

    /*
     * 选择排序
     */
    public static void choiceSort(int[] arrs){
        for (int i = 0; i < arrs.length-1; i++) {
            for (int j = i; j < arrs.length-1; j++) {
                if(arrs[i]<arrs[j+1]){
                    int t;
                    t = arrs[i];
                    arrs[i] = arrs[j+1];
                    arrs[j+1] = t;
                }
            }
        }
    }

冒泡排序：

/*
     * 冒泡排序
     */
    public static void bubbleSort(int[] arrs){
        for (int i = 0; i < arrs.length-1; i++) {
            for (int j = 0; j < arrs.length-i-1; j++) {
                if(arrs[j]>arrs[j+1]){
                    int temp;
                    temp = arrs[j];
                    arrs[j] = arrs[j+1];
                    arrs[j+1] = temp;
                }
            }
        }
    }

快速排序：

/*
     *  快速排序
     * @param array 数组
     * @param left 数组的前下标
     * @param right 数组的后下标
     * @return key的下标index，也就是分片的间隔点
     */ 
    public static void partition(int []array,int left,int right){
        //选取基准点
        int i = left;
        int j = right;
        int key = array[0];  //6
            while(i<j){
                //从后面扫描
                while(array[j] >= key &&i <j){
                    j--;
                }
                if(i<j){
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
                //然后从前面扫描
                while(array[i]<=key && i < j){
                    i++;
                }
                if(i<j){
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
                partition(array, left, i-1);
                partition(array, i+1, right);
        }
    }

二分查找：

    /*
     * 二分查找递归写法
     */
    public static int middleSortByRecursion(int[] arr,int item,int low,int high){

　　　　　　if(item < arr[low] || item > arr[high] || low > high){
　　　　　　　　return -1;
　　　　　　}

int mid = (low+high)/2;
        if(low>high){
            return -1;
        }
        if(arr[mid] > item){
            high = mid - 1;
            return middleSortByRecursion(arr, item, low, high);
        }else if (arr[mid] == item) {
            return mid;
        }else {
            low = mid + 1; 
            return middleSortByRecursion(arr, item, low, high);
        }
    }

    /*
     *二分查找一般写法
     */
    public static int middleSort(int[] arr,int item){

　　　　　　if(item < arr[0] || item > arr[arr.length]){
　　　　　　　　return -1;
　　　　　　}

int low = 0;
        int high = arr.length - 1;
        int mid;
        while(low <= high){
            mid =(low+high)/2;
            if(arr[mid]==item){
                return mid;
            }else if (arr[mid]> item) {
                high = mid-1;
            }else {
                low = mid+1;
            }
        }
        return -1;
    }