算法一（java版）

  /**
     * 二分查找算法，返回数组下标 O(log(n))
     * @param arr
     * @param target
     * @return
     */
    public static int binarySearch(int[] arr,int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = (high + low)/2;
            if(arr[mid] == target){
                return mid;
            }else if(arr[mid] > target){
                high = mid;
            }else{
                low = mid;
            }
        }
        return -1;
    }

    /**
     * 寻找最小数
     * @param arr
     * @return
     */
    public static int findSmallest(int[] arr){
        int small = arr[0];
        for(int i=1;i<arr.length;i++){
            if(small>arr[i]){
                small = arr[i];
            }
        }
        return small;
    }

    /**
     * 选择排序 从小到大  O(n2)
     * @param arr
     * @return
     */
    public static int[] selectSortAsc(int[] arr){
        int[] newArr = new int[arr.length];
        int len = arr.length;
        for(int i=0;i<len;i++){
            newArr[i] = findSmallest(arr);
            arr = arrRemove(arr,newArr[i]);
        }
        return newArr;
    }

    /**
     * 移除数组中指定元素
     * @param arr
     * @param desc
     * @return
     */
    public static int[] arrRemove(int[] arr,int desc){
        int[] newArr = new int[arr.length-1];
        int idx = 0;
        boolean flag = false;
        for(int i=0;i<arr.length;i++){
            if(!flag){
                if(arr[i]==desc){
                    flag = true;
                    continue;
                }
            }
            newArr[idx++] = arr[i];
        }
        return newArr;
    }

    /**
     * 数组转为字符串
     * @param arr
     * @return
     */
    public static String arr2Str(int[] arr){
        StringBuffer sb = new StringBuffer();
        for(int i=0;i<arr.length;i++){
            sb.append(arr[i]).append(" ");
        }
        return sb.toString();
    }

    /**
     * 快速排序  O(nlog(n))
     * @param arr
     * @return
     */
    public static List<Integer> quickSort(List<Integer> arr){
        if(arr.size()<2){
            return arr;
        }else{
            int pivot = arr.get(0);
            List<Integer> less = new ArrayList<>();
            List<Integer> greater = new ArrayList<>();
            for(int i=1;i<arr.size();i++){
                if(arr.get(i)>pivot){
                    greater.add(arr.get(i));
                }else{
                    less.add(arr.get(i));
                }
            }
            List<Integer> newLess = quickSort(less);
            List<Integer> newGreater = quickSort(greater);
            newLess.add(pivot);
            newLess.addAll(newGreater);
            return newLess;
        }
    }

    /**
     * 快速排序
     * @param arr
     * @param low
     * @param high
     */
    public static void quickSort(int[] arr,int low,int high){
        if(low>=high){
            return;
        }
        int left = low;
        int right = high;
        int tmp = arr[low];
        int t;
        while (left<right){
            while(arr[right]>=tmp&&left<right){
                right--;
            }
            while(arr[left]<=tmp&&left<right){
                left++;
            }
            if(left<right){
                t = arr[right];
                arr[right] = arr[left];
                arr[left] = t;
            }

        }
        arr[low] = arr[left];
        arr[left] = tmp;
        quickSort(arr,low,left-1);
        quickSort(arr,right+1,high);
    }

    /**
     * 冒泡排序 O(n2)
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }