AVL的实现

#include "stdafx.h"

/*
* @author Wu Jingan
* @created June 6, 2018
*/

#include <iostream>
#include <string>
#include <algorithm>
#include <ctime>
#include <Windows.h>
#include <vector>
using namespace std;

class Node
{
public:
    Node() {}
    Node(int value, Node *parent, Node *left, Node *right)
    {
        this->value = value;
        this->parent = parent;
        this->left = left;
        this->right = right;
    }

    Node operator=(const Node &_Right)
    {
        this->value = _Right.value;
        this->parent = _Right.parent;
        this->right = _Right.right;
        this->left = _Right.left;
        return *this;
    }

    bool isLeaf()
    {
        return this->left == nullptr && this->right == nullptr;
    }

    int value;
    Node *parent;
    Node *left;
    Node *right;
};

class AbstractBinarySearchTree
{
public:
    int getMinimumNodeValue()
    {
        return getMinimumNode(root)->value;
    }

    int getMaximumNodeValue()
    {
        return getMaximumNode(root)->value;
    }

    int getSize()
    {
        return this->size;
    }

    //若元素不存在, 返回1
    bool isContains(int element)
    {
        return search(element) == nullptr;
    }

    //先序遍历二叉搜索树
    void printtAbstractBinarySearchTreePreOrder(Node *root)
    {
        if (root == nullptr)
            return;
        cout << root->value << " ";
        printtAbstractBinarySearchTreePreOrder(root->left);
        printtAbstractBinarySearchTreePreOrder(root->right);
    }

    //中序遍历二叉搜索树
    void printtAbstractBinarySearchTreeInOrder(Node *root)
    {
        if (root == nullptr)
            return;
        printtAbstractBinarySearchTreeInOrder(root->left);
        cout << root->value << " ";
        printtAbstractBinarySearchTreeInOrder(root->right);
    }

    //后序遍历二叉搜索树
    void printtAbstractBinarySearchTreePostOrder(Node *root)
    {
        if (root == nullptr)
            return;
        printtAbstractBinarySearchTreePostOrder(root->left);
        printtAbstractBinarySearchTreePostOrder(root->right);
        cout << root->value << " ";
    }

    void printTree()
    {
        printSubtree(root);
    }

protected:
    Node * createNode(int value, Node *parent, Node *left, Node *right)
    {
        Node *node = new Node(value, parent, left, right);
        return node;
    }

    Node * deleteNode(int element)
    {
        Node *node = search(element);
        if (node != nullptr)
            return deleteNode(node);
        else
            return nullptr;
    }

    Node *search(int element)
    {
        Node *node = root;
        while (node != nullptr && node->value != element)
        {
            if (node->value < element)
                node = node->right;
            else
                node = node->left;
        }
        return node;
    }

    Node *insertNode(int element)
    {
        if (root == nullptr)
        {
            root = createNode(element, nullptr, nullptr, nullptr);
            size++;
            return root;
        }
        Node *insertParentNode = root;
        Node *searchTempNode = root;
        while (searchTempNode != nullptr)
        {
            insertParentNode = searchTempNode;
            if (element < searchTempNode->value)
                searchTempNode = searchTempNode->left;
            else if (element > searchTempNode->value)
                searchTempNode = searchTempNode->right;
            else
                return searchTempNode;
        }
        Node *NewNode = createNode(element, insertParentNode, nullptr, nullptr);
        if (insertParentNode->value > element)
            insertParentNode->left = NewNode;
        else
            insertParentNode->right = NewNode;
        size++;
        return NewNode;
    }

    Node * deleteNode(Node *deleteNode)
    {
        Node *nodeToReturn = nullptr;
        if (deleteNode != nullptr)
        {
            if (deleteNode->left == nullptr)
                nodeToReturn = transplantNode(deleteNode, deleteNode->right);
            else if (deleteNode->right == nullptr)
                nodeToReturn = transplantNode(deleteNode, deleteNode->left);
            else
            {
                Node *successorNode = getMinimumNode(deleteNode->right);
                if (successorNode->parent != deleteNode)
                {
                    transplantNode(successorNode, successorNode->right);
                    successorNode->right = deleteNode->right;
                    successorNode->right->parent = successorNode;
                }
                transplantNode(deleteNode, successorNode);
                successorNode->left = deleteNode->left;
                successorNode->left->parent = successorNode;
                nodeToReturn = successorNode;
            }
            size--;
            return nodeToReturn;
        }
        else
            return nullptr;
    }

    Node *transplantNode(Node *nodeToReplace, Node *newNode)
    {
        if (nodeToReplace->parent == nullptr)
            this->root = newNode;
        else if (nodeToReplace == nodeToReplace->parent->left)
            nodeToReplace->parent->left = newNode;
        else
            nodeToReplace->parent->right = newNode;
        if (newNode != nullptr)
            newNode->parent = nodeToReplace->parent;
        return newNode;
    }

    void printNodeValue(Node *node)
    {
        if (node == nullptr)
            cout << "<null>";
        else
            cout << node->value;
        cout << endl;
    }

    void printSubtree(Node *node)
    {
        if (node->right != nullptr) {
            printTree(node->right, true, "");
        }
        printNodeValue(node);
        if (node->left != nullptr) {
            printTree(node->left, false, "");
        }
    }

    void printTree(Node *node, bool isRight, string indent)
    {
        if (node->right != nullptr)
            printTree(node->right, true, indent + (isRight ? "        " : " |      "));
        cout << indent;
        if (isRight)
            cout << " /";
        else
            cout << " \";
        cout << "----- ";
        printNodeValue(node);
        if (node->left != nullptr)
            printTree(node->left, false, indent + (isRight ? " |      " : "        "));
    }

    Node *getMinimumNode(Node *node)
    {
        while (node->left != nullptr)
            node = node->left;
        return node;
    }

    Node *getMaximumNode(Node *node)
    {
        while (node->right != nullptr)
            node = node->right;
        return node;
    }

    Node *root = nullptr;
    int size;
};

class AbstractSelfBalancingBinarySearchTree :public AbstractBinarySearchTree
{
protected:
    Node * rotateLeft(Node *node)
    {
        Node *tempNode = node->right;
        tempNode->parent = node->parent;
        node->right = tempNode->left;
        if (node->right != nullptr)
            node->right->parent = node;
        tempNode->left = node;
        node->parent = tempNode;
        if (tempNode->parent != nullptr)
        {
            if (node == tempNode->parent->left)
                tempNode->parent->left = tempNode;
            else
                tempNode->parent->right = tempNode;
        }
        else
            root = tempNode;
        return tempNode;
    }

    Node *rotateRight(Node *node) 
    {
        Node * tempNode = node->left;
        tempNode->parent = node->parent;
        node->left = tempNode->right;
        if (node->left != nullptr)
            node->left->parent = node;

        tempNode->right = node;
        node->parent = tempNode;
        if (tempNode->parent != nullptr)
        {
            if (node == tempNode->parent->left)
                tempNode->parent->left = tempNode;
            else
                tempNode->parent->right = tempNode;
        }
        else
            root = tempNode;
        return tempNode;
    }
};

class AVLNode :public Node
{
public:
    AVLNode(int value, Node *parent, Node *left, Node *right)
    {
        Node(value, parent, left, right);
    }

    int height;
};

class AVLTree :public AbstractSelfBalancingBinarySearchTree
{
public:
    Node * insert(int element)
    {
        Node *newNode = this->insertNode(element);
        rebalance((AVLNode *)newNode);
        return newNode;
    }

    Node *deleteAVLNode(int element)
    {
        Node *delete_Node = AbstractSelfBalancingBinarySearchTree::search(element);
        if (delete_Node != nullptr)
        {
            Node *successorNode = AbstractSelfBalancingBinarySearchTree::deleteNode(delete_Node);
            if (successorNode != nullptr)
            {
                AVLNode *minimum = successorNode->right != nullptr ? (AVLNode *)getMinimumNode(successorNode->right) : (AVLNode *)successorNode;
                recomputeHeight(minimum);
                rebalance((AVLNode *)minimum);
            }
            else
            {
                recomputeHeight((AVLNode *)delete_Node->parent);
                rebalance((AVLNode *)delete_Node->parent);
            }
            return successorNode;
        }
        return nullptr;
    }

protected:
    Node * createNode(int value, Node *parent, Node *left, Node *right)
    {
        return new AVLNode(value, parent, left, right);
    }

    Node * doubleRotateRightLeft(Node *node)
    {
        node->right = avlRotateRight(node->right);
        return avlRotateLeft(node);
    }

    Node * doubleRotateLeftRight(Node *node)
    {
        node->left = avlRotateLeft(node->left);
        return avlRotateRight(node);
    }

private:
    void rebalance(AVLNode *node)
    {
        while (node != nullptr)
        {
            Node *parent = node->parent;

            int leftHeight = (node->left == nullptr) ? -1 : ((AVLNode *)node->left)->height;
            int rightHeight = (node->right == nullptr) ? -1 : ((AVLNode *)node->right)->height;
            int nodeBalance = leftHeight - rightHeight;
            if (nodeBalance == -2)
            {
                if (node->right->right != nullptr) 
                {
                    node = (AVLNode *)avlRotateLeft(node);
                    break;
                }
                else 
                {
                    node = (AVLNode *)doubleRotateRightLeft(node);
                    break;
                }
            }
            else if (nodeBalance == 2)
            {
                if (node->left->left != nullptr)
                {
                    node = (AVLNode *)avlRotateRight(node);
                    break;
                }
                else
                {
                    node = (AVLNode *)doubleRotateLeftRight(node);
                    break;
                }
            }
            else 
                updateHeight(node);
            node = (AVLNode*)parent;
        }

    }
    
    void recomputeHeight(AVLNode *node)
    {
        while (node != nullptr)
        {
            node->height = maxHeight((AVLNode *)node->left, (AVLNode *)node->right) + 1;
            node = (AVLNode *)node->parent;
        }
    }

    int maxHeight(AVLNode *_LeftNode, AVLNode *_RightNode)
    {
        if (_LeftNode != nullptr && _RightNode != nullptr)
            return _LeftNode->height > _RightNode->height ? _LeftNode->height : _RightNode->height;
        else if (_LeftNode == nullptr)
            return _RightNode != nullptr ? _RightNode->height : -1;
        else if (_RightNode == nullptr)
            return _LeftNode != nullptr ? _LeftNode->height : -1;
        return -1;
    }

    Node * avlRotateLeft(Node *node)
    {
        Node *temp = AbstractSelfBalancingBinarySearchTree::rotateLeft(node);
        updateHeight((AVLNode *)temp->left);
        updateHeight((AVLNode *)temp);
        return temp;
    }

    Node * avlRotateRight(Node *node) 
    {
        Node *temp = AbstractSelfBalancingBinarySearchTree::rotateRight(node);

        updateHeight((AVLNode *)temp->right);
        updateHeight((AVLNode *)temp);
        return temp;
    }

    void updateHeight(AVLNode *node)
    {
        int leftHeight = (node->left == nullptr) ? -1 : ((AVLNode *)node->left)->height;
        int rightHeight = (node->right == nullptr) ? -1 : ((AVLNode *)node->right)->height;
        node->height = max(leftHeight, rightHeight) + 1;
    }
};

//for test
class RandomArray
{
public:
    RandomArray() { }
    RandomArray(int maxValue, int maxSize)
    {
        this->maxValue = maxValue;
        this->maxSize = maxSize;
        this->randomVec = new vector<int>(rand() % maxSize + 5);
    }

    vector<int> *getRandomArray()
    {
        for (vector<int>::size_type i = 0; i < randomVec->size(); i++)
            (*randomVec)[i] = rand() % maxValue + 1;
        return randomVec;
    }

    int getSize()
    {
        return (int)randomVec->size();
    }

private:
    int maxValue;
    int maxSize;
    vector<int> *randomVec;
};

int main()
{
    srand((unsigned)time(NULL));
    RandomArray randomArray(100, 15);
    vector<int> *randomVec = randomArray.getRandomArray();
    AVLTree AVLtree;
    AVLNode *root = (AVLNode *)AVLtree.insert((*randomVec)[0]);
    cout << "the array for test is : " << (*randomVec)[0] << " ";
    for (int i = 1; i < randomArray.getSize(); i++)
    {
        cout << (*randomVec)[i] << " ";
        AVLtree.insert((*randomVec)[i]);
    }
    cout << endl;

    AVLtree.printTree();

    cout << "============================" << endl;

    int randomIndex = rand() % randomArray.getSize();
    cout << "the value of delete AVLnode is : " << (*randomVec)[randomIndex] << endl;
    AVLtree.deleteAVLNode((*randomVec)[randomIndex]);
    AVLtree.printTree();


    return 0;
}