PHP 二叉查找树

二叉查找树：简单点说就是颗做孩子小，右孩子大的树

说几个关键点

最小值：总是树的最左节点的key

最大值：总是树的最右节点的key

前趋：按照中序遍历的顺序，遍历输出时当前节点的前一个节点

        如果当前节点有左子节点，前驱就是当前节点的左边的最右节点，也可以认为是以当前节点的左孩子为根的树的最大值

        如果当前节点没有左子节点，前驱就是找到一个父节点，使得当前节点位于该父节点的右边，不明白的看代码

后继：按照中序遍历的顺序，遍历输出时当前节点的后一个节点

        如果当前节点有右子节点，后继就是当前节点的右边的最左节点，也可以认为是以当前节点的右孩子为根的树的最小值

        如果当前节点没有柚子节点，后继就是找到一个父节点，使得当前节点位于该父节点的左边

插入节点：插入节点的思想是从root开始用当前节点的key值比较待插入节点的key值，待插入key比当前节点key小，则当前节点变为当前节点左孩子，否则变为当前节点右孩子，继续比较key，直到当前节点为null(到达树底部)，记下比较完的最后一个叶子节点为P，如果P不为空，比较这个叶子节点和待插入节点的key，待插入节点小则作为这个叶子节点的左孩子，否则作为他的右孩子，如果P为空，说明这是一个空树，直接将待插入节点作为根返回即可

删除节点：删除节点分三种情况

1）如果待删除节点没有孩子，直接将节点删除即可。

2）如果待删除节点只有一个孩子，将待删除节点删除，并连接待删除节点的孩子和父亲，原来的左孩子还是作为其父节点的左孩子，原来的右孩子还是作为其父亲的右孩子

3）如果待删除节点有两个孩子，则找到待删除节点的直接后继，将后继删除（直接后继肯定只有一个子节点，要不然不可能是一个直接后继），然后按照2）连接后继的子节点和父节点，最后交换待删除节点和后继节点的key值

下面是代码和输出结果

<?php
    #二叉查找树实现
    #节点
    class Node {
        public $key = null;
        public $parent = null;
        public $left = null;
        public $right = null;
    }

    #查找操作
    function search($root, $k) {
        $cnode = $root;
        while ($cnode != null) {
            if ($cnode->key == $K) {
                return $cnode;
            } else if ($cnode->key > $k) {
                $cnode = $cnode->left;
            } else {
                $cnode = $cnode->right;
            }
        }

        return $cnode;
    }

    #查找最小关键字
    function search_minimum($root) {
        $cnode = $root;
        while ($cnode->left != null) {
            $cnode = $cnode->left;
        }
        return $cnode;
    }

    #查找最大关键字
    function search_maximum($root) {
        $cnode = $root;
        while ($cnode->right != null) {
            $cnode = $cnode->right;
        }
        return $cnode;
    }

    #查找中序遍历前驱节点
    function predecessor($x) {
        if ($x->left !== null) { #左子结点存在，直接返回左子结点的最右子节点
            return search_maximum($x->left);
        }   
        #否则查找其父节点，直到当前节点位于父节点的右边
        $p = $x->parent;
        while ($p !== null && $x == $p->left) { #如果x是p的左孩子，说明p是x的后继，我们需要找的是p是x的前驱
            $x = $p;
            $p = $p->parent;
        }        
        return $p;
    } 

    #查找中序遍历的后继结点
    function successor($x) {
        if ($x->right !== null) {
            return search_minimum($x->right);
        }
        $p = $x->parent;
        while ($p !== null && $x = $p->right) {
            $x = $p;
            $p = $p->parent;
        }

        return $p;
    }

    #插入结点
    function insert($root, $inode) {
        $cnode = $root;
        $pnode = null;
        while ($cnode !== null) { #为inode找到合适的插入位置
            $pnode = $cnode;
            if ($cnode->key > $inode->key) {
                $cnode = $cnode->left;
            } else {
                $cnode = $cnode->right;
            }
        }

        $inode->parent = $pnode;
        if ($pnode === null) { #pnode == null,说明是空树
            $root = $inode;
        } else {
            if ($pnode->key > $inode->key) {
                $pnode->left = $inode;
            } else {
                $pnode->right = $inode;
            }
        }
        // print_r($root);
        // echo "<br>";
    }

    #删除结点
    function delete($root, $dnode) {
        if ($dnode-> left === null || $dnode->right === null) { #如果待删除结点无子节点或只有一个子节点，则c = dnode
            $c = $dnode;
        } else { #如果待删除结点有两个子节点，c置为dnode的直接后继，以待最后将待删除结点的值换为其后继的值
            $c = successor($dnode);
        }

        if ($c->left !== null) {
            $s = $c->left;
        } else {
            $s = $c->right;
        }

        if ($s !== null) { #将c的子节点的父母结点置为c的父母结点，此处c只可能有1个子节点，因为如果c有两个子节点，则c不可能是dnode的直接后继
            $s->parent = $c->parent;
        }

        if ($c->parent === null) { #如果c的父母为空，说明c=dnode是根节点，删除根节点后直接将根节点置为根节点的子节点，此处dnode是根节点，且拥有两个子节点，则c是dnode的后继结点，c的父母就不会为空，就不会进入这个if
            $root = $s;
        } else if ($c == $c->parent->left) { #如果c是其父节点的左右子节点，则将c父母的左右子节点置为c的左右子节点
            $c->parent->left = $s;
        } else {
            $c->parent->right = $s;
        }

        #如果c!=dnode，说明c是dnode的后继结点，交换c和dnode的key值
        if ($c != $dnode) {
            $dnode->key = $c->key;
        }

        #返回根节点
        return $root;
    }

    #使用数组构造二叉查找树
    function build_iterative_tree($arr) {
        $root = new Node();
        $root->key = $arr[0];
        for ($i = 1; $i < count($arr); $i++) {
            $new_node = new Node();
            $new_node->key = $arr[$i];
            insert($root, $new_node);
        }
        return $root;
    }

    #二叉查找树中序遍历
    function inorder_traverse($root) {
        if ($root->left !== null) {
            inorder_traverse($root->left);
        }

        echo $root->key . " ";

        if ($root->right !== null) {
            inorder_traverse($root->right);
        }
    }

    $arr = array(55, 1, 5, 9, 3, 4, 2, 2, 7, 8, 8, 0, 1);
    $root = build_iterative_tree($arr);
    inorder_traverse($root);
    echo "<br>";
    echo search_maximum($root)->key;
    echo "<br>";
    echo search_minimum($root)->key;
    echo "<br>";
    $inode = new Node();
    $inode->key = 99;
    insert($root, $inode);
    inorder_traverse($root);
    echo "<br>";
    delete($root, $root);
    inorder_traverse($root);
    echo "<br>";
?>

0 1 1 2 2 3 4 5 7 8 8 9 55 

55
0
0 1 1 2 2 3 4 5 7 8 8 9 55 99 
0 1 1 2 2 3 4 5 7 8 8 9 99