二叉树

二叉树

一.二叉树的概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉
树组成。
二叉树的特点：

1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
2. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。

二.二叉树的基本形态

上图给出了几种特殊的二叉树形态，从左往右依次是：空树、只有根节点的二叉树、节点只有左子树、节点只有右子树、节点的左右子树均存在，一般二叉树都是由上述基本形态结合而形成的。

三.两种特殊的二叉树

1.满二叉树

. 满二叉树: 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。

2.完全二叉树

完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

四.二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点
2. 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0)
3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
4. 具有n个结点的完全二叉树的深度k为 上取整
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：
   若i>0，双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
   若2i+1<n，左孩子序号：2i+1，否则无左孩子
   若2i+2<n，右孩子序号：2i+2，否则无右孩子

五.二叉树的存储

1.顺序存储

2. 链式存储

二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式

// 孩子表示法
class Node {
 int val; // 数据域
 Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
 Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
// 孩子双亲表示法
class Node {
 int val; // 数据域
 Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
 Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
 Node parent; // 当前节点的根节点
}

六.二叉树的基本操作

1.二叉树的遍历

<1>先序遍历

 //先序遍历
    public static void preTraversal(TreeNode root){
       //前提是，这棵树不是空树，有根结点

        if (root!=null) {
            //1.首先处理根节点
            System.out.println(root.value);
            //2.按照前序遍历的方式，递归处理该结点的左子树
            preTraversal(root.left);
            //3.按照前序遍历的方式，递归处理该结点的右子树
            preTraversal(root.right);
        }else {
            //什么都不处理即可
        }
    }

<2>中序遍历

  //中序遍历
    public static void  inTraversal(TreeNode root){
       inTraversal(root.left);
        System.out.println(root.value);
        inTraversal(root.right);
    }

<3>后序遍历

//后序遍历
    public static void postTraversal(TreeNode root){
   postTraversal(root.left);
   postTraversal(root.right);
        System.out.println(root.value);
    }

<4>层序遍历

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

使用队列实现

public static void sequenceTraversal(TreeNode root){
        if(root==null){
            return;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            //这个node就是层序遍历经过的结点
           TreeNode node =queue.remove();
            System.out.println(node.value);
            //如果左孩子存在，放入队列
            if(node.left!=null){
                queue.add(node.left);
            }
            //如果右孩子存在，放入队列
            if(node.right!=null){
                queue.add(node.right);
            }
        }
    }

2.二叉树求结点个数

<1>解题思路

<2>代码示例

public class TreeNodeCount {
    private  static int n;//静态变量，记录结点个数，作用域是大括号内
    //返回根为root的树中，有多少个结点
    public static int  sumTreeNodeSize(TreeNode root){
         n=0;//每次计数前，先把n归零
        preTraversal(root);
        return n;
    }

    public static void preTraversal(TreeNode root){
        //1.一个树的结点（root！=null）
        //2.没有结点（root==null）
        if(root!=null){
            //处理根的时候不打印，执行n++
             n++;
            preTraversal(root.left);
            preTraversal(root.right);
        }
    }
}

3.求二叉树第K层结点个数

<1>解题思路

<2>代码示例

public class Tree_k_LeafCount {
  //给定一棵二叉树，求该二叉树，第k层的节点个数

 public static int getKLevelSize(TreeNode root,int k){
     //1.空树情况
     if(root==null){
         return 0;
     }else if(k==1){
         //第一层结点个数
         return 1;
     }else {
         //其他情况
         int leftLeafK_1=getKLevelSize(root.left, k-1);
         int rightLeafK_1=getKLevelSize(root.right, k-1);
         return leftLeafK_1+rightLeafK_1;
     }
}
 }

4.求二叉树叶子结点的个数

<1>解题思路

使用静态变量n记录叶子结点的个数，然后遍历二叉树，当左孩子和右孩子都为空时，n++

<2>代码示例

public class TreeLeafCount {
    private static int n;//记录叶子结点的个数
    public static int TreeLeafcount(TreeNode root){
        n=0;
        LeafCount(root);
        return n;
    }
    public static void LeafCount(TreeNode root){
        if(root!=null){
            if(root.left!=null||root.right!=null){
                LeafCount(root.left);
                LeafCount(root.right);
            }else {
                n++;
            }
        }
    }
}

5.求二叉树的高度

<1>解题思路

<2>代码示例

public class TreeHeight {
    public static int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }else if(root.left==null&&root.right==null){
            return 1;
        }else {
            int leftHeight=getHeight(root.left);
            int rightHeight=getHeight(root.right);
            return Math.max(leftHeight,rightHeight)+1;
        }
    }
}

6.在二叉树中查找是否含有另一棵二叉树

<1>解题思路

<2>代码示例

public class NodeFind {
    public static TreeNode Find(TreeNode root, char a) {
        if (root == null) {
            //为空树
            return null;
        } else {
            //树不为空
            if (root.value == a) {
                return root;
            } else {
                //根结点中没找到
                //在左子树中找
                TreeNode leftFind = Find(root.left, a);
                if (leftFind != null) {
                    //左子树中找到了
                    return leftFind;
                } else {
                    //左子树中没找到，在右子树中找
                    TreeNode rightFind = Find(root.right, a);
                    if (rightFind != null) {
                        //右子树中找到了
                        return rightFind;
                    } else {
                        //右子树中没找到
                        return null;
                    }
                }
            }
        }
    }
}

7.判断一棵二叉树是不是完全二叉树

<1>解题思路

根据层序遍历的思想

<2>代码示例

import java.util.LinkedList;
import java.util.Queue;

public class JudgeCompleteTree {
    public static boolean Judeg(TreeNode root){
        Queue<TreeNode>queue=new LinkedList<>();
        if(root==null){
            return true;
        }
        queue.add(root);
        //找到队列中第一个为空的结点
        while (true){
          TreeNode node=queue.remove();
          if(node==null){
              break;
          }
          //无论左右孩子是不是null，都放入队列中
            queue.add(node.left);
          queue.add(node.right);
        }
        //判断队列中是不是全为null，如果是，则是完全二叉树，反之则不是
        while (!queue.isEmpty()){
            if(queue.remove()!=null){
                return false;
            }
        }
        return true;
    }
}

七.总结