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);
    }
}