Java的二叉树

树

是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起 来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个结点有零个或多个子结点；没有父 结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树

概念：

节点的度：一个节点含有的子树的个数称为该节点的度；
树的度：一棵树中，最大的节点的度称为树的度；
叶子节点或终端节点：度为0的节点称为叶节点；
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
根结点：一棵树中，没有双亲结点的结点；
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为

二叉树

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

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

特殊二叉树

完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个 结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉 树。 要注意的是满二叉树是一种特殊的完全二叉树。
满二叉树: 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一 个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

二叉树的遍历

1.NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 3. LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

这里就不举例了，比较简单。

二叉树的构成

class Node {
    	int val;        // 数据域
        Node left;      // 左孩子的引用，常常代表左孩子为根的整棵左子树    
        Node right;     // 右孩子的引用，常常代表右孩子为根的整棵右子树    
        Node parent;    // 可选的，双亲的引用 }
		Node root = null;   // 表示没有结点，如果是树的根，则表示根一个结点都没有，即空树
		}

然后就是一些常规代码实现：

package TreeNode;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

class TreeNode{
    public char val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(char val) {  //构造方法
        this.val = val;
    }

    @Override
    public String toString() {   
        return "TreeNode{" +
                "val=" + val +
                '}';
    }
}
public class Tree {
    private static TreeNode root=null;
    public static void preOrderTraversal(TreeNode root){ //先序遍历
     if(root == null){
         return;
     }
        System.out.print(root.val);
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
        return;
   }

    public static void inOrderTraversal(TreeNode root){//中序遍历
        if(root == null){
            return;
        }
        inOrderTraversal(root.left);
        System.out.print(root.val);
        inOrderTraversal(root.right);
        return;
    }
    public  static void postOrderTraversal(TreeNode root){//后序遍历
        if(root == null){
            return;
        }
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val);
        return;
    }
   public static void buildTree(){  //构造树
       TreeNode A = new TreeNode('A');
       TreeNode B = new TreeNode('B');
       TreeNode C = new TreeNode('C');
       TreeNode D = new TreeNode('D');
       TreeNode E = new TreeNode('E');
       TreeNode F = new TreeNode('F');
       TreeNode G = new TreeNode('G');
       A.left = B;
       A.right = C;
       B.left = D;
       B.right = E;
       E.left = G;
       C.right = F;
        root=A;
   }
    static int size = 0;//算数结点数
    public static void getSize1(TreeNode root){
        if(root == null){
            return ;
        }
        size++;
        getSize1(root.left);
        getSize1(root.right);
    }
    public static int getSize2(TreeNode root){  //第二种方法
        if(root == null){  
            return 0;
        }
        return 1+getSize2(root.left)+getSize2(root.right);
    }
    static int leafSize = 0;
    public static void  getLeafSize1(TreeNode root){  //叶子结点个数
        if(root == null){
            return ;
        }
        if(root.left == null && root.right == null){
            leafSize++;
        }
        getLeafSize1(root.left);
        getLeafSize1(root.right);
    }
    public static int getLeafSize2(TreeNode root){//叶子结点数二
        if(root == null){
            return  0;
        }
        if(root.left == null && root.right == null){
            return 1;
        }
        return getLeafSize2(root.left)+getLeafSize2(root.right);
    }
   public static int getKLevelSize(TreeNode root,int k){ 
        if(root == null || k<1){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        return getKLevelSize(root.left,k-1)+
                  getKLevelSize(root.right,k-1);
   }
   public static TreeNode find(TreeNode root, int val){
        if(root == null){
            return null;
        }
        if(root.val ==val){
            return root;
        }
       TreeNode ret = find(root.left, val);
       if (ret != null) {
           return ret;
       }
       return find(root.right,val);
   }
  public static void levelOrderTraversal(TreeNode root){
      if(root == null){
          return;
      }
      Queue<TreeNode> queue=new LinkedList<>();
      queue.offer(root);
      while(!queue.isEmpty()) {
          TreeNode cur = queue.poll();
          System.out.print(cur.val + " ");
          if (cur.left != null) {
              queue.offer(cur.left);
          }
          if (cur.right != null) {
              queue.offer(cur.right);
          }
      }
  }
    public static void main(String[] args) {
      buildTree();
//     preOrderTraversal(root);
//        System.out.println();
//     inOrderTraversal(root);
//        System.out.println();
//     postOrderTraversal(root);
//     getSize1(root);
//        System.out.println(size);
//        System.out.println(getSize2(root));
//        getLeafSize1(root);
//        System.out.println(leafSize);
//        System.out.println(getLeafSize2(root));
//        System.out.println(getKLevelSize(root,5));
//        System.out.println(find(root,'F'));
        levelOrderTraversal(root);
    }
}