经典算法分析

1折半查找。,当给出的数组绝对有序时，可以使用折半查找的办法，可以将时间复杂度降低到logN级别。

package sort;

 

public class HalfSort {

 

    public static <AnyType extends Comparable<? super AnyType>> int binarySearch(

            AnyType[] a, AnyType x) {

        //定义两个游标，分别指向数组的开头和结尾

        int low = 0, high = a.length - 1;

        while (low <= high) {

            //找到中间的元素

            int mid = (low + high) / 2;

            //如果中间的那个元素小于比较的值，则从中间值的下一个到最后开始找

            if (a[mid].compareTo(x) < 0) {

                low = mid + 1;

            } else if (a[mid].compareTo(x) > 0) {

                high = mid - 1;

            } else {

                return mid;

            }

        }

 

        return -1;

 

    }

}

 

欧几里算法：

欧几里算法主要用来计算两个整数的最大公因式。。

public class GCD {

    public static long gcd(long m, long n) {

        while (n != 0) {

            long rem = m % n;

            m = n;

            n = rem;

        }

        return m;

    }

}

 

 

幂运算的解决办法。

计算X^N幂运算的思路是利用递归，将N<=1作为递归的基准情况，否则，如果N是偶数，我们有X^N=X^N/2* X^N/2,如果N是奇数，则X^N=X^(N-1)/2* X^(N-1)/2,所需要的乘法次数最多是2LogN

 

package sort;

 

public class POW {

    public static long pow(long x,int n){

        if(n==0){

            return 1;

        }

        if(n==1){

            return x;

        }

        //如果是偶数

        if(isEven(n)){

            //调用递归算法

            return pow(x*x,n/2);

        }else{

            //如果是奇数

            return pow(x*x,n/2)*x;

        }

    }

}