Java设计实践课的LeetCode题目

7.Reverse Integer 

解题思路：使用强制类型转换的代码，先用long做，之后判断值然后强制转化成int

public class Solution {
    public int reverse(int x) {
        long reverse_n = 0;
        while (x != 0) {
            reverse_n = reverse_n * 10 + x % 10;//关键代码
            x = x / 10;
        }
        if (reverse_n > Integer.MAX_VALUE || reverse_n < Integer.MIN_VALUE) {
            return 0;
        }
        return (int)reverse_n;
    }
}

 9. Palindrome Number 

public class Solution {//解题思路：直接利用直接做的reverse题目，如果x == reverse_x则说明是回文数。
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        int y = x;
        long reverse_x = 0;
        while (x != 0) {
            reverse_x = reverse_x * 10 + x % 10;
            x = x / 10;
        }
        // if (x > Integer.MAX_VALUE || x < Integer.MIN_VALUE) {
        //     return false;
        // }
        if (y == (int)reverse_x) {
            return true;
        }
        return false;
    }
}

 8. String to Integer (atoi)

public class Solution {
    public int myAtoi(String str) {
        //输入有效性判断
        if (str == null || str.length() == 0) {
            return 0;
        }
        int index = 0;
        int sign = 1;
        int sum = 0;
        //找到第一个不是空格的字符
        while (str.charAt(index) == ' ' && index < str.length()) {
            index++;
        }
        //判断正负
        if (str.charAt(index) == '+' || str.charAt(index) == '-') {
            sign = str.charAt(index) == '+' ? 1 : -1;
            index++;
        }
        //防止溢出
        while (index < str.length() && str.charAt(index) >= '0' && str.charAt(index) <= '9') {
            int num = str.charAt(index) - '0';
            if (sum > Integer.MAX_VALUE / 10 || (sum == Integer.MAX_VALUE / 10 && num > Integer.MAX_VALUE % 10)) {
                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }
            sum = sum * 10 + num;
            index++;
        }
        return sum * sign;
    }
}

581. Shortest Unsorted Continuous Subarray （需要一个额外的数组对现有数组进行排序，然后找到第一个跟排序数组不同的数字的索引）                

public class Solution {
    public int findUnsortedSubarray(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        //将数组复制出去并进行排序
        int numsLen = nums.length;
        int[] temp = new int[numsLen];
        for (int i = 0; i < numsLen; i++) {
            temp[i] = nums[i]; 
        }
        Arrays.sort(temp);
        //分别从左到右找到第一个跟排序数组不一样的数字
        int left = 0;
        int right = nums.length - 1;
        while (left < numsLen - 1 && nums[left] == temp[left]) {
            left++;
        }
        while (right > 0 && nums[right] == temp[right]) {
            right--;
        }
        //排除已经排序好的情况
        if (right <= left) {
            return 0;
        } else {
            return right - left + 1;
        }
    }
}

 456. 132 Pattern （time:O(n*n)）                  

public class Solution {
    public boolean find132pattern(int[] nums) {
        if (nums == null || nums.length < 3) {
            return false;
        }
        for (int i = 1, min = nums[0]; i < nums.length; i++) {
            if (nums[i] < min) {
                min = nums[i];
                continue;
            }
            for (int j = nums.length - 1; j > i; j--) {
                if (min < nums[j] && nums[j] < nums[i]) {
                    return true;
                }
            }
        }
        return false;
    }
}

 476. Number Complement

highestOneBit~~                   

public class Solution {
    public int findComplement(int num) {
        //hightestOneBit为获取最高位为1，其余为0，返回int
        return ~num & (Integer.highestOneBit(num) - 1);
    }
}

public class Solution {
    public int findComplement(int num) {
       //用全为1减去num
       int sum = 0;
       int i = 0;
       while (sum < num) {
           sum += Math.pow(2,i);
           i++;
       }
       return sum - num;
    }
}

 306. Additive Number                   

public class Solution {
    public boolean isAdditiveNumber(String num) {
        if (num.length() <= 2) {
            return false;
        }
        int len = num.length();
        //选择第一个数
        for (int i = 1; i <= (len - 1) / 2; i++) {
            //第一个数首数字不能为0
            if (num.charAt(0) == '0' && i >= 2) {
                break;
            }
            //选择第二个数
            for (int j = i + 1; len - j >= i && len - j >= j - i; j++) {
                //第二个谁首数字不能为0
                if (num.charAt(i) == '0' && j - i >= 2) {
                    break;
                }
                //截取前两个数字
                String num1 = num.substring(0, i);
                String num2 = num.substring(i, j);
                String sum = num.substring(j);
                if (isAdditive(num1, num2, sum)) {
                    return true;
                }
            }
        }
        return false;
    }
    public boolean isAdditive(String num1, String num2, String sum) {
        //如果已经运行到最后一个数字为空表示之前的isAdditive是满足的
        if (sum.equals("")) {
            return true;
        }
        long x1 = Long.parseLong(num1);
        long x2 = Long.parseLong(num2);
        String result = ((Long)(x1 + x2)).toString();
        if (!sum.startsWith(result)) {
            return false;
        }
        return isAdditive(num2, result, sum.substring(result.length()));
    }
}

543. Diameter of Binary Tree                   

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int diameterOfBinaryTree(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int depthSum = depth(root.left) + depth(root.right);
        //最大直径：如果包含根节点，那就是左边的深度+右边的深度，如果不包含根节点，分别以root.left和root.right为新的根节点重复操作
        return Math.max(depthSum, Math.max(diameterOfBinaryTree(root.left), diameterOfBinaryTree(root.right)));
    }
    public int depth(TreeNode root) {
        //求数的深度
        if (root == null) {
            return 0;
        }
        return 1 + Math.max(depth(root.left), depth(root.right));
    }
}

279. Perfect Squares 

   

      

public class Solution {
    public int numSquares(int n) {
        if (n <= 0) {
            return 0;
        }
        //正着计算出所有的dp[n]
        int[] dp = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 1; j * j <= i; j++) {
                min = Math.min(min, dp[i - j * j] + 1);
            }
            dp[i] = min;
        }
        return dp[n];
    }
}