《恋上数据结构第1季，kafka入门与实践电子版

本文链接：https://blog.csdn.net/m0_61453067/article/details/120208938

*   最多有 2h − 1 个节点（ 20 + 21 + 22 + ⋯ + 2h−1，即 **满二叉树** ）

*   总节点数量为 n  

    2h−1 ≤ n < 2h  

    h − 1 ≤ log2n < h  

    h = floor( log2n ) + 1  

    （ `floor` 是向下取整，`ceiling` 是向上取整 ）

在这里插入图片描述

下图不是完全二叉树：

在这里插入图片描述

[](

)面试题（完全二叉树）

在这里插入图片描述

国外教材的说法：了解一下

在这里插入图片描述

[](

)二叉树的遍历 + 练习题

===============================================================================

遍历是数据结构中的常见操作：把所有元素都访问一遍；

线性数据结构的遍历比较简单：

正序遍历
逆序遍历

根据节点访问顺序的不同，二叉树的常见遍历方式有 4 种：

前序遍历（Preorder Traversal）
中序遍历（Inorder Traversal）
后序遍历（Postorder Traversal）
层序遍历（Level Order Traversal）

遍历的应用：

前序遍历：树状结构展示（注意左右子树的顺序）
中序遍历：二叉搜索树的中序遍历按升序或者降序处理节点
后序遍历：适用于一些先子后父的操作
层序遍历：计算二叉树的高度、判断一棵树是否为完全二叉树

[](

)前序遍历（Preorder Traversal）

访问顺序：根节点、前序遍历左子树、前序遍历右子树

下图前序遍历的结果是：7、4、2、1、3、5、9、8、11、10、12

在这里插入图片描述

二叉树的前序遍历：[https://leetcode-cn.com/problems/binary-tree-preorder-traversal/](

)


/**

 * Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * }

 */

class Solution {

	List<Integer> list = new ArrayList<>();

	public List<Integer> preorderTraversal(TreeNode root) {

        if(root == null) return list;

        

        list.add(root.val);

        preorderTraversal(root.left);

        preorderTraversal(root.right);

        

        return list;

    }

}

[](

)中序遍历（Inorder Traversal）

访问顺序：中序遍历左子树、根节点、中序遍历右子树

下图中序遍历的结果是：1、2、3、4、5、7、8、9、10、11、12

另一种中序遍历访问顺序：中序遍历右子树、根节点、中序遍历左子树

则下图的中序遍历的结果是：12、11、10、9、8 、7、5、4、3、2、1

在这里插入图片描述

二叉搜索树的中序遍历结果是升序或者降序的；

二叉树的中序遍历： [https://leetcode-cn.com/problems/binary-tree-inorder-traversal/](

)


/**

 * Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * }

 */

class Solution {

	List<Integer> list = new ArrayList<>();

    public List<Integer> inorderTraversal(TreeNode root) {

    	if(root == null) return list;

    	inorderTraversal(root.left);

    	list.add(root.val);

    	inorderTraversal(root.right);

    	return list;

    }

}

[](

)后序遍历（Postorder Traversal）

访问顺序：后序遍历左子树、后序遍历右子树、根节点

下图的后序遍历的结果是：1、3、2、5、4、8、10、12、11、9、7

在这里插入图片描述

二叉树的后序遍历： [https://leetcode-cn.com/problems/binary-tree-postorder-traversal/](

)


/**

 * Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * }

 */

class Solution {

	List<Integer> list = new ArrayList<Integer>();

    public List<Integer> postorderTraversal(TreeNode root) {

        if(root == null) return list;

        postorderTraversal(root.left);

        postorderTraversal(root.right);

        list.add(root.val);

        return list;

    }

}

[](

)层序遍历（Level Order Traversal）

访问顺序：从上到下、从左到右依次访问每一个节点

下图的层序遍历的结果是：7、4、9、2、5、8、11、1、3、10、12

在这里插入图片描述

二叉树的层次遍历： [https://leetcode-cn.com/problems/binary-tree-level-order-traversal/](

)


/**

 * Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * }

 */

class Solution {

	List<List<Integer>> resList = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {

    	if(root == null) return resList;

    	

    	Queue<TreeNode> queue = new LinkedList<>();

    	int levelSize = 1;

    	queue.offer(root);

    

    	

    	List<Integer> list = new ArrayList<>(); ;

    	while(!queue.isEmpty()){

    		TreeNode node = queue.poll();

    		list.add(node.val);

    		levelSize--;

    		

    		if(node.left != null){

    			queue.offer(node.left);

    		}

    		if(node.right != null){

    			queue.offer(node.right);

    		}



    		if(levelSize == 0){

    			resList.add(list);

                levelSize = queue.size();

    			list = new ArrayList<>();

    		}

    	}

    	return resList;

    }

}

[](

)根据遍历结果重构二叉树

==============================================================================

以下结果可以保证重构出唯一的一棵二叉树：