编程之美需整理的题目汇总

2.1 求二进制中1的个数。

2.2 求n！末尾有多少个0 和 求n!的二进制表示中最低位1的位置。

2.3 找出数量超过总数一半的记录。 扩展：3个发帖都超过了总数N的1/4。

2.4 十进制1~N 所有整数中1的个数； 满足F(N)=N的最大的N是多少。 扩展：CC上所有2的个数。

2.5 寻找最大的k的个数。

2.6 精确表达浮点数

2.7 最大公约数问题。

2.8 任意给定一个正整数N，求一个最小的正整数M(M>1)，似的N*M的十进制表示形式里只有1和0。

2.9 Fibonacci 数列

2.10 寻找数组中的最大值和最小值。

2.11 寻找最近点对。

2.12 快速寻找满足条件的两个数。

2.13 子数组的最大乘积。

2.14 求数组的子数组之和的最大值。

2.15 子数组之和的最大值（二维）。

2.16 求数组中最长递增子序列。

2.17 数组循环移位。

2.18 数组分割。

2.19 区间重合判断。

2.20 程序理解和时间分析。

2.21 只考加法的面试题目。

3.8 求二叉树中节点的最大距离

2.1 求二进制中1的个数。

2.2 求n！末尾有多少个0 和 求n!的二进制表示中最低位1的位置。

2.3 找出数量超过总数一半的记录。 扩展：3个发帖都超过了总数N的1/4。

2.4 十进制1~N 所有整数中1的个数； 满足F(N)=N的最大的N是多少。 扩展：CC上所有2的个数。

2.5 寻找最大的k的个数。

2.6 精确表达浮点数

2.7 最大公约数问题。

2.8 任意给定一个正整数N，求一个最小的正整数M(M>1)，似的N*M的十进制表示形式里只有1和0。

2.9 Fibonacci 数列

2.10 寻找数组中的最大值和最小值。

http://blog.csdn.net/hysfwjr/article/details/8916421

2.11 寻找最近点对。

http://www.cnblogs.com/pangxiaodong/archive/2011/09/30/2196684.html

http://blog.csdn.net/hysfwjr/article/details/8916478

2.12 快速寻找满足条件的两个数。

2.13 子数组的最大乘积。

2.14 求数组的子数组之和的最大值。

2.15 子数组之和的最大值（二维）。

http://blog.csdn.net/linyunzju/article/details/7723730

2.16 求数组中最长递增子序列。

public class Solution {

    /**
     * 最长递增子序列 LIS 
     * DP + BinarySearch
     * 
     * 
     */
    public static int LIS(int[] a) {
        if (a == null || a.length == 0)
            return 0;
        int len = 1;/* 存储子序列的最大长度 即MaxV当前的下标 */
        int[] maxV = new int[a.length];/* 存储长度i+1（len）的子序列最大元素的最小值 */
        maxV[0] = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] > maxV[len - 1]) {
                maxV[len++] = a[i];
            } else {
                int pos = bSearch(maxV, len, a[i]);
                maxV[pos] = a[i];
            }
        }

        return len;
    }

    /* 返回MaxV[i]中刚刚大于x的那个元素的下标 */
    private static int bSearch(int[] maxV, int len, int target) {
        int left = 0, right = len - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (maxV[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    public static void main(String[] args) {
        int[] a = { 1, -3, 2, -1, 4, -5, 6, -7 };
        System.out.println(LIS(a));
    }

}

http://www.ahathinking.com/archives/117.html

2.17 数组循环移位。

import java.util.Arrays;

public class Solution {

    /**
     * 数组中所有元素循环右移k位。 比如 k=4：12345abcd -> abcd12345
     */
    public static void shiftRight(int[] a, int k) {
        int n = a.length;
        k = k % n;
        reverse(a, 0, n - 1 - k);
        reverse(a, n - k, n - 1);
        reverse(a, 0, n - 1);
    }

    private static void reverse(int[] a, int i, int j) {
        while (i < j) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
            i++;
            j--;
        }

    }

    public static void main(String[] args) {
        int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        System.out.println(Arrays.toString(a));
        shiftRight(a, 100);
        System.out.println(Arrays.toString(a));

    }

}

2.18 数组分割。

http://blog.sina.com.cn/s/blog_66223402010164ux.html

2.19 区间重合判断。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
 * 先按照start排序
 * 合并有重叠的Interval
 * 二分查找目标
 * @author jd
 *
 */
public class Solution {

    public static boolean isCovered(Interval x, Interval[] set) {
        Arrays.sort(set, new Comparator<Interval>() {

            public int compare(Interval a, Interval b) {
                return ((Integer) (a.start)).compareTo(b.start);
            }
        });

        List<Interval> res = new ArrayList<Interval>();

        for (int i = 0; i < set.length;) {
            Interval merged = new Interval(set[i].start, set[i].end);
            int j = i + 1;
            while (j < set.length && isConnected(merged, set[j])) {
                merged = merge(merged, set[j]);
                j++;
            }
            res.add(merged);
            i = j;
        }

        int left = 0, right = res.size()-1;
        int mid = 0;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (res.get(mid).start <= x.start && res.get(mid).end >= x.end)
                return true;
            else if (x.start > res.get(mid).end) {
                left = mid + 1;
            } else if (x.end < res.get(mid).start) {
                right = mid - 1;
            } else {
                return false;
            }

        }
        return false;

    }

    private static boolean isConnected(Interval a, Interval b) {
        return (a.start >= b.start && a.start <= b.end) || (b.start >= a.start && b.start <= a.end);

    }

    private static Interval merge(Interval a, Interval b) {
        int newStart = a.start < b.start ? a.start : b.start;
        int newEnd = a.end > b.end ? a.end : b.end;
        a.start = newStart;
        a.end = newEnd;
        return a;
    }

    public static void main(String[] args) {
        Interval x = new Interval(1, 6);
        Interval[] set= {new Interval(1,2),new Interval(2,3),new Interval(4,9)};
        System.out.println(isCovered(x, set));
    }

}

class Interval {
    int start;
    int end;

    Interval() {
        start = 0;
        end = 0;
    }

    Interval(int s, int e) {
        start = s;
        end = e;
    }

    @Override
    public String toString() {
        return "Interval [start=" + start + ", end=" + end + "]";
    }
    
}

2.20 程序理解和时间分析。

2.21 只考加法的面试题目。

3.8 求二叉树中节点的最大距离

public class Solution {

    private int maxLen;

    public int findMaxLen(TreeNode root) {
        maxLen(root);
        return maxLen;
    }

    private int maxLen(TreeNode root) {
        if (root == null)
            return 0;

        if (root.left == null && root.right == null) {// 叶子节点
            return 0;
        } else if (root.right == null) {// 只有左节点
            int leftLen = maxLen(root.left);
            maxLen = Math.max(leftLen + 1, maxLen);
            return leftLen + 1;
        } else if (root.left == null) {// 只有右节点
            int rightLen = maxLen(root.right);
            maxLen = Math.max(rightLen + 1, maxLen);
            return rightLen + 1;
        } else {// 左右节点都有的情况下
            int leftLen = maxLen(root.left);
            int rightLen = maxLen(root.right);
            maxLen = Math.max(leftLen + rightLen + 2, maxLen);
            return Math.max(leftLen, rightLen) + 1;
        }

    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.left.left.right = new TreeNode(7);
        root.right = new TreeNode(3);
        root.right.left = new TreeNode(6);

        System.out.println(new Solution().findMaxLen(root));
    }
}