import java.util.*;
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;
}
@Override
public String toString() {
return "test.TreeNode{" +
"val=" + val +
", left=" + left +
", right=" + right +
'}';
}
private static TreeNode orderRoot ;
public static TreeNode constructTree(Integer... nums) {
if (nums.length == 0) return new TreeNode(0);
Deque<TreeNode> nodeQueue = new LinkedList<>();
// 创建一个根节点
TreeNode root = new TreeNode(nums[0]);
nodeQueue.offer(root);
TreeNode cur;
// 记录当前行节点的数量（注意不一定是2的幂，而是上一行中非空节点的数量乘2）
int lineNodeNum = 2;
// 记录当前行中数字在数组中的开始位置
int startIndex = 1;
// 记录数组中剩余的元素的数量
int restLength = nums.length - 1;
while (restLength > 0) {
// 只有最后一行可以不满，其余行必须是满的
// // 若输入的数组的数量是错误的，直接跳出程序
if (restLength < lineNodeNum) {
throw new RuntimeException("输入数量错误");
}
for (int i = startIndex; i < startIndex + lineNodeNum; i = i + 2) {
// 说明已经将nums中的数字用完，此时应停止遍历，并可以直接返回root
if (i == nums.length) return root;
cur = nodeQueue.poll();
if (nums[i] != null) {
cur.left = new TreeNode(nums[i]);
nodeQueue.offer(cur.left);
}
// 同上，说明已经将nums中的数字用完，此时应停止遍历，并可以直接返回root
if (i + 1 == nums.length) return root;
if (nums[i + 1] != null) {
cur.right = new TreeNode(nums[i + 1]);
nodeQueue.offer(cur.right);
}
}
startIndex += lineNodeNum;
restLength -= lineNodeNum;
lineNodeNum = nodeQueue.size() * 2;
}
orderRoot = root;
return root;
}
//前序排列
public TreeNode preOrder() {
List<Integer> ans = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if(orderRoot == null) return null;
TreeNode tempRoot = orderRoot;
stack.push(tempRoot);
while(!stack.isEmpty()){
TreeNode cur = stack.pop();
ans.add(cur.val);
if(cur.right != null){
stack.push(cur.right);
}
if(cur.left != null){
stack.push(cur.left);
}
}
System.out.println("前序遍历："+ ans);
return orderRoot;
}
//中序排列
public TreeNode midOrder() {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> s = new Stack<>();
if(orderRoot == null){
return null;
}
TreeNode cur = orderRoot;
while(!s.empty()||cur!=null){
while(cur!=null){
s.push(cur);
cur = cur.left;
}
cur = s.pop();
list.add(cur.val);
cur = cur.right;
}
System.out.println("中序遍历："+ list);
return orderRoot;
}
//后序遍历
public TreeNode aftOrder() {
List<Integer> ans = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if(orderRoot == null) return null;
TreeNode cur = orderRoot;
TreeNode pre = null;
while(true){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
if(stack.isEmpty()){
break;
}
TreeNode top = stack.peek();
if(top.right == null || pre == top.right){
stack.pop();
pre = top;
ans.add(top.val);
}else
cur = top.right;
}
System.out.println("后序遍历："+ ans);
return orderRoot;
}
// 用于获得树的层数
public static int getTreeDepth(TreeNode root) {
return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
}
private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
// 保证输入的树不为空
if (currNode == null) return;
// 先将当前节点保存到二维数组中
res[rowIndex][columnIndex] = String.valueOf(currNode.val);
// 计算当前位于树的第几层
int currLevel = ((rowIndex + 1) / 2);
// 若到了最后一层，则返回
if (currLevel == treeDepth) return;
// 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
int gap = treeDepth - currLevel - 1;
// 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
if (currNode.left != null) {
res[rowIndex + 1][columnIndex - gap] = "/";
writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
}
// 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
if (currNode.right != null) {
res[rowIndex + 1][columnIndex + gap] = "\\";
writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
}
}
public TreeNode show() {
if (orderRoot == null) System.out.println("EMPTY!");
// 得到树的深度
int treeDepth = getTreeDepth(orderRoot);
// 最后一行的宽度为2的（n - 1）次方乘3，再加1
// 作为整个二维数组的宽度
int arrayHeight = treeDepth * 2 - 1;
int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
// 用一个字符串数组来存储每个位置应显示的元素
String[][] res = new String[arrayHeight][arrayWidth];
// 对数组进行初始化，默认为一个空格
for (int i = 0; i < arrayHeight; i ++) {
for (int j = 0; j < arrayWidth; j ++) {
res[i][j] = " ";
}
}
// 从根节点开始，递归处理整个树
// res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
writeArray(orderRoot, 0, arrayWidth/ 2, res, treeDepth);
// 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
for (String[] line: res) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < line.length; i ++) {
sb.append(line[i]);
if (line[i].length() > 1 && i <= line.length - 1) {
i += line[i].length() > 4 ? 2: line[i].length() - 1;
}
}
System.out.println(sb.toString());
}
return orderRoot;
}
}
先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。
浙公网安备 33010602011771号