《12.23-1.2 Leetcode》

1. 最后一个单词的长度

题目描述：
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指由字母组成，但不包含任何空格的字符串。

代码：

package leetcode.week2;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-23 13:17
 * @desc 最后一个单词的长度
 */
public class t58 {
    public static int lengthOfLastWord(String s) {
        if (null == s || "".equals(s)) {
            return 0;
        }

        int length = 0;
        int i = s.length() - 1;
        while (i >= 0 && s.charAt(i) == ' ') {
            i--;
        }
        while (i >= 0 && s.charAt(i) != ' ') {
            i--;
            length++;
        }
        if (i == -1) {
            return length;
        }
        return length;
    }

    public static void main(String[] args) {
        String str = "    ";
        System.out.println(lengthOfLastWord(str));
    }
}

2. 加一

题目描述：
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

package leetcode.week2;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-25 13:46
 * @desc 加一
 */
public class t66 {
    /**
     * 我的解法
     *
     * @param digits
     * @return
     */
    public static int[] plusOne(int[] digits) {
        // 如果最后一位小于9，则加一后直接返回
        if (digits[digits.length - 1] < 9) {
            digits[digits.length - 1] += 1;
            return digits;
        }

        // 创建一个更大的数组，并进行倒置
        int[] result = new int[digits.length + 1];
        for (int i = 0; i < digits.length; i++) {
            result[i] = digits[digits.length - i - 1];
        }

        result[0] += 1;
        int join = 0;

        for (int j = 0; j < result.length; j++) {
            int temp = join + result[j];
            if (temp >= 10) {
                result[j] = temp - 10;
                join = 1;
            } else {
                result[j] = temp;
                join = 0;
            }
        }

        // 数组倒置回来
        for (int i = 0; i < result.length / 2; i++) {
            int temp = result[i];
            result[i] = result[result.length - i - 1];
            result[result.length - i - 1] = temp;
        }

        if (result[0] == 0) {
            for (int i = 0; i < digits.length; i++) {
                digits[i] = result[i + 1];
            }
            return digits;
        }

        return result;
    }

    /**
     * 最优解
     *
     * @param digits
     * @return
     */
    public static int[] plusOneExc(int[] digits) {
        int len = digits.length;
        for (int i = len - 1; i >= 0; i--) {
            digits[i]++;
            digits[i] %= 10;
            if (digits[i] != 0) {
                return digits;
            }
        }
        /**
         * 数组的扩容
         */
        digits = new int[len + 1];
        digits[0] = 1;
        return digits;
    }


    public static void main(String[] args) {

        int[] arr = {9, 9, 9};
        arr = plusOneExc(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3. 二进制求和

题目描述：
给定两个二进制字符串，返回他们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。

代码：

package leetcode.week2;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2019-12-25 15:12
 * @desc 二进制求和
 */
public class t67 {

    public static String addBinary(String a, String b) {
        String max = a.length() >= b.length() ? a : b;
        String min = a.length() < b.length() ? a : b;
        int maxLength = max.length();
        int minLength = min.length();
        for (int i = 0; i < maxLength - minLength; i++) {
            min = "0" + min;
        }
        StringBuilder result = new StringBuilder();
        int temp = 0;
        for (int i = max.length() - 1; i >= 0; i--) {
            int a1 = max.charAt(i) - '0';
            int a2 = min.charAt(i) - '0';
            int sum = a1 + a2 + temp;
            if (sum > 1) {
                result.append(sum - 2);
                temp = 1;
            } else {
                result.append(sum);
                temp = 0;
            }
        }
        if (temp > 0) {
            result.append(1);
        }

        return result.reverse().toString();
    }

    public static void main(String[] args) {
        String a = "1";
        String b = "111";
        System.out.println(addBinary(a, b));

    }
}

4. x的平方根

题目描述：
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

代码：

package leetcode.week2;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-02 22:55
 * @desc 求x的平方根
 */
public class t69 {
    public static int mySqrt(int x) {
        long left = 0;
        long right = x;

        while (left < right) {
            long mid = (left + right) / 2;
            if (mid < 1) {
                return (int) right;
            } else if (mid == left) {
                return (int) left;
            }
            long squre = mid * mid;
            if (squre > x) {
                right = mid;
            } else if (squre < x) {
                left = mid;
            } else {
                return (int) mid;
            }
        }
        return (int) left;
    }

    public static void main(String[] args) {
        System.out.println(mySqrt(2147395599));
    }
}

5. 相同的树

题目描述：
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

代码：

package leetcode.week2;


/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-02 23:25
 * @desc 判断两个二叉树是否相同
 */
/*
public class TreeNode {
    Integer data;
    TreeNode left;
    TreeNode right;

    public TreeNode(Integer data) {
        this.data = data;
    }
    */
public class t100 {
    public static boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        }
        if (p != null && q != null) {
            if (!p.data.equals(q.data)) {
                return false;
            }
        } else {
            return false;
        }
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);


    }

    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        node1.left = node2;
        node1.right = node3;
        node2.left = node4;

        TreeNode node11 = new TreeNode(1);
        TreeNode node21 = new TreeNode(2);
        TreeNode node31 = new TreeNode(3);
        TreeNode node41 = new TreeNode(4);

        node11.left = node21;
        node11.right = node31;
        node21.right = node41;

        System.out.println(isSameTree(node1, node11));
    }
}