tree

中綴表達式轉後綴
    符號入棧,入棧時檢查棧頂符號優先級,若優先級比符號低,直接入棧,若高,則出棧,一直到發現優先級更低的
元素爲止(同優先級不算)

後綴構建表達式樹
   樹入棧,遇到符號出棧構成子樹,子樹入棧....

ALV樹 ：由最下面向上找第一個不平衡的點
單旋   /  左旋       \ 右旋
雙旋  < 先左後右  對拐角節點左旋，然後對 第一個不平衡的點 右旋  
      >先右後左  對拐角節點 右旋 ，然後對 第一個不平衡的點 左旋

ALV實現

public class Tree {
    public static void main(String[] args) {
        TreeNode root =null;
        root = insert(3,root);
        root =  insert(1,root);
        root =  insert(4,root);
        root =  insert(7,root);
        root =  insert(10,root);
        root = insert(5,root);
        showTree(root);
        System.out.println("-------------------------");
        showTree1(root);
        System.out.println("-------------------------");
        showTree2(root);

    }

    public static void showTree(TreeNode treeNode){
        if(treeNode==null){
            return;
        }
        System.out.println(treeNode.value+" high: "+treeNode.high);
        showTree(treeNode.left);
        showTree(treeNode.right);
    }
    public static void showTree1(TreeNode treeNode){
        if(treeNode==null){
            return;
        }
        showTree1(treeNode.left);
        System.out.println(treeNode.value+" high: "+treeNode.high);
        showTree1(treeNode.right);
    }

    public static void showTree2(TreeNode treeNode){
        if(treeNode==null){
            return;
        }
        showTree2(treeNode.left);
        showTree2(treeNode.right);
        System.out.println(treeNode.value+" high: "+treeNode.high);
    }
    public static int getHight(TreeNode position) {
        if (position == null) {
            return -1;
        } else {
            return position.high;
        }
    }

    public static TreeNode insert(int value, TreeNode treeNode) {
        if (treeNode == null) {
            treeNode = new TreeNode(value);
            treeNode.high = 0;
            treeNode.left = treeNode.right = null;
        } else if (value < treeNode.value) {//左子樹
           treeNode.left = insert(value, treeNode.left);

            if (getHight(treeNode.left) - getHight(treeNode.right) == 2) {
                if (value < treeNode.left.value) {
                    treeNode = rightRotate(treeNode);
                } else {
                    treeNode = leftThenRightRotate(treeNode);
                }
            }
        } else if(value>treeNode.value){//右子樹
            treeNode.right = insert(value, treeNode.right);

            if (getHight(treeNode.right) - getHight(treeNode.left) == 2) {
                if (value > treeNode.right.value) {
                    treeNode = leftRotate(treeNode);
                } else {
                    treeNode = rightThenLeftRotate(treeNode);
                }
            }
        }
        treeNode.high = Math.max(getHight(treeNode.left),getHight(treeNode.right))+1;
        return treeNode;
    }

    public static TreeNode rightRotate(TreeNode treeNode) {
        TreeNode tmp = treeNode.left;
        treeNode.left = tmp.right;
        tmp.right=treeNode;
        treeNode.high=Math.max(getHight(treeNode.left),getHight(treeNode.right))+1;
        tmp.high =Math.max(getHight(tmp.left),getHight(tmp.right))+1;
        return tmp;
    }

    public static TreeNode leftThenRightRotate(TreeNode treeNode) {
        treeNode.left = leftRotate( treeNode.left );
        treeNode = rightRotate(treeNode);
        return treeNode;
    }

    public static TreeNode leftRotate(TreeNode treeNode) {
        TreeNode tmp = treeNode.right;
        treeNode.right = tmp.left;
        tmp.left=treeNode;
        treeNode.high=Math.max(getHight(treeNode.left),getHight(treeNode.right))+1;
        tmp.high =Math.max(getHight(tmp.left),getHight(tmp.right))+1;
        return tmp;
    }

    public static TreeNode rightThenLeftRotate(TreeNode treeNode) {
        treeNode.right = rightRotate(treeNode.right);
        treeNode = leftRotate(treeNode);
        return treeNode;
    }

    private static class TreeNode {
        TreeNode left;
        TreeNode right;
        int high;
        int value;

        public TreeNode(int value) {
            this.value = value;
        }
    }
}

 一棵m階B-樹，或爲空樹，或爲滿足下列特性的m叉樹：(m≥3)
    (1)根結點只有1個，關鍵字字數的範圍[1,m-1]，分支數量範圍[2,m]；
    (2)除根以外的非葉結點，每個結點包含分支數範圍[[m/2],m](m/2取上界) ，即關鍵字字數的範圍是
        [[m/2]-1,m-1]，其中[m/2]表示取大於m/2的最小整數；
    (3)非葉結點是由葉結點分裂而來的，所以葉結點關鍵字個數也滿足[[m/2]-1,m-1]；
    (4)所有的非終端結點包含信息：(n，P0，K1，P1，K2，P2，……，Kn，Pn)，
       其中Ki爲關鍵字，Pi爲指向子樹根結點的指針，並且Pi-1所指子樹中的關鍵字均小於Ki，而Pi所指的
       關鍵字均大於Ki（i=1，2，……，n），n+1表示B-樹的階，n表示關鍵字個數，即[ceil(m / 2)-1]<= 
        n <= m-1；
    (5)所有葉子結點都在同一層，並且指針域爲空，具有如下性質：

　　根據B-樹定義，第一層爲根有一個結點，至少兩個分支，第二層至少2個結點，i≥3時，每一層至少有2乘以
([m/2])的i-2次方個結點([m/2]表示取大於m/2的最小整數)。若m階樹中共有N個結點，那麼可以推導出N必然
滿足N≥2*(([m/2])的h-1次方)-1 (h≥1)，因此若查找成功，則高度h≤1+log[m/2](N+1)/2，h也是磁盤訪問次
數(h≥1)，保證了查找算法的高效率。
從以上的定義特性可總結出如下結論:對於m階B-樹
    1)樹中每個結點最多含有m個孩子（m>=2）；
    2)除根結點和葉子結點外，其它每個結點至少有[ceil(m / 2)]個孩子（其中ceil(x)是一個取上限的
        函數）；
    3)若根結點不是葉子結點，則至少有2個孩子（特殊情況：沒有孩子的根結點，即根結點爲葉子結點，整棵
        樹只有一個根節點）；
    4)所有葉子結點都出現在同一層，葉子結點不包含任何關鍵字信息(葉子節點只是沒有孩子和指向孩子的指
        針，這些節點也存在，也有元素）。
    5)每個非終端結點中包含有n個關鍵字信息： (n，P0，K1，P1，K2，P2，......，Kn，Pn)。其中：
       a)   Ki (i=1...n)爲關鍵字，且關鍵字按順序升序排序K(i-1)< Ki。
       b)   Pi爲指向子樹根的接點，且指針P(i-1)指向子樹種所有結點的關鍵字均小於Ki，
            但都大於K(i-1)。
       c)   關鍵字的個數n必須滿足： [ceil(m / 2)-1]<= n <= m-1。
    6)每個結點能包含的關鍵字的個數有一個上界和下界。這些界可以稱爲B-樹的相應結點的最小度數(內結點
        中結點最小孩子數目，即前面提到指針P的個數)的固定整數t>=2來表示
        a).每個非根結點必須至少有t-1個關鍵字，每個非根的內結點至少有t個子女,即。如果樹是非空的，
            則根結點至少包含一個關鍵字。
        b).每個結點可包含至多2t-1個關鍵字，每個非根的內結點至多可有2t個子女。如果一個結點是滿的，
            則它有2t-1個關鍵字.
        c).綜上根節點關鍵字的個數範圍: [1, 2*t - 1]，非根節點關鍵字的個數範圍: [t-1, 2*t - 1]

紅黑樹的特性:
（1）每個節點或者是黑色，或者是紅色。
（2）根節點是黑色。
（3）每個葉子節點（NIL）是黑色。 [注意：這裏葉子節點，是指爲空(NIL或NULL)的葉子節點！]
（4）如果一個節點是紅色的，則它的子節點必須是黑色的。
（5）從一個節點到該節點的子孫節點的所有路徑上包含相同數目的黑節點。

注意：
(01) 特性(3)中的葉子節點，是隻爲空(NIL或null)的節點。
(02) 特性(5)，確保沒有一條路徑會比其他路徑長出倆倍。因而，紅黑樹是相對是接近平衡的二叉樹。

定理：一棵含有n個節點的紅黑樹的高度至多爲2log(n+1).