第七周题解

101. 对称二叉树

解法一（递归）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    public boolean isSymmetric(TreeNode root) {
        return judgeSymmetric(root, root); 
        //若写成return judgeSymmetric(root.left, root.right);
        //则当二叉树为空时会出现NullPointerException空指针异常
    }
    
    public boolean judgeSymmetric(TreeNode leftNode, TreeNode rightNode){
        if(leftNode == null && rightNode == null)
            return true;
        if(leftNode == null || rightNode == null)
            return false;
        if(leftNode.val == rightNode.val)
            return judgeSymmetric(leftNode.left, rightNode.right) && judgeSymmetric(leftNode.right, rightNode.left);
        return false;
    }
}

解法二：
将根节点的左右子树分别存入两个栈中，比较该节点是否相同，再将这两个节点的左右子树继续入栈，然后出栈比较，直到栈空。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Stack<TreeNode> rootLeft = new Stack<TreeNode>();
        Stack<TreeNode> rootRight = new Stack<TreeNode>();

        if(root == null)
            return true;

        rootLeft.push(root.left);
        rootRight.push(root.right);
        
        while(!rootLeft.isEmpty() && !rootRight.isEmpty()) {
            TreeNode p = rootLeft.pop();
            TreeNode q = rootRight.pop();
            if(p == null && q == null)
                continue;
            if(p == null || q == null)
                return false;
            if(p.val == q.val){
                rootLeft.push(p.left);
                rootRight.push(q.right);
                rootLeft.push(p.right);
                rootRight.push(q.left);
            } else {
                return false;
            }
        }
        return true;
    }
}

1. 两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] index = new int[2];
        for(int i = 0; i < nums.length; i ++){
            for(int j = i + 1; j < nums.length; j ++){
                if(nums[i] + nums[j] == target){
                    index[0] = i;
                    index[1] = j;
                    return index;
                }
            }
        }
        return null;
    }
}

2. 两数相加

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(0); //初始化一个值为零的空节点
        ListNode node = l3; 
        int t = 0; //每位数相加后的值
        while(l1 != null || l2 != null || t != 0) {
            if(l1 != null) {
                t += l1.val;
                l1 = l1.next;
            }
            if(l2 != null){
                t += l2.val;
                l2 = l2.next;
            }
            node.next = new ListNode(t%10); //t%10，因为每位数的值不能超过10
            node = node.next;
            t /= 10; //该位数是否进位
        }
        return l3.next;
    }
}

3. 无重复字符的最长长度

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int[] last = new int[128]; //下标为字符在ASCII中的值
        for(int i = 0; i < 128; i++) {
            last[i] = -1;
        }

        int res = 0;
        int start = 0; // 无重复字符串开始位置
        for(int i = 0; i < s.length(); i++) {
            int index = s.charAt(i);
            start = Math.max(start, last[index] + 1);
            res = Math.max(res, i - start + 1); //当前无重复字符串的最长长度
            last[index] = i; //该字符上一次出现的位置
        }
        return res;
    }
}