常见算法总结(1)

大约两个月前一位朋友问我一道他同事的面试题目：一个含有无重复元素的集合，找出它所有的子集。例如{1,2}的所有集合是{}, {1}, {2}, {1, 2}.

当时我预料到了这道题目的算法时间复杂度为O(2^n), 但是并没有写出代码来。前两天无意间又试着做了一下这道题目，然后接受查找的资料，原来这是一个专门的算法问题。学名为powerset.

代码如下：

/*
     * 该算法的基本原理是:将集合分成前后两个部分：
     * 前一部分是已经固定了的，后一部分为即将固定的，
     * 然后将即将固定的添加到已经固定的集合的后面。
     * 然后采用递归的方式，欲求｛1，n-1｝，必先求{2, n-2}，
     * 之后仿效类推，直到先求出{n-1, 1}
     */
    public static <T> Set<Set<T>> getPowerSet(Set<T> originalSet) {
        Set<Set<T>> sets = new HashSet<Set<T>>();
        if (originalSet.isEmpty()) {
            sets.add(new HashSet<T>());
            return sets;
        }
        List<T> list = new ArrayList<T>(originalSet);
        T head = list.get(0);
        Set<T> rest = new HashSet<T>(list.subList(1, list.size()));
        for (Set<T> set : getPowerSet(rest)) {
            Set<T> newSet = new HashSet<T>();
            newSet.add(head);
            newSet.addAll(set);
            sets.add(newSet);
            sets.add(set);
        }
        return sets;
    }

这个算法采用了泛型的方式，可以求整型、字符串和字符数组的子组合问题。

然后自己还写了个判断一个数字是否是素数的程序，之所以再写了一个是因为自己以前写的算法时间表复杂度为O(n^1/2),这个还是有可以优化的地方，比如下面这种算法：

public static boolean isPrime(long n) {
        if(n < 2) {
            return false;
        }
        if(n == 2 || n== 3){
            return true;
        }
        if(n%2 == 0 || n%3==0){
            return false;
        }
        long sqrt=(long) (Math.sqrt(n)+1);
        for (long i = 6L; i <=sqrt; i+=6L) {
            if(n%(i-1) == 0 || n%(n+1)==0){
                return false;
            }
        }
        return true;
    }

这种算法使用了判断诸如2, 3, 5, 7, 11, 13...这些比较小的素数是否是n的因子来判断n是否是素数，明显地提升了算法的时间复杂度。

还有一道题目是求数组的最大和的问题。常见的解法是采用动态规划跟记忆算法，采用O(n^2)的时间来循环求解，但是这里有一个复杂度为O(n)的解法，代码如下：

/*该算法的时间复杂度为: O(n)*/
    public static int maxSubsum(int[] array) {
        int maxSum=0;
        int tempSum=0;
        for (int i = 0; i < array.length; i++) {
            tempSum+=array[i];
            if(tempSum > maxSum){
                maxSum=tempSum;
            }else if (tempSum < 0) {
                tempSum=0;
            }
        }
        return maxSum;
    }

的确，这种解法真的非常巧妙。

今天对这个解法进行了一些功能扩充，就是要求将具有最大各的子数组的起始位置找出来，具体代码如下：

/* 该算法的时间复杂度为: O(n) */
    public static int maxSubArraySum2(int[] array) {
        if (array == null) {
            return -1;
        }
        int maxSum = 0;
        int tempSum = 0;
        int start = 0, end = 0, curStart = 0;
        for (int i = 0; i < array.length; i++) {
            if (tempSum < 0) {
                tempSum = array[i];
                curStart = i;
            } else {
                tempSum += array[i];
            }
            if (tempSum > maxSum) {
                maxSum = tempSum;
                start = curStart;
                end = i;
            }
        }
        System.out.println("Start---" + start + ",  End---" + end);
        return maxSum;
    }

思路是一样的，只是因为要找出子数组的索引，所以对代码的基本结构进行了一些调整，但逻辑跟时间复杂度并没有发生变化。

还有一个算法题目是：自己实现一个power函数。在java的Math库的，有pow(double base, double exp)方法，返回base的exp次方。一般有两种算法，先看一下只对int进行处理的循环和递归算法：

/* when exp is bigger than zero */
    public static int ipow1(int base, int exp) {
        int result = 1;
        while (exp != 0) {
            if ((exp & 1) == 1) {
                result *= base;
            }
            exp >>= 1;
            base *= base;
        }
        return result;
    }

    /* when exp is bigger than zero */
    public static long ipow2(long base, long exp) {
        if (exp == 0) {
            return 1;
        }
        if (exp == 1) {
            return base;
        }

        if (exp % 2 == 0) {
            long half = ipow2(base, exp / 2);
            return half * half;
        } else {
            long half = ipow2(base, (exp - 1) / 2);
            return base * half * half;
        }
    }

以上的两种方法都是在base和exp不小于0的情况下进行的讨论。

后者是递归的实现方式：分成了exp是奇数还是偶数两种情况进行讨论。关于递归，有一个经典名言：“In order to understand recursion, you must first understand recursion.”。就像GNU的定义一样，自己去理解吧。

下面看一下对base和exp可以是任意数值(exp是int)的情况下循环方式的实现：

/* when exp or base could be smaller than zero */
    public static double ipow3(double base, int exp) {
        if (base == 0.0D && exp < 0) {
            throw new ArithmeticException("Dividend can't be zero");
        }
        int tmpExp = Math.abs(exp);
        double temBase = Math.abs(base);
        double tempResult = 1;
        while (tmpExp != 0) {
            if ((tmpExp & 1) == 1) {
                tempResult *= temBase;
            }
            tmpExp >>= 1;
            temBase *= temBase;
        }
        boolean isBaseNegative = base < 0;
        boolean isExpNegative = exp < 0;
        boolean isExpEven = (exp % 2 == 0);
        if (!isBaseNegative && !isExpNegative) {
            return tempResult;
        } else if (!isBaseNegative && isExpNegative) {
            return 1 / tempResult;
        } else if (isBaseNegative && !isExpNegative) {
            if (isExpEven) {
                return tempResult;
            } else {
                return -tempResult;
            }
        } else {
            if (isExpEven) {
                return 1 / tempResult;
            } else {
                return -1 / tempResult;
            }
        }
    }

 这里增加了对base和exp为负数时的讨论，以及base=0而exp<0的异常抛出。

暂时只想到了这么多，以后再想到了会及时的添加上去。