数据结构二叉树基础及其Java实现瞅瞅这里

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树
是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

1.二叉搜索树（BST）
2.平衡二叉树（AVL,红黑树）
3.堆，并查集
4.线段树，Trie（字典树）

1.子树不相交
2.除根节点外，每个节点有且仅有一个父节点
3.一颗N个节点的树有N-1条边

节点的度：一个节点含有的子树的个数称为该节点的度；
树的度：一棵树中，最大的节点的度称为树的度；
叶子节点或终端节点：度为0的节点称为叶节点；
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
根结点：一棵树中，没有双亲结点的结点；
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；
兄弟节点：具有相同父节点的节点互称为兄弟节点；
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
森林：由m（m>=0）棵互不相交的树的集合称为森林

孩子兄弟表示法

class Node {
    int value; // 树中存储的数据
    Node firstChild; // 第一个孩子引用`在这里插入代码片
    Node nextBrother; // 下一个兄弟引用
} 

两种特殊的二叉树：满二叉树，完全二叉树

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

实现递归的条件

• 大问题可以拆分为小问题
• 除了数据规模之外，大问题与小问题的求解思路完全一样
• 存在终止条件

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

 //先序遍历   （根左右）
 //传入一棵二叉树的根节点，根据先序遍历访问该二叉树
        public void preOrder(Node root){
            if(root==null) {
              return;
            }
            //根
            System.out.print(root.val+" ");
            //左
            preOrder(root.left);
            //右
            preOrder(root.right);
              System.out.println("先序遍历结果:");
              myBinaryTree.preOrder(root);
        }

(Inorder Traversal)——根的左子树—>根节点—>根的右子树。

  //中序遍历  （左根右）传入一棵二叉树的根节点，根据中序遍历访问该二叉树
        public void inOrder(Node root){
        if(root == null){
            return;
        }
        //左
        inOrder(root.left);
        //根
        System.out.print(root.val+" ");
        //右
        inOrder(root.right);
            System.out.println("中序遍历结果:");
            myBinaryTree.inOrder(root);
    }

(Postorder Traversal)——根的左子树—>根的右子树—>根节点。

  //后序遍历  （左右根） 传入一棵二叉树的根节点，根据后序遍历访问该二叉树
        public void postOrder(Node root){
          if(root == null){
          return;
        }

         //左
         postOrder(root.left);
         //右
         postOrder(root.right);
         //根
        System.out.print(root.val+" ");
            System.out.println("后序遍历结果:");
            myBinaryTree.postOrder(root);
     }

 //传入一个二叉树的根节点root，求得该二叉树的节点个数
public int getNodeCount(Node root){
        if(root ==null){
            return 0;
        }
        return 1 + getNodeCount(root.left)+getNodeCount(root.right);
     System.out.println("二叉树节点个数为:");
     System.out.println(myBinaryTree.getNodeCount(root));
}

//传入一个二叉树的根节点root，求得该二叉树叶子节点个数
    public int getLeafNodeCount(Node root){
        if(root == null){
            return 0;
        }
       //若只有左子数或者只有右子树
         if(root.left == null||root.right == null){
             return 1;
         }
         return getLeafNodeCount(root.left) + getLeafNodeCount(root.right);
         System.out.println("二叉树的叶子节点个数为:");
         System.out.println(myBinaryTree.getLeafNodeCount(root));
 
    }

   //传入一个二叉树的根节点root，求二叉树的高度
    public int height(Node root){
        if(root == null){
            return 0;
        }
        //返回根节点高度1＋左右子树的高度较大值
       return  1 + Math.max(height(root.left),height(root.right));
        System.out.println("二叉树的高度为:");
        
    }

//传入一个二叉树的根节点root，判断该二叉树只能够是否包含值为val的节点
    public boolean contains(Node root,char val){
        //根为空
        if(root ==null){
            return false;
        }
        //根=要查找的val
        if(root.val ==val) {
            return true;
        }
        //在左子树和右子树中查找val
        return contains(root.left,val )|| contains(root.right,val);
        System.out.println(myBinaryTree.height(root));
        System.out.println("二叉树中是否存在值H,X:");
    }

//传入一个二叉树的根节点root，求该二叉树第k层的节点个数
    public int getLevelNodes(Node root,int k){
        if(k <= 0||root == null){
            return 0;
        }
        if(k==1){
            return 1;
        }
        //若k>1,第K层的节点个数=左子树的k-1层节点个数+右子树的K-1层节点个数
        return getLevelNodes(root.left,k-1)+ getLevelNodes(root.right,k-1);
        System.out.println("二叉树第3层节点个数:");
        System.out.println(myBinaryTree.getLevelNodes(root,3));
    }