结点的度 ：一个结点含有子树的个数称为该结点的度； 如上图： A 的度为 6

树的度 ：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为 6

叶子结点或终端结点 ：度为 0 的结点称为叶结点； 如上图： B 、 C 、 H 、 I... 等节点为叶结点

双亲结点或父结点 ：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图： A 是 B 的父结点

孩子结点或子结点 ：一个结点含有的子树的根结点称为该结点的子结点； 如上图： B 是 A 的孩子结点

根结点 ：一棵树中，没有双亲结点的结点；如上图： A

结点的层次 ：从根开始定义起，根为第 1 层，根的子结点为第 2 层，以此类推

树的高度或深度 ：树中结点的最大层次； 如上图：树的高度为 4

树的以下概念只需了解，在看书时只要知道是什么意思即可：

非终端结点或分支结点 ：度不为 0 的结点； 如上图： D 、 E 、 F 、 G... 等节点为分支结点

兄弟结点 ：具有相同父结点的结点互称为兄弟结点； 如上图： B 、 C 是兄弟结点

堂兄弟结点 ：双亲在同一层的结点互为堂兄弟；如上图： H 、 I 互为兄弟结点

结点的祖先 ：从根到该结点所经分支上的所有结点；如上图： A 是所有结点的祖先

子孙 ：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是 A 的子孙

森林 ：由 m （ m>=0 ）棵互不相交的树组成的集合称为森林

一棵二叉树是结点的一个有限集合，该集合

1. 或者为空

2. 或者是由 一个根节 点加上两棵别称为 左子树 和 右子树 的二叉树组成。

从上图可以看出：

一棵二叉树，如果 每层的结点数都达到最大值，则这棵二叉树就是满二叉树 。也就是说， 如果一棵

完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n

个结点的二叉树，当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 0 至 n-1 的结点一一对应时称之为完全二叉树

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）

解析：设叶子结点为N0，度数为2的节点为N2，由N0 = N2 + 1 可知，N0 + N2 = 2（N2）+1 = 399 = 二叉树总共的结点399  得 N2 = （399-1）/ 2 = 199 ,所有 N0 = 199+1 = 200 ，正确答案为B.

A n

B n+1

C n-1

D n/2

public class BinaryTree {
    public static class BTNode{
        BTNode left;
        BTNode right;
        int val;

        BTNode(int val) {
            this.val = val;
        }
    }
    private BTNode root;

    public void createBinaryTree() {
        BTNode node1 = new BTNode(1);
        BTNode node2 = new BTNode(2);
        BTNode node3 = new BTNode(3);
        BTNode node4 = new BTNode(4);
        BTNode node5 = new BTNode(5);
        BTNode node6 = new BTNode(6);

        root = node1;
        node1.left = node2;
        node2.left = node3;
        node1.right = node4;
        node4.left = node5;
        node5.right = node6;

    }
}

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。

LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。

LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。

http://【前序遍历 中序遍历 后序遍历】https://www.bilibili.com/video/BV1vv411t7mW?vd_source=3850009259e8d45a9a8c3ad0eb1b723dhttp://【前序遍历 中序遍历 后序遍历】https://www.bilibili.com/video/BV1vv411t7mW?vd_source=3850009259e8d45a9a8c3ad0eb1b723d

例题：

A: ABDHECFG

B: ABCDEFGH

C: HDBEAFCG

D: HDEBFGCA

A: E   B: F   C: G   D: H

A: adbce         B: decab         C: debac         D: abcde

A: FEDCBA         B: CBAFED         C: DEFCBA         D: ABCDEF

递归实现二叉树的前中后后序遍历

 /*
    递归遍历：
     */
    //前序遍历
    public void preOrder(BTNode root) {
        if(root==null) {
            return;
        }
        //前序：根左有
        System.out.println(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }
    //中序遍历
    public void inOrder(BTNode root) {
        if(root == null) {
            return;
        }
        inOrder(root.right);
        System.out.println(root.val+ " ");
        inOrder(root.left);
    }
    //后序遍历
    public void postOrder(BTNode root) {
        if(root==null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.val+" ");
    }

二叉树的基本操作

获取树中节点个数

 //一.获取结点个数
    public int size = 0;
    //1.遍历思路
    public int nodeSize(BTNode root) {
        if(root==null){
            return 0 ;
        }
        //根结点++
        size++;
        nodeSize(root.left);
        nodeSize(root.right);
        return size;
    }

方法二：当前root结点总数 = 左树子树结点个数+右数结点个数+1

  //2.子问题思路，要算当前root结点总数：
    // 左树子树结点个数+右数结点个数+1
    public int nodeSize2(BTNode root) {
        if(root==null) {
            return 0;
        }
        return nodeSize2(root.left) +
                nodeSize2(root.right) + 1;
    }

获取叶子结点个数

获取叶子结点（度为0的结点）的个数
1.遍历思路
一个结点的左边右边都为空，证明为叶子结点

 //二.获取叶子结点（度为0的结点）的个数

    //1.遍历思路
    //一个结点的左边右边都为空，证明为叶子结点
    public int leafSize = 0;
    public int getLeafSize(BTNode root) {
        if(root==null) {
            return 0 ;
        }
        if(root.right==null&&root.left==null) {
            leafSize++;
        }
        getLeafSize(root.left);
        getLeafSize(root.right);
        return leafSize;
    }

子问题思路-获取叶子结点个数

当前二叉树叶子结点个数
              = 根结点左边的叶子结点个数 + 根结点右边的叶子个数 

 //2.子问题思路，要算当前二叉树叶子结点个数
    //     = 根结点左边的叶子结点个数 + 根结点右边的叶子个数 
    public int getLeafSize2(BTNode root) {
        if(root==null) {
            return 0;
        }
        if(root.left == null && root.right==null) {
            return 1;
        }
        return getLeafSize2(root.left) +
        getLeafSize2(root.right);
    }

获取第K层结点个数

 root这颗树的第K层 = root.left 第 K-1 层 +
                    root.right 的第 K-1层

 //三.获取 第K层 结点个数

    //子问题：
    //  root这颗树的第K层 = root.left 第 K-1 层 +
    //                    root.right 的第 K-1层
    public int getKLeveNodeCount(BTNode root,int  k) {
        if(root == null) {
            return 0;
        }
        if(k==1) {
            return 1;
        }
        return getKLeveNodeCount(root.left,k-1) +
                getKLeveNodeCount(root.right,k-1);
    }

获取二叉树的高度

高度 = (root 左树的高度   root 右树的高度 )max + 1

 //四.获取二叉树的高度
    //高度 = (root 左树的高度   root 右树的高度 )max
    //                        + 1
    public int height;
    public int getHeight(BTNode root) {
        if(root == null) {
            return 0;
        }
      int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return (leftHeight > rightHeight ? leftHeight+1 : rightHeight+1);
    }

判断值为key的元素是否存在

---

 //五.判断K是否在二叉树里
    //前序遍历的方式进行二叉树的遍历
    public boolean find(BTNode root,int key) {
        if(root==null) {
            return false;
        }
        //判断根节点
        if(root.val==key) {
            return true;
        }
        //根节点左边
        boolean leftVal = find(root.left,key);
        if(leftVal==true) {
            return true;
        }
        //根结点右边
        boolean rightVal = find(root.right,key);
        if(rightVal==true) {
            return true;
        }

        return false;

    }