编程练习——伸展树(SplayTree)

最新推荐文章于 2021-10-21 16:51:42 发布

帐前卒

最新推荐文章于 2021-10-21 16:51:42 发布

阅读量1.4k

点赞数

分类专栏： c/c++ 数据结构&amp;算法文章标签：编程 null 数据结构 delete apache insert

本文链接：https://blog.youkuaiyun.com/cctt_1/article/details/3013225

版权

c/c++ 同时被 2 个专栏收录

76 篇文章

订阅专栏

数据结构&算法

39 篇文章

订阅专栏

本文详细介绍了伸展树(Splay Tree)的数据结构及其操作方法，包括插入、删除和查找等核心功能，并通过具体的代码实现展示了伸展树的工作原理。此外，还探讨了伸展树适用的应用场景及其实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

  伸展树用于查询结果的概率非平均情况，即起初假设某些要查询的信息偏多，有些信息几乎无人问津。对于平均访问概率来说，使用SplayTree实现并不是一个明智的选择。 

  可能会用到此数据结构的程序：词典或者多维搜索树，还有连接/切除树（link/cut tree）（这个树是用于网络优化问题包括最大流和最小代价） 

 
 /*
* create by chico chen
* date: 2008/10/02
*/
template<class T>
class SplayTree:public BinaryTree<T>
{
public:
    explicit SplayTree(T& data):BinaryTree(data)
    {
    
    }
    explicit SplayTree(TreeNode<T>* root):BinaryTree(root)
    {
    }
    ~SplayTree()
    {
        
    }
public:
    void insertNode(T& data)
    {
        
        if(NULL == this->head)
        {
            this->head = new TreeNode<T>(data);
            return;
        }
        
        splay(this->head,data);
        if(this->head->data > data)
        {
            //     A     B                 A 
            //            / /     ->         / / 
            //         C   D             C   B 
            //                                / 
            //                                 D 
            TreeNode<T>* node = new TreeNode<T>(data);
            node->left = this->head->left ;
            node->right = this->head;
            this->head->left = NULL;
            this->head = node;
        }
        else if(this->head->data < data)
        {
            //     A     B                 A 
            //            / /     ->         / / 
            //         C   D             B   D 
            //                              /      
            //                            C         
            TreeNode<T>* node = new TreeNode<T>(data);
            node->right = this->head->right;
            node->left = this->head;
            this->head->right = NULL;
            this->head = node;
        }
        else
        {
            // insert the same key 
            // throw exception 
            throw "the same key";
        }
    }
    // use the data as key to splay the tree 
    // then we can get the structures of the tree like the following: 
    //     (1)  A             (2)   A 
    //              /                    / / 
    //               B               C   B 
    // the difference between the two structures is whether the root has left child 
    // In case (1), we can simpliy make the root right child instead the root. 
    // In case (2), we should splay the root left subtree and then it will be  
    // changed like case (1), and we make the splayed left subtree root instead   
    // the root. 
    void deleteNode(T& data)
    {
        
        if(NULL == this->head)
        {
            return;
        }
        splay(this->head, data);
        if(this->head->data != data)
        {
            // not found the key to delete 
            return;
        }
        TreeNode<T>* newRoot;
        if(NULL == this->head->left)
        {
            newRoot = this->head->right;
        }
        else
        {
            newRoot = this->head->left;
            splay(newRoot,data);
            newRoot->right = this->head->right;
        }
        delete this->head;
        this->head = newRoot;
    }
    
    TreeNode<T>* searchNode(T& data)
    {
        if(NULL == this->head)
        {
            return NULL;
        }
        splay(this->head, data);
        if(this->head->data == data)
        {
            return this->head;
        }
        return NULL;
    }
private:
    // use top-down splay method, 
  
    // you should make the suitable final step  
    // according to the situation, such as "insert", "delete", "search". 
    // And what's the top-down method? 
    // now we should add LeftMaxRoot as L and RightMinRoot as R 
    // 1. L  A  R         2. L  A  R        3. L   A   R 
    //         /                        /                      / 
    //        B                     B                     B 
    //                               /                          / 
    //                              C                          C 
    //  
    // 1.->L  B  R      2.->L  C   R        3.L   C    R 
    //        /                     /                          /      /       
    //     A                    B                         B    A 
    //                             /  
    //                              A 
    // but in case 3. we can simplified case 3 rotate as 
    // 3. L   B      R 
    //            /      / 
    //            C  A 
    // and we must integrate the LeftMaxRoot and RightMinRoot together, 
    // then we have final step to do this. And L is left tree, and R is right tree. 
    // L     A     R               A        
    //         / /         ->         /   / 
    //       B   C                L     R 
    //                                 /   / 
    //                                B C 
    void splay(TreeNode<T>* &subRoot,T& data)
    {
        if(NULL == subRoot)
        {
            return;
        }
        TreeNode<T>* leftRoot;
        TreeNode<T>* rightRoot;
        // here some code use static member, if you promise you have sync-control 
        // or you don't use this code in thread or process, you could choose static 
        // member to accelerate your program. 
        // It means the following code is thread-safe. 
        TreeNode<T> head(data); 
        leftRoot = rightRoot = &head;
        while(true)
        {
            if(data < subRoot->data)
            {
                if(NULL == subRoot->left)
                {
                    break;
                }
                else if(data < subRoot->left->data)
                {
                    // Left rotate 
                    TreeNode<T>* tempLeft = subRoot->left;
                    subRoot->left = tempLeft->right;
                    tempLeft->right = subRoot;
                    subRoot = tempLeft;
                }
                else
                {
                    // do nothing 
                }
                // split the tree with right root 
                if(NULL == subRoot->left)
                    break;
                rightRoot->left = subRoot;
                rightRoot = subRoot;
                subRoot = subRoot->left ;
            }
            else if(data > subRoot->data)
            {
                if(NULL == subRoot->right)
                {
                    // need not to rotate 
                    break;
                }
                else if(data > subRoot->right->data)
                {
                    // right rotate 
                    TreeNode<T>* tempRight = subRoot->right;
                    subRoot->right = tempRight->left;
                    tempRight->left = subRoot;
                    subRoot = tempRight;
                }
                else
                {
                    // do nothing 
                }
                // split the tree by left root 
                if(NULL == subRoot->right)
                    break;
                leftRoot->right = subRoot;
                leftRoot = subRoot;
                subRoot = subRoot->right;
            }
            else
            {
                // the same key 
                break;
            }
        }
        // the final step  
        // we have find the last node, ant then we should  
        // integrate the left root, the right root and the root into One tree. 
        // head.right is left root 
        // head.left is right root 
        leftRoot->right = subRoot->left;
        rightRoot->left = subRoot->right;
        subRoot->left = head.right;
        subRoot->right = head.left;
    
        
    }
};
 