LintCode算法题解——奇偶分割数组、二进制中1个数、反转整数、加一、排序数组转换为高度最小的二叉搜索树、二进制求和

奇偶分割数组

分割一个整数数组，使得奇数在前偶数在后。

样例

给定 [1, 2, 3, 4]，返回 [1, 3, 2, 4]。

算法

这题还是比较简单的，方法很多很多，我们将数组循环遍历，将遍历中的偶数和奇数相互交换就ok了。

public class Solution {
/*
 * @param nums: an array of integers
 * @return: nothing
 */
    public void partitionArray(int[] nums) {
        // write your code here
        int length = nums.length;
        int temp = 0;
        int index = 0;
        if(length==0)
            return;
        for(int i=0;i<length;i++){
            if(nums[i]%2==0){
                index = i;
                while(nums[index]%2==0){
                    if(index!=length-1)
                        index=index+1;
                    else
                        break;
                }
                temp = nums[i];
                nums[i] = nums[index];
                nums[index] = temp;
            }
        }
    }
}

二进制中1个数

计算在一个 32 位的整数的二进制表示中有多少个 1.

样例

给定 32 (100000)，返回 1

给定 5 (101)，返回 2

给定 1023 (111111111)，返回 9

算法

按与计算
1&1==1，1&0==0，0&&0==0；下面是很巧妙的一个方法。

public class Solution {
/*
 * @param num: An integer
 * @return: An integer
 */
    public int countOnes(int num) {
        // write your code here
        int count = 0;
        while(num!=0){
            num = num & (num-1);
            count++;
        }
        return count;       
    }
}

反转整数

将一个整数中的数字进行颠倒，当颠倒后的整数溢出时，返回 0 (标记为 32 位整数)。

样例

给定 x = 123，返回 321

给定 x = -123，返回 -321

算法

反转很简单，难点在于颠倒后证书溢出判断，int32位范围是-2^31~2^31-1,这里使用temp/10与reversed_n进行判断，当temp溢出时，/10不等于reversed_n，所以可判断溢出成立。

public class Solution {
    /*
     * @param n: the integer to be reversed
     * @return: the reversed integer
     */
    public int reverseInteger(int n) {
        // Write your code here
        int reversed_n = 0;

        while (n != 0) {
            int temp = reversed_n * 10 + n % 10;
            n = n / 10;
            if (temp / 10 != reversed_n) {
                reversed_n = 0;
                break;
            }
            reversed_n = temp;
        }
        return reversed_n;
    }
}

加一

给定一个非负数，表示一个数字数组，在该数的基础上+1，返回一个新的数组。

该数字按照大小进行排列，最大的数在列表的最前面。

样例

给定 [1,2,3] 表示 123, 返回 [1,2,4].

给定 [9,9,9] 表示 999, 返回 [1,0,0,0].

算法

google的题，哪道没有陷阱，第一次被坑了。
注意不要把数组转为int型整数，因为不确定数组大小会导致溢出。
本题思想是，若数组值都为9，则增加数组length，首位设为1，其他位为0；否则，末位加1，结束返回。

public class Solution {
    /*
     * @param digits: a number represented as an array of digits
     * @return: the result
     */
    public static int[] plusOne(int[] digits) {
        // write your code here
        boolean index = true;
        for(int n=0; n<digits.length;n++){
            if(digits[n]!=9)
                index = false;
        }
        if(index==true){
            int[] num = new int[digits.length+1];
            num[0] = 1;
            for(int m=1;m<digits.length+1;m++)
                num[m] = 0;
            return num;
        }
        for(int i=digits.length-1;i>=0;i--){
            if(digits[i]!=9){
                digits[i] = digits[i]+1;
                break;
            }else{
                digits[i] = 0;
            }
        }
        return digits;
    }
}

把排序数组转换为高度最小的二叉搜索树

给一个排序数组（从小到大），将其转换为一棵高度最小的排序二叉树。

样例

给出数组 [1,2,3,4,5,6,7], 返回

         4
       /   \
      2     6
     / \    / \
    1   3  5   7

算法

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */ 
public class Solution(){
    /**
     * @param nums: an integer array
     * @return: a tree node
     */
    public TreeNode sortArrayToBST(int[] A){
        if(A==null)
            return null;
        return bulidTree(A, 0, A.length-1); 
    }

    public void buildTree(int[] A, int start, int end){
        if(start>end)
            return null;
        int middle = (start+end)/2;
        TreeNode root = new TreeNode(A[middle]);
        A.left = buildTree(A, start, middle-1);
        A.right = buildTree(A, middle+1, end);  
    }
}

二进制求和

给定两个二进制字符串，返回他们的和（用二进制表示）。

样例

a = 11

b = 1

返回 100

算法

这种题千万不要将二进制转化为整数，这样转化复杂度将提高几何倍数。
注意如果相应位相加结果为2（1+1），则结果设为1，这时要设一个哨兵，相应位溢出时，哨兵设为1；结果为3（1+1+哨兵）时，相同道理。

public class Solution {
    /*
     * @param a: a number
     * @param b: a number
     * @return: the result
     */
    public String addBinary(String a, String b) {
        // write your code here
        if(b.length()==0&&a.length()==0)
            return null;
        String str = "";
        int index = 0;
        int i = 0;
        int middle = 0;
        String[] A = a.split("");
        String[] B = b.split("");
        while(i<A.length||i<B.length) {
            if (i >= A.length && i < B.length)
                middle = Integer.valueOf(B[B.length-1-i]) + index;
            else if (i >= B.length && i < A.length)
                middle = Integer.valueOf(A[A.length-1-i]) + index;
            else if (i < A.length && i < B.length)
                middle = Integer.valueOf(A[A.length-1-i]) + Integer.valueOf(B[B.length-1-i]) + index;
            if (middle == 3) {
                str = 1 + str;
                index = 1;
                //i=i+1;
            } else if (middle == 2) {
                str = 0 + str;
                index = 1;
            } else if (middle == 0 || middle == 1) {
                str = middle + str;
                index = 0;
            }
            i = i + 1;
        }
        if(index==1)
            str = index+str;
        return str;
    }
}