二叉树(三)| 二叉树的高级操作(求高度、深度)(java实现)

二叉树节点的存储结构

	public class TreeNode {
	     int val;
	     TreeNode left;
	     TreeNode right;
	     TreeNode(int x) { val = x; }
	}

获取树的深度

树的深度是指从根节点到叶子节点的最长路径。

当前节点的深度示意图

1、递归实现获取树的深度

    //(递归方式)获取以root为根节点的子树的深度:从叶子节点到达根节点的最长路径
    public int getDept(TreeNode root, int dept){

        if(root == null){
            return dept;
        }
        int leftDept = getDept(root.left, dept+1);
        int rightDept = getDept(root.right, dept+1);

        return Math.max(leftDept, rightDept);
    }

2、非递归实现树的深度

非递归方式借助辅助数据结构队列，广度优先遍历二叉树(也就是层次遍历)

    /**
     * (非递归方式)获取以root为根节点的子树的深度
     * 借助辅助数据结构队列，广度优先遍历二叉树
     * @param root
     * @return
     */
    public int getDept2(TreeNode root) {
    	if(root == null) {
    		return 0;
    	}
    	Queue<TreeNode> queue = new LinkedList<BinaryTree.TreeNode>();
    	int height = 0;
    	queue.add(root);
    	while (!queue.isEmpty()) {
			int size = queue.size();
			for (int i = 0; i < size; i++) {
				TreeNode node = queue.remove();
				if (node.left != null) {
					queue.add(node.left);
				}
				if (node.right!=null) {
					queue.add(node.right);
				}
			}
			height++;
		}
    	return height;
    }

3、(附加)求树的最小深度

树的最小深度是指从根节点到最近叶子节点的最短路径上的节点数量。采用递归方式实现。

    /**
     * 求树的最小深度：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
     * @param root
     * @return
     */
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        // null节点不参与比较
        if (root.left == null && root.right != null) {
            return 1 + minDepth(root.right);
        }
        // null节点不参与比较
        if (root.right == null && root.left != null) {
            return 1 + minDepth(root.left);
        }

        return 1 + Math.min(minDepth(root.left), minDepth(root.right));
        
    }

获取树的高度

树的高度是指从叶子节点到达根节点的最长路径。

当前节点的高度示意图

1、递归实现

    /**
     * (递归方式)求树的高度:从叶子节点到达根节点的最长路径
     * @param root
     * @return
     */
    public int getTreeHeight(TreeNode root) {
    	if (root == null) {
			return 0;
		}
    	int leftHeight = getTreeHeight(root.left);
    	int rightHeight = getTreeHeight(root.right);
    	return leftHeight > rightHeight? leftHeight+1 : rightHeight+1;
    	
    }

2、非递归实现

非递归方式采用队列辅助进行层次遍历，然后统计树的高度。

    /**
     * (非递归方式)求树的高度:从叶子节点到达根节点的最长路径
     * @param root
     * @return
     */
    public int non_getTreeHeight(TreeNode root) {
    	if (root == null) {
			return 0;
		}
    	int height = 0, //记录树的高度
    		count = 0, //进行层级统计
    		nextCount = 1; //记录每层遍历后新增到队列中的元素数量
    	
    	Queue<TreeNode> queue = new LinkedList<BinaryTree.TreeNode>();
    	queue.add(root);
    	while (!queue.isEmpty()) {
			TreeNode node = queue.poll();
			count++;
			if (node.left!=null) {
				queue.add(node.left);
			}
			if (node.right!=null) {
				queue.add(node.right);
			}
			if (count == nextCount) {  //表示该层已经遍历完了
				nextCount = queue.size();  //从新获取队列中保存的下一层节点个数
				count = 0;  //每层计算器清零
				height++;   //树的高度加1
			}
		}
    	return height;
    }

求第K大的树节点

要求第K大的树节点，首先要获得树的排序序列，采用中序遍历正好可以获取到树的顺序序列，然后进行第K大节点判断。

    //二叉搜索树的第k大节点(树中第k大的数)
    public int kthLargest(TreeNode root, int k) {
        if (root == null) {
            return 0;
        }
        List<Integer> list = new ArrayList<Integer>();
        findKinOrderTraveral(root, list);
        int size = list.size();
        return list.get(size-k);
    }
    public void findKinOrderTraveral(TreeNode root, List<Integer> list){
        if(root == null) return;
        findKinOrderTraveral(root.left,list);
        list.add(root.val);
        findKinOrderTraveral(root.right,list);
    }