二叉树有关习题整理145二叉树的后序遍历 94二叉树的中序遍历 572另一棵树的子树 236二叉树的最近公共祖先 JZ36二叉搜索树与双向链表 - 牛客

Posted 2022-03-08 王嘻嘻-

目录

145、二叉树的后序遍历 - 力扣  

94、二叉树的中序遍历 - 力扣

572、另一棵树的子树 - 力扣

236、二叉树的最近公共祖先 - 力扣

JZ36、二叉搜索树与双向链表 - 牛客

---

145、二叉树的后序遍历 - 力扣  

思路：后序遍历：左右根。非递归写法，先判断左树，然后判断右树，若右树不为空且之前没有被处理过，最后把根节点压入栈中。

class Solution 
public List<Integer> postorderTraversal(TreeNode root) 
        List<Integer> ret = new ArrayList<>();
        if (root == null)
            return ret;
        
        TreeNode cur = root;
        // 上一个完全处理过的节点(左右根都处理完毕的节点)
        TreeNode prev = null;
        Deque<TreeNode> stack = new ArrayDeque<>();
        while (cur != null || (!stack.isEmpty()))
            // 先一路向左走到根儿
            while (cur != null)
                stack.push(cur);
                cur = cur.left;
            
            // 此时左树为空，cur取栈顶元素，第二次访问
            cur = stack.pop();
            // 判断右树是否为空或者被我们访问过
            if (cur.right == null || prev == cur.right) 
                ret.add(cur.val);
                // 当前节点cur就是最后处理的根节点，更新prev引用，变为cur
                prev = cur;
                cur = null;
            else 
                // 此时右树不为空且没有处理过,就需要把根节点再压入栈中，继续处理右子树
                stack.push(cur);
                cur = cur.right;
            
        
        return ret;
    

 94、二叉树的中序遍历 - 力扣

思路：先遍历左树，一直向左走到底，最后一个值存放在栈中，然后出栈，访问根节点，最后遍历访问右子树。

class Solution 
    public List<Integer> inorderTraversal(TreeNode root) 
        List<Integer> ret = new ArrayList<>();
        if (root == null) 
            return ret;
        
        //走到当前节点
        TreeNode cur = root;
        Deque<TreeNode> stack = new ArrayDeque<>();
        // 当前树不为空 或者 当前栈不为空，一直向左走到根
        while (cur != null || !stack.isEmpty()) 
            while (cur != null) 
                //当前树不为空，直接将当前节点入栈
                stack.push(cur);
                cur = cur.left;
            
            //此时cur为空，说明走到了null，此时栈顶就存放了左树为空的节点，将该节点出栈
            cur = stack.pop();
            ret.add(cur.val);
            //继续访问右子树
            cur = cur.right;
        
        return ret;
    

 572、另一棵树的子树 - 力扣

思路：p和q是两颗相同的树 || p包含q || q包含p，满族任意一个条件就可以证明一棵树是另一颗的子树。

class Solution 
    // 传入两颗树root和subRoot，就能判断出subRoot是否是root的子树
    public boolean isSubtree(TreeNode root, TreeNode subRoot) 
        //边界
        if (root == null && subRoot == null)
            return true;
        
        if (root == null || subRoot == null)
            return false;
        
        // root和subRoot相同 || 左树包含 || 右树包含
        return isSameTree(root, subRoot) || isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
    

    public boolean isSameTree(TreeNode p, TreeNode q) 
        if (p == null && q == null)
            return true;
        
        if (p == null || q == null)
            return false;
        
        return p.val == q.val && 
                isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    

236、二叉树的最近公共祖先 - 力扣

思路：先找p和q的所有祖先，p和q一定不在同一子树中，从节点开始遍历，能同时将p和q这两个节点找到就是他俩的祖先。p和q可能出现的位置：左右子树，左子树和根，右子树和根。

class Solution 
   // 最近公共祖先
    private TreeNode lca;
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) 
        // 找到p和q的所有祖先
        findNode(root,p,q);
        return lca;
    

    /**
     * 以当前root为根节点的二叉树能否找到节点p或q
     * @param root
     * @param p
     * @param q
     */
    private boolean findNode(TreeNode root, TreeNode p, TreeNode q) 
        //边界
        if (root == null) 
            return false;
        
        //用整型变量来记录是否找到节点
        //先在左子树中寻找p和q
        //若left==1 =》 在左子树至少找到了一个节点p或者q
        int left = findNode(root.left,p,q) ? 1 : 0;
        //再在右子树中寻找p和q
        //若right==1 =》 在右子树至少找到了一个节点p或者q
        int right = findNode(root.right,p,q) ? 1 : 0;
        //最后在根节点中寻找p和q
        //若mid==1 => 根节点就是p或者q
        int mid = (root == p || root == q) ? 1 : 0;
        if (left + mid + right == 2) 
            //说明一定把p和q都找到了，且p和q不在一棵子树中
            lca = root;
        
        //此时返回是boolean类型
        //返回true，说明找到p或者q或者p q都找到
        //返回false,说明没找到 p q
        return (left + mid + right) > 0;
    

JZ36、二叉搜索树与双向链表 - 牛客

思路：因为要得到一个排序的双向链表，将BST进行中序遍历；原地操作，left左子树就相当于前驱节点，right右子树就相当于后继节点。

public class Solution 
    //传入一颗以root为根的BST就能转换为双向链表，返回链表的头节点
    public TreeNode Convert(TreeNode pRootOfTree) 
        //边界
        if(pRootOfTree == null) 
            return null;
        
        //对树进行中序遍历
        //此时的遍历 => 转换操作 => 先将左子树转换为双向链表
        //通过子函数就转了Conver(root.left);
        //此时leftHead就是左链表的头节点
        TreeNode leftHead = Convert(pRootOfTree.left);
        //继续处理根节点
        //左子树的尾节点 root.prev(left) = lifeTail
        //找到左链表的尾节点
        TreeNode leftTail = leftHead;
        //此时要判空
        while (leftTail != null && leftTail.right != null) 
            leftTail = leftTail.right;
        
        //此时leftTail就处于左侧链表的尾节点
        if (leftTail != null) 
            pRootOfTree.left = leftTail;
            leftTail.right = pRootOfTree;
        
        //再递归处理右子树，转换右子树为链表，返回右侧链表的头节点
        TreeNode rightHead = Convert(pRootOfTree.right);
        //在和根节点拼接
        if (rightHead != null) 
            pRootOfTree.right = rightHead;
            rightHead.left = pRootOfTree;
        
        //返回整个大链表的根节点
        //左树不为空返回左侧头节点
        //否则返回根节点
        return leftHead == null ? pRootOfTree : leftHead;
    

---

本小节完^_^