二叉树的元素基本操作与二叉树构建

二叉搜索树的优势：高效的查找数据，高效的插入，删除数据，动态维护数据。

二叉树：

1.每个节点的键值大于左孩子。

2.每个节点的键值小于右孩子。

3.以左右孩子为根的子树仍为二分搜索树。

4.二分搜索树不一定是一棵完全二叉树。

5.二分搜索树一般用Node结点结构体的存储方式。

 

二叉搜索树结点的结构体设计：

struct Node{
        Key key;
        Value value;
        Node *left;
        Node *right;

        Node(Key key, Value value){
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }

        Node(Node *node){
            this->key = node->key;
            this->value = node->value;
            this->left = node->left;
            this->right = node->right;
        }
    };

二叉搜索树的插入操作：

    Node* insert(Node *node, Key key, Value value){

        if( node == NULL ){
            count ++;
            return new Node(key, value);
        }

        if( key == node->key )
            node->value = value;
        else if( key < node->key )
            node->left = insert( node->left , key, value);
        else    // key > node->key
            node->right = insert( node->right, key, value);

        return node;
    }

检查树中是否包含某个元素：

bool contain(Node* node, Key key){

        if( node == NULL )
            return false;

        if( key == node->key )
            return true;
        else if( key < node->key )
            return contain( node->left , key );
        else // key > node->key
            return contain( node->right , key );
    }

查找操作：

// 在以node为根的二叉搜索树中查找key所对应的value
    Value* search(Node* node, Key key){

        if( node == NULL )
            return NULL;

        if( key == node->key )
            return &(node->value);
        else if( key < node->key )
            return search( node->left , key );
        else if( key > node->key )
            return search( node->right, key );
    }

销毁操作：

void destroy(Node* node){

        if( node != NULL ){
            destroy( node->left );
            destroy( node->right );
        }
        if (node==NULL){
            delete node;
            count --;
        }
    }

返回最小值：

// 在以node为根的二叉搜索树中,返回最小键值的节点
    Node* minimum(Node* node){
        if( node->left == NULL )
            return node;
        else
           return minimum(node->left);
    }

返回最大值：

// 在以node为根的二叉搜索树中,返回最大键值的节点
    Node* maximum(Node* node){
        if( node->right == NULL )
            return node;
        else
            return maximum(node->right);
    }

删除最小结点：

// 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    Node* removeMin(Node* node){

        if( node->left == NULL ){

            Node* rightNode = node->right;
            delete node;
            count --;
            return rightNode;
        }

        node->left = removeMin(node->left);
        return node;
    }

删除最大节点：

// 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    Node* removeMax(Node* node){

        if( node->right == NULL ){

            Node* leftNode = node->left;
            delete node;
            count --;
            return leftNode;
        }

        node->right = removeMax(node->right);
        return node;
    }

删除键值为key的结点：

// 删除掉以node为根的二分搜索树中键值为key的节点
    // 返回删除节点后新的二分搜索树的根
    Node* remove(Node* node, Key key){

        if( node == NULL )
            return NULL;

        if( key < node->key ){
            node->left = remove( node->left , key );
            return node;
        }
        else if( key > node->key ){
            node->right = remove( node->right, key );
            return node;
        }
        else{   // key == node->key

            if( node->left == NULL ){
                Node *rightNode = node->right;
                delete node;
                count --;
                return rightNode;
            }

            if( node->right == NULL ){
                Node *leftNode = node->left;
                delete node;
                count--;
                return leftNode;
            }

            // node->left != NULL && node->right != NULL
            Node *successor = new Node(minimum(node->right)); //找出其右子树中的最小值并用指针successor指向
            count ++;

            successor->right = removeMin(node->right); //将删除右子树中的最小结点的新的二叉树的根节点指针返回
            successor->left = node->left;

            delete node;
            count --;

            return successor;
        }
    }

二叉树的高度：

int height(Node* node){
    if (node==NULL)
        return 0;
    return 1+height(node->left)+height(node->right)
}

前序遍历：

// 对以node为根的二叉搜索树进行前序遍历
void preOrder(Node* node){

        if( node != NULL ){
            cout<<node->key<<endl;
            preOrder(node->left);
            preOrder(node->right);
        }
    }

中序遍历：

// 对以node为根的二叉搜索树进行中序遍历
    void inOrder(Node* node){

        if( node != NULL ){
            inOrder(node->left);
            cout<<node->key<<endl;
            inOrder(node->right);
        }
    }

后序遍历：

// 对以node为根的二叉搜索树进行后序遍历
    void postOrder(Node* node){

        if( node != NULL ){
            postOrder(node->left);
            postOrder(node->right);
            cout<<node->key<<endl;
        }
    }