package com.company.Tree;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
class TreeNode {
String val;
TreeNode left;
TreeNode right;
public TreeNode() {
}
public TreeNode(String val) {
this.val = val;
}
@Override
public String toString() {
return "TreeNode{" +
"val='" + val + '\'' +
'}';
}
}
public class BTree {
public TreeNode buildTree(String[] s) {
TreeNode root = new TreeNode();
TreeNode res = root;
if (s == null || s.length == 0) return res;
root.val = s[0];
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int pos = 0;
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
if (++pos < s.length) {
if (!"#".equals(s[pos])) {
node.left = new TreeNode(s[pos]);
queue.add(node.left);
}
}
if (++pos < s.length) {
if (!"#".equals(s[pos])) {
node.right = new TreeNode(s[pos]);
queue.add(node.right);
}
}
}
return res;
}
public int getTreeDepth(TreeNode root) {
if (root == null) return 0;
return Math.max(getTreeDepth(root.left), getTreeDepth(root.right)) + 1;
}
public int getTreeDepthNoRecursive(TreeNode root) {
//非递归获取二叉树高度, 层次遍历
if (root == null) return 0;
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int level = 0;
while (!queue.isEmpty()) {
int curPos = queue.size();
while (curPos > 0) {
TreeNode node = queue.poll();
if (node.left != null) queue.add(node.left);
if (node.right != null) queue.add(node.right);
curPos--;
}
level++;
}
return level;
}
public void preOrder(TreeNode root) {
//递归前序遍历
if (root == null) return;
System.out.print(root.val);
preOrder(root.left);
preOrder(root.right);
}
public void preOrderNoRecursive(TreeNode root) {
//非递归前序遍历(DFS
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
System.out.print(node.val);
if (node.right != null) stack.push(node.right);
if (node.left != null) stack.push(node.left);
}
}
public void midOrder(TreeNode root) {
if (root == null) return;
midOrder(root.left);
System.out.print(root.val);
midOrder(root.right);
}
public void midOrderNoRecursive(TreeNode root) {
//中序非递归
if (root == null) return;
Stack<TreeNode> stack = new Stack<>();
while (!stack.isEmpty() || root != null) {
if (root != null) {
stack.push(root);
root = root.left;
} else {
root = stack.pop();
System.out.print(root.val);
root = root.right;
}
}
}
public void postOrder(TreeNode root) {
if (root == null) return;
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val);
}
public void postOrderNoRecursive(TreeNode root) {
if (root == null) return;
Stack<TreeNode> s1 = new Stack<>();
Stack<TreeNode> s2 = new Stack<>();
s1.push(root);
while (!s1.isEmpty()) {
TreeNode node = s1.peek();
s2.push(node);
s1.pop();
if (node.left != null) {
s1.push(node.left);
}
if (node.right != null) {
s1.push(node.right);
}
}
while (!s2.isEmpty()) {
System.out.print(s2.pop().val);
}
}
public static void main(String[] args) {
String[] s = {"1", "2", "3", "4", "5", "#", "6", "#", "#", "7"};
BTree bTree = new BTree();
TreeNode treeNode = bTree.buildTree(s);
System.out.println(treeNode.left.val);
System.out.println(treeNode.left.right.val);
System.out.println(treeNode.right.right.val);
//二叉树高度
System.out.println("递归-二叉树高度");
System.out.println(bTree.getTreeDepth(treeNode));
System.out.println("非递归-二叉树高度");
System.out.println(bTree.getTreeDepthNoRecursive(treeNode));
System.out.println("递归-前序遍历");
bTree.preOrder(treeNode);
System.out.println("\n非递归-前序遍历");
bTree.preOrderNoRecursive(treeNode);
System.out.println("\n递归-中序遍历");
bTree.midOrder(treeNode);
System.out.println("\n非递归-中序遍历");
bTree.midOrderNoRecursive(treeNode);
System.out.println("\n递归-后序遍历");
bTree.postOrder(treeNode);
System.out.println("\n非递归-后序遍历");
bTree.postOrderNoRecursive(treeNode);
}
}
输出
2
5
6
递归-二叉树高度
4
非递归-二叉树高度
4
递归-前序遍历
1245736
非递归-前序遍历
1245736
递归-中序遍历
4275136
非递归-中序遍历
4275136
递归-后序遍历
4752631
非递归-后序遍历
4752631
Process finished with exit code 0