树的简单介绍

结点的度
结点拥有的子树数称为结点的度。度为0的结点称为叶子结点或终端结点（如上图的GHIJ），度不为0的结点称为非终端结点或分支结点(如ABC等)。除根结点以外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。(如此时B结点的度是1，D结点的度是3)

层次与深度
结点的层次从根开始定义起，根为第一层，根的孩子是第二层。若某节点在第k层，则其子树的根就在k+1层。其双亲在同一层的结点互为堂兄弟。树中的结点的最大层次称为树的深度或高度。

有序与无序树
如果将树中结点的各子树看成从左到右是有次序的，不能互换的，则称改树有序树，否则称为无序树

树的存储结构
三种表示方法

• 双亲表示法
• 孩子表示法
• 孩子兄弟表示法
  

二叉树

特殊二叉树
所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树

满二叉树
在一颗二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树

完全二叉树
完全二叉树实际和满二叉树差不多，满二叉树一定是完全二叉树，但是完全二叉树最后一层是可以缺少的，但是缺少的只能是右边的

二叉树的性质

简单使用

public class BinaryTree {
    //根结点
    public TreeNode root = null;

    public BinaryTree() {
        root = new TreeNode(1, "A");
    }
    /**
     * 构建二叉树
     *         A
     *     B       C
     * D      E        F
     */
    public void createBinaryTree() {
        TreeNode nodeB = new TreeNode(2, "B");
        TreeNode nodeC = new TreeNode(3, "C");
        TreeNode nodeD = new TreeNode(4, "D");
        TreeNode nodeE = new TreeNode(5, "E");
        TreeNode nodeF = new TreeNode(6, "F");
        root.leftNodes=nodeB;
        root.rightNodes=nodeC;
        nodeB.leftNodes = nodeD;
        nodeB.rightNodes = nodeE;
        nodeC.rightNodes = nodeF;
    }
    /**
     * 前序遍历——迭代 根结点->左结点->右结点
     *         A
     *     B       C
     * D      E        F
     */
    public void preOrder(TreeNode node) {//前序遍历:A B D E C F
        if(node==null){
            return;
        }else{
            System.out.println(node.data);
            preOrder(node.leftNodes);
            preOrder(node.rightNodes);
        }
    }
    /**
     * 中序遍历——迭代  左结点->根结点->右结点
     *         A
     *     B       C
     * D      E        F
     */
    public void midOrder(TreeNode node) {//D B E A C F
        if(node==null){
            return;
        }else{
            midOrder(node.leftNodes);
            System.out.println(node.data);
            midOrder(node.rightNodes);
        }
    }
    /**
     * 后序遍历——迭代 左结点->右结点->根结点
     *         A
     *     B       C
     * D      E        F
     */
    public void postOrder(TreeNode node) {//D E B F C A
        if(node==null){
            return;
        }else{
            postOrder(node.leftNodes);
            postOrder(node.rightNodes);
            System.out.println(node.data);
        }
    }
    /**
     * 获得二叉树的高度或深度
     */
    public int getHeight() {
        return getHeight(root);
    }

    /**
     * 获得二叉树的高度或深度
     */
    private int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int i = getHeight(root.leftNodes);
        int j = getHeight(root.rightNodes);
        return (i < j) ? j + 1 : i + 1;
    }

    /**
     * 获取二叉树的结点数
     */
    public int getSize() {
        return getSize(root);
    }

    private int getSize(TreeNode root) {
        if(root==null){
            return 0;
        }else {
            return 1+getSize(root.leftNodes)+getSize(root.rightNodes);
        }
    }

    /**
     * 判断是否是平衡树:可以是空树，左右子树的高度差不会超过1，并且左右子树都是平衡二叉树
     */
    public boolean isBalanceTree(TreeNode root) {
          if(root==null){
              return true;
          }
          //左右子树的高度差不会超过1
        int leftDepth=getHeight(root.leftNodes);
        int rightDepth=getHeight(root.rightNodes);
        
        //左右子树都是平衡二叉树

        return Math.abs(leftDepth-rightDepth)<=1&&isBalanceTree(root.leftNodes)&&isBalanceTree(root.rightNodes);
    }

    public class TreeNode {
        private int index;
        private String data;
        private TreeNode leftNodes;
        private TreeNode rightNodes;
        public TreeNode(int index, String data) {
            this.index = index;
            this.data = data;
        }

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }
    }
}