二叉查找树实现-双向链表

标签：

////二叉查找树，为了实现方便，给每个节点添加了一个指向父节点的指针
#include<iostream>
#include<vector>
#include<ctime>
#include<cstdlib>

using namespace std;

template<class T>
class BinarySearchTree
{
    private:
        struct Node
        {
            T data;
            int deep;
            Node *left;
            Node *right;
            Node *prev;
            Node(T val,int deep)
            {
                data = val;
                deep = 0;
                left = NULL;
                right = NULL;
                prev = NULL;
            }

            private:
            Node()
            {
            }
        };
        Node *root;
        int size;

    public:
        BinarySearchTree()
        {
            root = NULL;
            size = 0;
        }
        ~BinarySearchTree()
        {
            clear(root);
            root = NULL;
            size = 0;
        }
        T min(Node *node) const
        {
            if(node->left == NULL)
                return node->data;
            else
                return min(node->left);
        }
        T max(Node *node) const
        {
            if(node->right == NULL)
                return node->data;
            else
                return max(node->right);
        }

        Node *insert(Node *& node,T val)
        {
            if(size == 0 && node == NULL)
            {
                root = new Node(val,0);
                root->prev = NULL;
                size++;
                return root;
            }
            if(size != 0 && node == NULL)
            {
                cout<<"ERROR\n";
                return NULL;
            }
            if(val > node->data)
            {
                if(node->right != NULL)
                    return insert(node->right,val);
                else
                {
                    Node *tmp = new Node(val,node->deep+1);
                    tmp->prev = node;
                    node->right = tmp;
                    size++;
                    return tmp;
                }    
            }
            else if(val < node->data)
            {
                if(node->left != NULL)
                    return insert(node->left,val);
                else
                {
                    Node *tmp = new Node(val,node->deep+1);
                    tmp->prev = node;
                    node->left = tmp;
                    size ++;
                    return tmp;
                }
            }
            else if(val == node->data)
            {
            }
        }

        bool contain(Node *node,T val) const
        {
            if(node == NULL)
                return false;

            if(val > node->data)
                return contain(node->right,val);
            else if(val < node->data)
                return contain(node->left,val);
            else
                return true;
        }
        void removeNode(Node *node)
        {
            if(node->left == NULL && node->right == NULL)
            {
                if(node->prev->left == node)
                    node->prev->left = NULL;
                else
                    node->prev->right = NULL;

                delete node;
                size--;
            }
            else if(node->left == NULL)
            {
                node->right->prev = node->prev;
                if(node->prev->left == node)
                    node->prev->left = node->right;
                else
                    node->prev->right = node->right;

                decDeep(node->right);
                delete node;
                size--;
            }
            else if(node->right == NULL)
            {
                node->left->prev = node->prev;
                if(node->prev->left == node)
                    node->prev->left = node->left;
                else
                    node->prev->right = node->left;

                decDeep(node->left);
                delete node;
                size--;
            }
            else
            {
                Node *p = node->right;
                while(p->left != NULL)
                {
                    p=p->left;
                }
                node->data = p->data;
                if(p->right != NULL)
                {
                    p->prev->left = p->right;
                    p->right->prev = p->prev;
                    decDeep(p->right);
                    delete p;
                    size--;
                }
                else
                {
                    p->prev->left = NULL;
                    delete p;
                    size--;
                }
            }
        }
        void decDeep(Node *node)
        {
            node->deep--;
            if(node->left != NULL)
                decDeep(node->left);
            if(node->right != NULL)
                decDeep(node->right);
        }
        void remove(T val)
        {
            Node * p=root;
            while(1)
            {
                if(val > p->data)
                    p = p->right;
                else if(val < p->data)
                    p = p->left;
                else if(val == p->data)
                {
                    
                    removeNode(p);
                    return;
                }
            }
        }
        void clear(Node*node)
        {
            if(node->left != NULL)
                clear(node->left);
            if(node->right != NULL)
                clear(node->right);

            delete node;
            node = NULL;
        }
        void print(Node *node)
        {
            if(node == NULL)
                return;
            cout<<node->data<< " ";
            if(node->left != NULL)
                print(node->left);
            if(node->right != NULL)
                print(node->right);
        }
        void insert(T val)
        {
            insert(root,val);
        }
        void print()
        {
            print(root);
            cout<<"\n";
        }
};

int main()
{
    BinarySearchTree<int> tree;
    tree.insert(10);
    tree.insert(1);
    tree.insert(11);
    tree.insert(9);
    tree.insert(8);
    tree.print();
    cout<<"\n\n";
    tree.remove(9);
    tree.print();

    return 0;
}

二叉查找树实现-双向链表

标签：

原文地址：http://www.cnblogs.com/jkred369/p/4616283.html