能带你起飞的【数据结构】成王第十篇:二叉树4

前言

 

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大

完整代码

class Solution {
    
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) return null;
        if(root == p || root == q){
            return root;
        }
        TreeNode leftT = lowestCommonAncestor( root.left,p,q);
         TreeNode rightT = lowestCommonAncestor( root.right,p,q);
         if(leftT != null && rightT != null ){
             return root;
         }else if(leftT != null){
             return leftT;
         }else{
             return rightT;
         }
         
    }
    
}

第二种思路

 

 

 

1.用两个栈存储路径

2.路径存好了,求栈的大小

3.让栈中多的元素出差值个元素

4.开始出栈,知道栈顶元素相同,此时就是公共祖先

 5.如何去找到从根节点到一个指定1节点的路径?

完整代码

class Solution {
    //root 根节点  node 指定的节点 stack 存放从根节点到指定节点的路径
    ppublic boolean getPath(TreeNode root,TreeNode node,Stack<TreeNode> stack){
        if(root == null || node == null){
            return false;
        }
        stack.push(root);
        if(root == node){
            return true;
        }
        boolean flg = getPath(root.left,node,stack);
        if(flg == true){
            return true;
        }
        flg = getPath(root.right,node,stack);
        if(flg == true){
            return true;
        }
        stack.pop();
        return false;
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) return null;
        Stack<TreeNode> stack1 = new Stack<>();
        getPath(root,p,stack1);
        Stack<TreeNode> stack2 = new Stack<>()          
        getPath(root,q,stack2);
         int size1 = stack1.size();
         int size2 = stack2.size();
         if(size1 > size2){
             int size = size1 - size2;
             while(size != 0){
                 stack1.pop();
                 size--;
             }
             while(!stack1.isEmpty()  && !stack2.isEmpty() ){
            if(stack1.peek() == stack2.peek()){
                return stack1.pop();
            }else{
                stack1.pop();
                stack2.pop();
            }
        } 
         }else{
         int size = size2 - size1;
        while(size != 0){
            stack2.pop();
            size--;
        }
         while(!stack1.isEmpty()  && !stack2.isEmpty()){
            if(stack1.peek() == stack2.peek()){
                return stack2.pop();
            }else{
                stack1.pop();
                stack2.pop();
            }
        } 
        }
        return null;
         
    }
}

 二叉树搜索树转换成排序双向链表

二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)

 

 

如果让这棵二叉搜索树变为链表,1的前驱为空, 3的前驱是1,4的前驱是3,5的前驱是4,6的前驱是5,7的前驱是6,8的前驱是7

 1的后继是3,3的后继是4,4的后继是5,5的后继是6,6的后继是7,7的后继是8

 这是我们最终想要的效果

 left:变成双向链表的前驱

right:变成双向链表的后驱

需要在中序遍历的过程中,修改每个节点的left和right

1.中序遍历不难

2.难点在于如何修改指向

完整代码

public class Solution {
    TreeNode prev = null;
    //先写一个中序遍历
    public void inorder(TreeNode pcur){
        if(pcur == null) return ;
 
        inorder(pcur.left);
        pcur.left =prev;
        if(prev != null){
            prev.right = pcur;
        }
        prev = pcur;
        System.out.print(pcur.val + " ");
        inorder(pcur.right);
 
    }
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null) return null;
        inorder(pRootOfTree);
        TreeNode  head = pRootOfTree;
        while(head.left != null){
            head = head.left;
        }
        return head;
    }
}

 根据一棵树的前序遍历与中序遍历构造二叉树

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

 

 pi来遍历这个字符串

ri表示根的位置

因为是前序遍历,pi++的时候,拿到的B就A这棵树的左树,此时B又是A这棵子树的根

 假设中序遍历的起始位置是ib,结束位置是ie

1.先将pi下标的元素,创建 为root

2,在中序遍历的数组当中,找到当前pi下标的元素,存在的位置ri

完整代码

class Solution {
    public int preIndex = 0;
    public TreeNode createTreeByPandI(int[] preorder,int[] inorder,int inbegin,int inend){
        if(inbegin >  inend){
            return null;
        }
        TreeNode root = new TreeNode(preorder[preIndex]);
        int rootIndex = findIndexofI(inorder,inbegin,inend,preorder[preIndex]);
        if(rootIndex == -1){
            return null; 
        }
        preIndex++;   
         root.left = createTreeByPandI(preorder,inorder,inbegin,rootIndex - 1);
         root.right = createTreeByPandI(preorder,inorder,rootIndex+ 1,inend);
         return root;
 
    }
     public int findIndexofI(int[] inorder,int inbegin,int inend,int key){
            for(int i = inbegin; i <= inend; i++ ){
                if(inorder[i] == key){
                    return i;
                }
            }
            return -1;
        }
 
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder == null && inorder == null){
            return null;
        }
        return createTreeByPandI(preorder,inorder,0,inorder.length - 1);
 
    }
}

二叉树前序非递归遍历实现 

 144. 二叉树的前序遍历 - 力扣（LeetCode）

首先,非递归就需要用循环

用栈来处理

让cur来遍历二叉树的每个节点,用前序遍历的方式

cur开始指向root

除了要打印A,然后把A也放到栈里面,来存储下来当前路径的信息

cur继续往后走,只要cur不为空,继续打印,继续往栈里存放

此时cur为空了

说明D这棵树的左树没有了,根也被打印了,那么就开始往D的右边走 

所以我们需要在这里额外定义一个引用top

弹出栈顶元素

 然后让当前的cur等于D的right,D的right也是空,说明这棵树完了

再来看当前栈为不为空,不为空弹出栈顶元素B

然后再让cur = top.right,为空吗,不为空拿起来放到栈里,同时把E打印

 

然后cur等于cur.left,为空再弹出栈顶元素,cur = top.right

以此类推

完整代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
            stack.push(cur);
            //System.out.print(cur.val + " ");
            list.add(cur.val);
            cur = cur.left;
        }
        TreeNode top = stack.pop();
        cur = top.right;
 
        }
        return list;
        
    }
}

二叉树中序非递归遍历实现 

94. 二叉树的中序遍历 - 力扣（LeetCode）

完整代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack.pop();
         //System.out.print(cur.val + " ");
        list.add(cur.val);
        cur = top.right;
 
        }
        return list;
        
    }
}

二叉树后序非递归遍历实现 

145. 二叉树的后序遍历 - 力扣（LeetCode）

如果cur不为空就放到栈里面,继续往左走 

cur为空了

此时我们看一下栈顶的元素D

此时如果要打印D就必须判断D的右边为不为空

如果右边为空就打印D

不为空就让cur = cur,right

完整代码

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        Stack<Integer> stack = new Stack<>();
        TreeNode cur = root;
        List<Integer> lsit = new ArrayList<>();
 
        TreeNode prev = null;
 
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.peek();
            //如果当前节点的右子树被打印过 或者 遍历过直接弹出
            if(top.right == null || top.right == prev){
                stack.pop();
                lsit.add(cur.left);
                prev = top;//记录一下最近一次打印的节点
            }else{
                cur = top.right;
            }
        }
 
    }
}