20191218——第一百题 相同的树

以后的代码要进行注释，方便理解
递归
最简单的策略是递归，首先判断p与q是不是None，然后判断它们的值是否相等，若通过以上判断，则对递归子节点做同样操作。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //如果p与q都为空，那么是相同的树
        if(p ==null  && q ==null){
            return true;
        }
        //如果p或者q一个为空，另一个不为空，那么一定不是相同的树
        if( p == null ||q==null){
            return false;
        }
        //如果p与q的值不同，那么也一定不是相同的树
        if(p.val != q.val){
            return false;
        }
        return (isSameTree(p.right,q.right)&&isSameTree(p.left,q.left));
    }
}

时间复杂度是n，n是树的节点，所以每个结点都访问一次。
空间复杂度 : 最优情况（完全平衡二叉树）时为 O(\log(N))O(log(N))，最坏情况下（完全不平衡二叉树）时为 {O}(N)O(N)，用于维护递归栈。

迭代
从根开始，每次迭代将当前结点从双向队列中弹出。进行判断，p和q是不是none，p.val与q.val值是否相等，若满足以上，则压入子节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    //创建一个check函数来判断p,q是否相同
    public boolean check(TreeNode p,TreeNode q){
        //p q 都是null，那么是一样的
        if(p == null && q==null){
            return true;
        }
        //p q一个为null,另一个不是那么不是一样的
        if(p == null || q ==null){
            return false;
        }
        //p q的val值不相等，return false
        if( p.val != q.val){
            return false;
        }
        return true;
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //检查一下p ,q两个节点，如果不满足check函数，return false
        if (p == null && q == null) return true;
        if(!check(p,q)) return false;
        //建立两个队列 depP 与 depQ
        ArrayDeque<TreeNode> deqP = new ArrayDeque<TreeNode>();
        ArrayDeque<TreeNode> deqQ = new ArrayDeque<TreeNode>();
        deqP.addLast(p);
        deqQ.addLast(q);

        while (!deqP.isEmpty()) {
            p = deqP.removeFirst();
            q = deqQ.removeFirst();
            //再次判断p与q
            if(!check(p,q)) return false;
            if(p != null){
                if(!check(p.left,q.left)) return false;
                if(p.left != null){
                    deqP.addLast(p.left);
                    deqQ.addLast(q.left);
                }
                if(!check(p.right,q.right)) return false;
                if(p.right != null){
                    deqP.addLast(p.right);
                    deqQ.addLast(q.right);
                }
            }
        }
        return true;
    }
}

学习一下java中的队列
Queue：基本上，一个队列就是先进先出（FIFO）的数据结构
Queue接口与List、Set同一级别，继承了Collection接口，LinkedList实现了Deque接口。

1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口
　　内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue
　　PriorityQueue 和 ConcurrentLinkedQueue 类在 Collection Framework 中加入两个具体集合实现。
　　PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的天然排序（通过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。
　　ConcurrentLinkedQueue 是基于链接节点的、线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大 小，　　　　 　　ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。

2)实现阻塞接口的：
　　java.util.concurrent 中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的 FIFO 数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
　　* ArrayBlockingQueue ：一个由数组支持的有界队列。
　　* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
　　* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
　　* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
　　* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

方法
add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
　　remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
　　element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
　　offer 添加一个元素并返回true 如果队列已满，则返回false
　　poll 移除并返问队列头部的元素 如果队列为空，则返回null
　　peek 返回队列头部的元素 如果队列为空，则返回null
　　put 添加一个元素 如果队列满，则阻塞
　　take 移除并返回队列头部的元素 如果队列为空，则阻塞