區塊鏈智能合約solidity語言實現AVL樹的插入

智能交易區塊鏈solidity語言編寫二叉平衡搜索樹（AVL-tree）

此介紹部分轉自https://www.cnblogs.com/skywang12345/p/3577479.html
AVL 樹的難點在於四種旋轉，solidity的難點在於此語言不存在指針，只能用mappping和下標來充當指針的形式。這對於樹的創建增加了難度。

四種旋轉

(1) LL：LeftLeft，也稱爲”左左”。插入或刪除一個節點後，根節點的左子樹的左子樹還有非空子節點，導致”根的左子樹的高度”比”根的右子樹的高度”大2，導致AVL樹失去了平衡。

(2) LR：LeftRight，也稱爲”左右”。插入或刪除一個節點後，根節點的左子樹的右子樹還有非空子節點，導致”根的左子樹的高度”比”根的右子樹的高度”大2，導致AVL樹失去了平衡。

(3) RL：RightLeft，稱爲”右左”。插入或刪除一個節點後，根節點的右子樹的左子樹還有非空子節點，導致”根的右子樹的高度”比”根的左子樹的高度”大2，導致AVL樹失去了平衡。

(4) RR：RightRight，稱爲”右右”。插入或刪除一個節點後，根節點的右子樹的右子樹還有非空子節點，導致”根的右子樹的高度”比”根的左子樹的高度”大2，導致AVL樹失去了平衡。

LL 的旋轉

圖中左邊是旋轉之前的樹，右邊是旋轉之後的樹。從中可以發現，旋轉之後的樹又變成了AVL樹，而且該旋轉只需要一次即可完成。
對於LL旋轉，你可以這樣理解爲：LL旋轉是圍繞”失去平衡的AVL根節點”進行的，也就是節點k2；而且由於是LL情況，即左左情況，就用手抓着”左孩子，即k1”使勁搖。將k1變成根節點，k2變成k1的右子樹，”k1的右子樹”變成”k2的左子樹”。

RR的旋轉

圖中左邊是旋轉之前的樹，右邊是旋轉之後的樹。RR旋轉也只需要一次即可完成。

LR的旋轉

第一次旋轉是圍繞”k1”進行的”RR旋轉”，第二次是圍繞”k3”進行的”LL旋轉”。

RL的旋轉

第一次旋轉是圍繞”k3”進行的”LL旋轉”，第二次是圍繞”k1”進行的”RR旋轉”。

目前只需要考慮AVL樹插入的代碼，搜索代碼實現十分簡單

pragma solidity ^0.4.0;

contract test{
    struct node{
        uint key;
        uint left;
        uint right;
        uint height;
    }
    mapping(uint => node) nodes;
    uint root=0;

    function height(uint n)public returns (uint r){
        if(n == 0){
            return 0;
        }else{
            return nodes[n].height;
        }
    }

    function max(uint a,uint b)public returns(uint r){
        if(a > b)
        return a;
        else 
        return b;
    }

    function leftleftrotation(uint k2) public returns(uint r){
        uint k1;
        k1 = nodes[k2].left;
        nodes[k2].left = nodes[k1].right;
        nodes[k1].right = k2;

        nodes[k2].height = max(height(nodes[k2].left),height(nodes[k2].right))+1;
        nodes[k1].height = max(height(nodes[k1].left),height(nodes[k1].right))+1;
        return k1;
    }

    function rightrightrotation(uint k1)public returns(uint r){
        uint k2;
        k2 = nodes[k1].right;
        nodes[k1].right = nodes[k2].left;
        nodes[k2].left = k1;

        nodes[k1].height = max(height(nodes[k1].left),height(nodes[k1].right))+1;
        nodes[k2].height = max(height(nodes[k2].right),height(nodes[k2].left))+1;
        return k2;
    }

    function leftrightrotation(uint k3)public returns(uint r){
        nodes[k3].left = rightrightrotation(nodes[k3].left);
        return leftleftrotation(k3);
    }

    function rightleftrotation(uint k1)public returns(uint r){
        nodes[k1].right = leftleftrotation(nodes[k1].right);
        return rightrightrotation(k1);
    }


    function _insert(uint n,uint key)internal returns(uint r){
        if(n==0){
            n = key;
            nodes[n] = node(key,0,0,0);
        }
        else{
            if(key < nodes[n].key){
                nodes[n].left = _insert(nodes[n].left,key);

                if(height(nodes[n].left)-height(nodes[n].right)==2){
                    if(key < nodes[nodes[n].left].key){
                        n = leftleftrotation(n);
                    }else{
                        n = leftrightrotation(n);
                    }
                }

            }
            else if(key > nodes[n].key){
                nodes[n].right = _insert(nodes[n].right,key);

                if(height(nodes[n].right)-height(nodes[n].left)==2){
                    if(key > nodes[nodes[n].right].key){
                        n = rightrightrotation(n);
                    }else{
                        n = rightleftrotation(n);
                    }
                }
            }
        }
        nodes[n].height = max(height(nodes[n].left),height(nodes[n].right))+1;
        return n;
    }
    function insert(uint key)public returns(uint r){
        root = _insert(root,key);
        return root;
    }
    function insertlist(uint[] keys)public{
        for(uint i=0;i<keys.length;i++){
            root = _insert(root,keys[i]);
        }
    }
}