实现计算二叉树的高度、判断一课树是否为完全二叉树以及经典算法题目翻转二叉树

一、打印二叉树的高度

• 递归的形式实现：

public int height() {
	return height(root);
}

private int height(Node<E> node) {
	if (node == null) return 0;
	return 1+Math.max(height(node.left), height(node.right));
}

• 非递归（迭代）形式实现：

/* 迭代实现高度的计算 */
public int height1() {
	if(root == null) return 0;
	
	//树的高度
	int height = 0;
	//存储着每一层的元素数量
	int levelSize = 1;
	
	Queue<Node<E>> queue = new LinkedList<>();
	queue.offer(root);
	
	while (!queue.isEmpty()) {
		Node<E> node =  queue.poll();
		levelSize--;
		
		if (node.left != null) {
			queue.offer(node.left);
		}
		if (node.right != null) {
			queue.offer(node.right);
		}
		if (levelSize == 0) {//意味着即将要访问下一层
			levelSize = queue.size();
			height++;
		}
	}
	return height;
}

测试实现：

import java.util.Comparator;
import com.mj.BinarySearchTree.Visitor;
import com.mj.file.Files;
import com.mj.printer.BinaryTrees;

public class Main {
	static void test9() {
		Integer date[] = new Integer[] {
				7,4,9,2,1
		};
		
		BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		System.out.println(bst.height());
		System.out.println(bst.height1());
	}
	
	public static void main(String[] args) {
		test9(); //4  4
	}
}

二、判断一棵树是否为完全二叉树

• 如果树为空，返回false
• 如果树不为空，开始层序遍历二叉树（用队列）
  ①、如果node.left!=null，将node.left入队
  ②、如果node.left == null && node.right != null，返回false
  ③、如果node.right != null，将node.right入队
  ④、如果node.right == null
  • 那么后面遍历的节点应该都为叶子节点，才是完全二叉树。
  • 否则返回false。
• 遍历结束，返回false

private static class Node<E>{
	E element;
	Node<E> left;
	Node<E> right;
	@SuppressWarnings("unused")
	Node<E> parent;
	
	public Node(E element,Node<E> parent) {
		this.element = element;
		this.parent = parent;
	}
	/**
	 * 判断是否为叶子节点
	 * @return
	 */
	public boolean isLeaf() {
		return left == null && right == null;
	}
	
	public boolean hasTwoChildren() {
		return left != null && right != null;
	}
}

/* 判断是否是完全二叉树 */
public boolean isComplete() {
	if(root == null) return false;
	
	Queue<Node<E>> queue = new LinkedList<>();
	queue.offer(root);
	
	boolean left = false;
	while (!queue.isEmpty()) {
		Node<E> node = queue.poll();
		if (left && !node.isLeaf()) return false;
		
		if (node.hasTwoChildren()) {
			queue.offer(node.left);
			queue.offer(node.right);
		}else if (node.left == null && node.right != null) {
			return false;
		}else {//后面遍历的节点都必须是叶子节点
			left = true;
			if (node.left != null) {
				queue.offer(node.left);
			}
		}
	}
	return true;
}

测试：

import java.util.Comparator;
import com.mj.BinarySearchTree.Visitor;
import com.mj.file.Files;
import com.mj.printer.BinaryTrees;

public class Main {
	static void test9() {
		Integer date[] = new Integer[] {
				7,4,9,2,1
		};
		
		BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		System.out.println(bst.isComplete());
	}
	
	public static void main(String[] args) {
		test9(); //true
	}
}

优化判断是否为完全二叉树：

private static class Node<E>{
	E element;
	Node<E> left;
	Node<E> right;
	@SuppressWarnings("unused")
	Node<E> parent;
	
	public Node(E element,Node<E> parent) {
		this.element = element;
		this.parent = parent;
	}
	/**
	 * 判断是否为叶子节点
	 * @return
	 */
	public boolean isLeaf() {
		return left == null && right == null;
	}
	
	public boolean hasTwoChildren() {
		return left != null && right != null;
	}
}

/* 判断是否是完全二叉树 */
public boolean isComplete() {
	if(root == null) return false;
	
	Queue<Node<E>> queue = new LinkedList<>();
	queue.offer(root);
	
	boolean left = false;
	while (!queue.isEmpty()) {
		Node<E> node = queue.poll();
		if (left && !node.isLeaf()) return false;
		
		//左子节点都能遍历到
		if (node.left != null) {
			queue.offer(node.left);
		}else if (node.right != null) {
			//node.left == null && node.right != null
			return false;
		}
		//右子节点都能遍历到
		if (node.right != null) {
			queue.offer(node.right);
		}else {//node.left == null
			left = true;
		}
	}
	return true;
}

三、翻转二叉树

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/invert-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
	//前序遍历
	public TreeNode invertTree(TreeNode root) {
		if (root == null) return root;
		
		TreeNode tmp = root.left;
		root.left = root.right;
		root.right = tmp;
		
		invertTree(root.left);
		invertTree(root.right);
		
		return root;
	}
}

class Solution {
	//后序遍历
	public TreeNode invertTree(TreeNode root) {
		if (root == null) return root;

		invertTree(root.left);
		invertTree(root.right);

		TreeNode tmp = root.left;
		root.left = root.right;
		root.right = tmp;

		return root;
	}
}

class Solution {
	//中序遍历
	public TreeNode invertTree(TreeNode root) {
		if (root == null) return root;
		
		invertTree(root.left);
		
		TreeNode tmp = root.left;
		root.left = root.right;
		root.right = tmp;
		
		invertTree(root.left);
		
		return root;
	}
}

class Solution {
    //层序遍历
	public TreeNode invertTree(TreeNode root) {
		if (root == null) return root;
		
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.offer(root);
		
		while (!queue.isEmpty()) {
			TreeNode node = queue.poll();
			TreeNode tmp = node.left;
			node.left= node.right;
			node.right = tmp;
			
			if (node.left != null) {
				queue.offer(node.left);
			}
			if (node.right != null) {
				queue.offer(node.right);
			}
		}
		return root;
    }
}