二叉树相关算法（Java）

二叉树的相关判断

1.二叉树的深度

输入一颗二叉树的根结点，求该树的深度。从根结点到叶结点依次经过的结点（含根，叶子结点）形成一条路径，最长路径的长度为树的深度

public int TreeDepth(TreeNode root) {
    if(root == null){
        return 0;
    }
    int left = TreeDepth(root.left);
    int right = TreeDepth(root.right);
    return left>right?left+1:right+1;
}

2.判断一颗二叉树是否为平衡二叉树

若二叉树中任意节点的左右子树的深度相差不超过1，则为平衡二叉树

public static int TreeDepth(TreeNode root) {
    if(root == null){
        return 0;
    }
    int left = TreeDepth(root.left);
    int right = TreeDepth(root.right);
    return left>right?left+1:right+1;
}

private static boolean isBalanced(TreeNode root){
    if(root == null){
        return true;
    }
    int left = TreeDepth(root.left);
    int right = TreeDepth(root.right);
    int diff = Math.abs(left - right);
    if(diff>1){
        return false;
    }
    return isBalanced(root.left)&&isBalanced(root.right);
}

3.判断一颗二叉树是否为搜索二叉树

private static int lastVisit = Integer.MIN_VALUE;
public boolean isBST(TreeNode root){
    if(root == null) return true;
    boolean judgeLeft = isBST(root.left);
    if(root.val >= lastVisit && judgeLeft){
        lastVisit = root.val;
    }else {
        return false;
    }
    boolean judgeRight = isBST(root.right);

    return judgeRight;
}

4.判断一颗二叉树是否为完全二叉树

public boolean isCompleteTree(TreeNode root){
    if(root == null) return true;
    boolean noChild = false;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (queue != null){
        TreeNode node = queue.poll();

        if(node.left != null){
            if(noChild){
                 return false;
            }
            queue.offer(node.left);
        }else {
            noChild = true;
        }
        if(node.right != null){
            if(noChild){
                return false;
            }
            queue.offer(node.right);
        }else {
            noChild = true;
        }
    }
     return true;
}

二叉树的非递归遍历

1.非递归前序遍历

public void preOrder(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode node = root;
    while(!stack.isEmpty() || node != null){
        while(node != null){
            System.out.println(node.val);
            stack.push(node);
            node = node.left;
        }

        If (!stack.isEmpty()){
            node = stack.pop();
            node = node.right;
        }
    }
}

2.非递归中序遍历

public void inOrder(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode node = root;
    while(!stack.isEmpty() || node != null){
        //中序遍历为左、中、右方式进行，所以首先找最左叶子节点，为遍历的起始节点
        while(node != null){
            stack.push(node);
            node = node.left;
        }
        //当node为空时，说明已经遍历到了最左叶子节点，开始出栈
        If (!stack.isEmpty()){
            node = stack.pop();
            System.out.println(node.val);
            node = node.right;
        }
    }
}

3.非递归后序遍历

public void postOrder(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    Stack<TreeNode> output = new Stack<TreeNode>();
    TreeNode node = root;
    while(stack != null || node != null){
        if(node != null){
            output.push(node);
            stack.push(node);
            node = node.right;
        }else {
            node = stack.pop();
            node = node.left;
        }
    }
    while (!output.isEmpty()){
        System.out.println(output.pop());
    }

}

其他相关算法

1.求两个节点的公共祖先

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
   if(root == null || p == root || q==root) return root;
   TreeNode left = lowestCommonAncestor(root.left,p,q);
   TreeNode right = lowestCommonAncestor(root.right,p,q);
   if(left != null && right != null){
        return root;
   }
   return left == null ? right : left;
}

2.求二叉树中最远的两个节点间的距离

距离分为两种情况：
1.两节点分别在左右子树，则最远距离为左子树深度+1+右子树深度
2.两节点在同一子树上，取左子树和右子树深度较大的

3.由前中序/后中序遍历重建二叉树

4.求二叉树的宽度

public static int maxWidth(TreeNode root){
    if(root == null){
        return 0;
    }
    Queue<TreeNode> queue = new ArrayDeque<>();
    int max = 1;
    queue.add(root);
    while(true){
        int len = queue.size();
        if(len == 0){
            break;
        }
        while(len > 0){
            TreeNode t = queue.poll();
            len --;
            if(t.left != null){
                queue.add(t.left);
            }
            if(t.right != null){
                queue.add(t.right);
            }
        }
        max=Math.max(max,queue.size());
    }
    return max;
}

5.判断一颗二叉树是否为另一颗二叉树的子树