二叉树OJ(JavaDS)

KY11 二叉树遍历

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

示例1
输入：
abc##de#g##f###
输出：
c b e g d f a 

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
class TreeNode{
    public char val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(char val){
        this.val=val;
    } 
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str=in.nextLine();
            TreeNode root=createTree(str);
            inorder(root);
        }
    }
    //中序遍历
    public static void inorder(TreeNode root){
        if(root==null){
            return;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }
    public static int i=0;
    //全局，i只有一份
    
    public static TreeNode createTree(String str){
        TreeNode root=null;
        char ch=str.charAt(i);
        if(ch!='#'){
        //遍历字符串，如果是字符，就new一个结点，然后左边和右边递归
            root=new TreeNode(ch);
            i++;
            root.left=createTree(str);
            root.right=createTree(str);
        }else{
        //如果是‘#’,说明走到空的位置，就i++,继续遍历字符串，同时返回root的初始值null，返回到上一次递归
            i++;
        }
        return root;
    }
}

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

示例 1：
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

方法一

借助栈

可以联想到两个链表的公共节点问题

那么如何找到两个元素的路径？

先创建一个栈，把root入栈，如果root==p，返回true回到上一次递归，否则就到root.left去找，没找到就去root.right找，都没找到就弹出栈顶元素，返回false

import java.util.Stack;

public class Solution {
    class TreeNode{
        public char val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(char val){
            this.val=val;
        }
    }
    //方法1，借助栈
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null||p==null||q==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();
        int size=0;
        if(size1>size2){
            size=size1-size2;
            for(int i=0;i<size;i++){
                stack1.pop();
            }
        }else{
            size=size2-size1;
            for(int i=0;i<size;i++){
                stack2.pop();
            }
        }
        while(stack1.peek()!=stack2.peek()){
            stack1.pop();
            stack2.pop();
        }
        return stack1.peek();
    }
    public 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 ret1=getPath(root.left,node,stack);
        if(ret1==true){
            return true;
        }
        boolean ret2=getPath(root.right,node,stack);
        if(ret2==true){
            return true;
        }
        stack.pop();
        return false;
    }

方法二

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null){
            return null;
        }
        if(root==p||root==q){
            return root;
        }
        TreeNode leftTree=lowestCommonAncestor(root.left,p,q);
        TreeNode rightTree=lowestCommonAncestor(root.right,p,q);
        if(leftTree!=null&&rightTree!=null){
        //两侧
            return root;
        }
        else if(leftTree!=null){
        //都在左边
            return leftTree;
        }
        else if(rightTree!=null){
        //都在右边
            return rightTree;
        }
        else{
            return null;
        }
    }
}

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

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。
要求不能创建任何新的结点，只能调整树中结点指针的指向。返回链表中的第一个节点的指针

二叉搜索树：
根节点的左边都比根节点小，根节点的右边都比根节点大。
特点：中序遍历是有序的

在中序遍历递归的基础上做修改，使结点的left,right指向改变，最后返回root=8，题目要求返回链表第一个节点的指针，所以从8开始往左找，找到left=null的节点1即为链表的头结点

public class Solution {
    TreeNode prev = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) {
            return null;
        }
        
        ConvertChild(pRootOfTree);
        TreeNode head = pRootOfTree;
        
        while (head.left != null) {
            head = head.left;
        }
        return head;
    }
    public void ConvertChild(TreeNode pCur) {
        if (pCur == null) {
            return;
        }
        ConvertChild(pCur.left);
        pCur.left = prev;
        if (prev != null) {
            prev.right = pCur;
        }
        prev = pCur;
        ConvertChild(pCur.right);
    }
}
//迭代+递归修改指向

力扣144.二叉树前序非递归遍历实现

借助栈

cur指向root,cur不为空，把cur进栈，并且list.add()，然后cur往左走，如果cur走到空，栈弹出栈顶元素赋给top，cur指向top.right，如果栈弹空了，说明遍历结束

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public  class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            TreeNode cur = root;
            Stack<TreeNode> stack = new Stack<>();
            while (true) {
                if (cur != null) {
                    stack.push(cur);
                    list.add(cur.val);
                    cur = cur.left;
                }
                //cur为空
                else {
                    if (stack.isEmpty()) {
                        break;
                    }
                    TreeNode top = stack.pop();
                    cur = top.right;
                }
            }
            return list;
        }
}