Java数组实现起泡排序/归并排序/二分查找/斐波那契查找/Fibonacci查找

二分查找

时间复杂度:O(logn)
算法的思路是：
1.区间为左闭右开[lo,hi)
2. 每次while循环只进行一次大小判断e<nums[mid]，使代码每次判断的时间常量更小。

public static int binSearch(int[] nums, int lo, int hi, int e){
        while(lo<hi){
            int mid = (lo+hi)>>1;
            if(e<nums[mid])
                hi=mid;
            else
                lo=mid+1;
        }
        return --lo;
    }

斐波那契查找

时间复杂度：O(logn）
时间复杂度看上去与二分查找时间复杂度无区别，这是因为时间复杂度可以忽略logn前的常系数。fibonacci查找logn前的常系数小于二分查找。
算法的思路是：
1.基本思路与二分查找类似。
2.当整个区间的数组数量为fib(k)-1时，mid=fib(k-1)-1。mid的数值由当前小于hi-lo的最大fib值决定，即while(hi-lo<fib[num])num--;

 public static int fibSearch(int[] nums, int lo, int hi, int e){
        int[] fib = getFib(hi-lo);
        int num = nums.length;
        while(lo<hi){
            while(hi-lo<fib[num])num--;
            int mid = lo+fib[num]-1;
            if(e<nums[mid])
                hi=mid;
            else if(nums[mid]<e)
                lo=mid+1;
            else
                return mid;
        }
        return -1;
    }
    private static int[] getFib(int num){
        int[] fib = new int[num+1];
        if(num==0){
            return new int[]{0};
        }else if(num==1){
            return new int[]{0,1};
        }else{
            fib[0]=0;
            fib[1]=1;
            fib[2]=1;
            for(int i=3; i<num+1;i++){
                fib[i]=fib[i-1]+fib[i-2];
            }
            return fib;
        }

起泡排序

时间复杂度：O(n^2)
算法的思路是：
1.总体的趋势是每次都将数组当前区间剩余的最大元素运输到当前区间的最后一个元素上。
2.本算法的改进之处是，每次都将最后一个交换的元素下标作为下次交换的区间终点。这样在一个后面有序、前面乱序的数组中，可以节省很大的时间复杂度。但是总体上，这样的改进不会改变此排序算法的时间复杂度。

public static void bubbleSort(int[] nums, int lo, int hi){
        while(lo<hi){
            hi = bubble(nums,lo,hi);
        };
        return;
    }
    private static int bubble(int[] nums, int lo, int hi){
        int temp=0;
        while(++lo<hi){
            if(nums[lo-1]>nums[lo]){
                temp=lo;
                swap(nums,lo-1,lo);
            }
        }
        return temp;
    }
    private static void swap(int[] nums,int i, int j){
        int temp = nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
        return;
    }

归并排序

时间复杂度：O(nlogn)//这已经是排序算法最小的时间复杂度。
算法的思路是：
1.采用递归的思路，一直将序列进行二分的操作，直到一个数组中仅含有两个元素，对数组内的元素进行排序。之后，将二分的序列逐渐合并，完成数组的归并排序。
2.本次算法的改进是只复制前半部分的数组，然后依次覆盖掉原数组完成排序。同时算法在复制的前半部分数组都排列完成后，就可以终止。

public static void mergeSort(int[] nums, int lo, int hi){
        if(hi-lo<2){return;}
        int mid = (lo+hi)>>1;
        mergeSort(nums,lo,mid);
        mergeSort(nums,mid,hi);
        merge(nums,lo,mid,hi);
    }
    private static void merge(int[] nums, int lo, int mid, int hi){
        int lb = mid - lo;
        int[] B = new int[lb];
        for(int i=0; i<lb; i++){
            B[i]=nums[lo+i];
        }
        int lc=mid;
        for(int i=0,j=lc,k=lo;i<lb;){
            if((i<lb)&&(j>=hi||B[i]<=nums[j])){
                nums[k++]=B[i++];
            }else if(nums[j]<B[i]){
                nums[k++]=nums[j++];
            }
        }
    }