二叉树试题总结

1、二叉树镜像

先交换根节点的左右孩子，再对其左右孩子镜像

//递归实现
public class Solution {
    public void Mirror(TreeNode root) {
        if(root == null){
            return;
        }
        if(root.left == null && root.right == null){
            return;
        }
        
        //交换
        TreeNode tmpNode = root.left;
        root.left = root.right;
        root.right = tmpNode;
        
        Mirror(root.left);
        Mirror(root.right);            
    }
}

2、求一个二叉树的高度

子问题的方法

//递归实现
public class Hight {
	public int getHight(TreeNode pRoot) {
		if (pRoot == null) {
			return 0;
		}

		int left = getHight(pRoot.left);
		int right = getHight(pRoot.right);

		return left > right ? left + 1 : right + 1;
	}
}

3、求一颗二叉树的总结点个数

//递归
public class Size {
	public int getSize(TreeNode pRoot) {
		if (pRoot == null) {
			return 0;
		}
		return getSize(pRoot.left) + getSize(pRoot.right) + 1;
	}
}

4、求一颗二叉树叶子节点总数

//递归实现
public class LeafSize {
	public int getLeafSize(TreeNode pRoot) {
		if (pRoot == null) {
			return 0;
		}

		if (pRoot.left == null && pRoot.right == null) {
			return 1;
		}

		return getLeafSize(pRoot.left) + getLeafSize(pRoot.right);
	}
}

5、一颗二叉树第K层的节点数

public class KlevelSize {
	public int getKLevelSize(TreeNode pRoot, int k) {
		if (k < 1 || pRoot == null) {
			return 0;
		}

		// 根所在的一层是一个结点
		if (k == 1) {
			return 1;
		}

		return getKLevelSize(pRoot.left, k - 1) + getKLevelSize(pRoot.right, k - 1);
	}
}

6、层序遍历二叉树

利用Java JDK提供的Queue类实现

public class LevelOrder {
	public void print(TreeNode pRoot) {
		if (pRoot == null) {
			return;
		}

		Queue<TreeNode> queue = new LinkedList<>();
		// Queue的唯一实现它的子类LinkedList类
		queue.offer(pRoot);// 入队列
		TreeNode head = null;
		while (!queue.isEmpty()) {
			head = queue.peek();// 返回对首元素
			queue.poll();// 出队列
			System.out.print(head.val + " ");
			if (head.left != null) {
				queue.offer(head.left);
			}
			if (head.right != null) {
				queue.offer(head.right);
			}
		}
	}
}

7、判断一个整数数组是否为一个二叉搜索树的后序遍历序列，数组无重复元素。

public class Solution {
	public boolean VerifySquenceOfBST(int [] sequence) {
            if(sequence.length == 0){
                return false;
            }
        
            return judge(sequence, 0, sequence.length - 1);
        }
    
        private boolean judge(int [] sequence, int start, int end){
            if(start >= end){//表示以判断完毕
                return true;
            }
        
            //找到左右子树分界点
            int i = start;
            for(; i < end; i++){//end为根
                if(sequence[i] > sequence[end]){
                    break;
                }
            }
            //从右子树第一个下标开始遍历判断
            for(int j = i; j < end; j++){
                if(sequence[j] < sequence[end]){
                    return false;
                }
            }
        
            return judge(sequence, start, i-1) && judge(sequence, i, end - 1);
        }
}

8、判断一个二叉树是否为平衡二叉树

public class BalanceTree {
	boolean flag = true;
        public boolean IsBalanced_Solution(TreeNode root) {
            getHight(root);
            return flag;
        }
    
        private int getHight(TreeNode root){
            if(root == null){
                return 0;
            }
            int left = getHight(root.left);
            int right = getHight(root.right);
        
            if(Math.abs(left - right) > 1){
                flag = false;
            }
        
            return (left > right ? left : right) + 1;
        }
}