目录
一. 树
1.1 树的定义
树是n个结点的有限集合，有且仅有一个根结点，其余结点可分为m个根结点的子树。
1.2 树的概念
树（tree）是包含 n(n≥0)个结点，当 n=0 时，称为空树，非空树中条边的有穷集，在非空树中：（1）每个元素称为结点（node）。
（2）有一个特定的结点被称为根结点或树根（root）。
结点的度: 一个结点拥有子树的个数称为度。比如A的度为3，B的度为2，C的度为0。度为0的结点称为叶子结点（C,E,G,H,I）。树的度是树中所有结点的度的最大值，此树的度为3。
树的深度(高度)：树中结点的最大层次称为树的深度或高度。此树的深度为4。
父结点和子结点：父节点A的子结点B,C，D；B,C,D也是兄弟结点。
森林：树的集合称为森林，树和森林之间有着密切的关系，删除一个树的根结点,其所有原来的子树都是树,构成森林，用一个结点连接到森林的所有树的根结点就构成树。
空树：空集合也是树，称为空树。空树中没有结点。
二. 二叉树
2.1 二叉树的定义
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。
2.2 二叉树的性质
性质1：二叉树的第 i 层上至多有 2^(i-1)（i≥1）个结点。
性质2：深度为 h 的二叉树中至多含有 2^h - 1 个结点。
性质3：若在任意一棵二叉树中，有 n0 个叶子节点，有 n2 个度为2的节点，则必有 n0=n2+1。
性质4：具有 n 个节点的满二叉树深为 log2n+1。
2.3 二叉树的特殊类型
1、满二叉树：如果一棵二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。（高度为h，由2^h-1个节点构成的二叉树称为满二叉树）
2、完全二叉树：深度为k，有n个节点的二叉树当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树。
2.4 二叉树的遍历
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点 所做的操作依赖于具体的应用问题(比如：打印节点内容)。
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode(int val) {
this.val = val;
this.left = null;
this.right = null;
}
}层序遍历(广度优先遍历)
按二叉树从上到下，从左到右依次打印每个节点中存储的数据。
import java.util.LinkedList;
import java.util.Queue;
public class 层序遍历 {
public void levelorder(TreeNode root){
if(root == null){
return;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
TreeNode node = queue.poll();
System.out.printf("%c ", node.val);
if (node.left != null){
queue.offer(node.left);
}
if (node.right != null){
queue.offer(node.right);
}
}
System.out.println();
}
}前序遍历(深度优先遍历)
前序(preorder)遍历：根——>左——>右
import sun.reflect.generics.tree.Tree;
public class 前序遍历 {
//(前序遍历)采用递归方法的形式进行编写；
public static void preorder(TreeNode root){
//空树；
//跟的左右子树为空树；
//跟的左子树为空 && 跟的右子树不为空树；
//跟的右子树为空 && 跟的左子树不为空树；
//跟的左子树不为空 && 跟的右子树不为空树；
if(root == null){
//空树直接返回；
return;
}
if(root.left == null && root.right == null){
System.out.printf("%c ",root.val);
return;
}
if(root.left == null && root.right != null){
System.out.printf("%c ",root.val);
preorder(root.right);
return;
}
if(root.left != null && root.right == null){
System.out.printf("%c ",root.val);
preorder(root.left);
return;
}
if(root.left != null && root.right != null){
System.out.printf("%c ",root.val);
preorder(root.left);
preorder(root.right);
}
}
public static void preorder1(TreeNode root){
if(root != null){
System.out.printf("%c ",root.val);
preorder1(root.left);
preorder1(root.right);
}
//空树直接返回；
}
}中序遍历(深度优先遍历)
中序(inorder)遍历：左——>根——>右
public class 中序遍历 {
public static void inorder(TreeNode root){
if(root != null){
inorder(root.left);
System.out.printf("%c ", root.val);
inorder(root.right);
}
}
}后序遍历(深度优先遍历)
后序(postorder)遍历：左——>右——>根
public class 后序遍历 {
public static void postorder(TreeNode root){
if(root != null){
postorder(root.left);
postorder(root.right);
System.out.printf("%c ", root.val);
}
}
}
前中后序遍历的两种视角
视角1：递归视角
前序遍历：【跟】【左子树】【右子树】
中序遍历：【左子树】【跟】【右子树】
后续遍历：【左子树】【右子树】【跟】
视角2：非递归视角
无论是前，中，后序，都是沿着这个图中的虚线在前进，会经过所有结点。观察树中的每个结点，在这个过程都会被路过3次。
前序遍历：在第一次经过结点时，打印该结点；
中序遍历：在第二次经过结点时，打印该结点；
后序遍历：在第三次经过结点时，打印该结点；
2.5 二叉树的基本操作
1. 计算二叉树结点个数
public class Tree {
//通过前序遍历的方式，计算一棵树的结点个数；
private static int nodeCount;
public static void calcNodeCountVersion1(TreeNode root){
if (root != null){
nodeCount++;
calcNodeCountVersion1(root.left);
calcNodeCountVersion1(root.right);
}
}
public static int calcNodeCountVersion2(TreeNode root){
if(root == null){
return 0;
}
//分别用递归的方法，去计算左右子树的结点个数；
int leftCount = calcNodeCountVersion2(root.left);
int rightCount = calcNodeCountVersion2(root.right);
return leftCount + rightCount + 1;
}
}2. 计算二叉树叶子结点个数
public class Tree {
//方法1---遍历统计
private static int leafCount;
private static void calcLeafCountVersion1(TreeNode root){
if(root !=null){
//判断当前经过的结点，是不是叶子结点
if(root.left ==null && root.right == null){
leafCount++;
}
calcLeafCount(root.left);
calcLeafCount(root.right);
}
}
//方法2：化简为小问题的方式
private static int calcLeafCountVersion2(TreeNode root){
if(root == null){
return 0;
}
if(root.left == null && root.right == null){
return 1;
}
int leftLeafCount = calcLeafCountVersion2(root.left);
int rightLeafCount = calcLeafCountVersion2(root.right);
return leftLeafCount + rightLeafCount;
}
}3. 二叉树 k 层的结点个数
public class Tree {
public static int calcKLevelNodeCount(TreeNode root,int k){
if(root == null){
return 0;
}
if(k ==1){
return 1;
}
int leftCount = calcKLevelNodeCount(root.left,k - 1);
int rihgtCount = calcKLevelNodeCount(root.right,k - 1);
return leftCount + rihgtCount;
}
}4. 二叉树的高度
public class Tree {
public static int calcHeight(TreeNode root){
if(root == null){
return 0;
}
int leftHeight = calcHeight(root.left);
int rightHeight = calcHeight(root.right);
return Integer.max(leftHeight,rightHeight) + 1;
}
}5. 二叉树查找 val 是否存在
public class Tree {
/**
* 在以 root 为跟的二叉树中，进行 val 的查找
* 前提：二叉树中的 val 不会出现重复
* @param root 二叉树的跟结点
* @param val 待查找的值
* @return val 所在的结点。
*/
public static TreeNode find(TreeNode root,int val){
if(root == null){
return null;
}
if(root.val == val){
return root;
}
TreeNode node = find(root.left,val);
if(node != null){
return node;
}
//返回右子树的查找结果
return find(root.right,val);
}
}6. 判断是不是平衡二叉树
public class Tree {
private int height(TreeNode root) {
if (root == null) {
return 0;
}
return Integer.max(height(root.left), height(root.right)) + 1;
}
public boolean isBalanced(TreeNode root) {
if (root == null) {
return true;
}
int left = height(root.left);
int right = height(root.right);
int diff = left - right;
// 高度差的绝对值 <= 1 <=> -1 <= diff && diff <= 1
if (diff < -1 || diff > 1) {
return false;
}
return isBalanced(root.left) && isBalanced(root.right);
}
}7. 判断两棵树是否相同
public class Solution {
public boolean isSameTree(TreeNode p, TreeNode q){
if (p == null && q == null){
return true;
}
if (p == null || q == null){
return false;
}
return p.val == q.val && isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}8. 判断两棵树是否互为镜像
public class Solution {
public boolean isMirrorTree(TreeNode p, TreeNode q){
if (p == null && q == null){
return true;
}
if (p == null || q == null){
return false;
}
return p.val == q.val && isMirrorTree(p.left,q.right) && isMirrorTree(p.right,q.left);
}
public boolean isSymmetric(TreeNode root){
return isMirrorTree(root.left,root.right);
}
}9. 判断两棵树是否有包含关系
public class Solution {
private boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null && q == null) {
return true;
}
if (p == null || q == null) {
return false;
}
return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
// 保证：subRoot != null
private boolean find(TreeNode root, TreeNode subRoot) {
if (root == null) {
return false;
}
if (isSameTree(root, subRoot)) {
return true;
}
if (find(root.left, subRoot)) {
return true;
}
return find(root.right, subRoot);
}
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
if (subRoot == null) {
return true;
}
return find(root, subRoot);
}
}
4276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
