財神娛樂首存即享優惠回饋唷~詳情請進👉

【數據布局】紅黑樹的完老虎機機率成

Talk is cheap,show me the code.

紅黑樹真是抄了很久才抄完,要是偶然間真應當從新寫一下。

#ifndef _RED_BLACK_TREE_HPP_
#define _RED_BLACK_TREE_HPP_

#include <iomanip>
#includ九牛娛樂e <iostream>
using namespace std;

enum RBTColor{RED,BLACK};

template <class T>
class RBTNode{
    public:
        RBTColor color;    // 顏色
        T key;            // 樞紐字(鍵值)
        RBTNode *left;    // 左孩子
        RBTNode *right;    // 右孩子
        RBTNode *parent; // 父結點

        RBTNode(T value,RBTColor c,RBTNode *p,RBTNode *l,RBTNode *r):
            key(value),color(c),parent(),left(l),right(r) {}
};

template <class T>
class RBTree {
    private:
        RBTNode<T> *mRoot;    // 根結點
    public:
        RBTree();
        ~RBTree();
        // 前序遍歷公眾紅黑樹"大眾
        void preOrder();
        // 中序遍歷"大眾紅黑樹公眾
        void inOrder();
        // 后序遍歷"大眾紅黑樹公眾
        void postOrder();
        // (遞回完成)查找"大眾紅黑樹公眾中鍵值為key的節點
        RBTNode<T>* search(T key);
        // 查找最小結點:返歸最小結點的鍵值。
        T minimum();
        // 查找最大結點:返歸最大結點的鍵值。
        T maximum();
        // 找結點(x)的后繼結點。即,查找"大眾紅黑樹中數據值大于該結點"大眾的"大眾最小結點公眾。
        RBTNode<T>* successor(RBTNode<T> *x);
        // 找結點(x)的先驅結點。即,查找公眾紅黑樹中數據值小于該結點"大眾的"大眾最大結點"大眾。
        RBTNode<T>* predecessor(RBTNode<T> *x);
        // 將結點(key為節點鍵值)拔出到紅黑樹中
        void insert(T key);
        // 刪除結點(key為節點鍵值)
        void remove(T key);
        // 燒毀紅黑樹
        void destroy();
        // 打印紅黑樹
        void print();
        //刪除小于h的節點
        void deleteLessThan(T h);
        //刪除大于h的節點
        void deleteLargerThan(T h);
        //刪除大于l小于h的節點
        void deleteBetween(T l,T h);
        int depth(T x)
        {
            int d =1;
            RBTNode<T>* t = mRoot;
            while(t!=NULL&&t->key!=x)
            {
                if(t->key>x)
                    t = t->left;
                else
                    t = t->right;
                d++;
            }
            if(t==NULL)
                return -1;
            else
                return d;
        }
    private:
        // 前序遍歷"大眾紅黑樹"大眾
        void preOrder(RBTNode<T>* tree) const;
        // 中序遍歷"大眾紅黑樹"大眾
        void inOrder(RBTNode<T>* tree) const;
        // 后序遍歷公眾紅黑樹"大眾
        void postOrder(RBTNode<T>* tree) const;
        // (遞回完成)查找"大眾紅黑樹x公眾中鍵值為key的節點
        RBTNode<T>* search(RBTNode<T>* x,T key) const;
        // (非遞回完成)查找公眾紅黑樹x"大眾中鍵值為key的節點
        RBTNode<T>* iterativeSearch(RBTNode<T>* x,T key) const;
        // 查找最小結點:返歸tree為根結點的紅黑樹的最小結點。
        RBTNode<T>* minimum(RBTNode<T>* tree);
        // 查找最大結點:返歸tree為根結點的紅黑樹的最大結點。
        RBTNode<T>* maximum(RBTNode<T>* tree);
        // 左旋
        void leftRotate(RBTNode<T>* &root,RBTNode<T>* x);
        // 右旋
        void rightRotate(RBTNode<T>* &root,RBTNode<T>* y);
        // 拔出函數
        void insert(RBTNode<T>* &root,RBTNode<T>* node);
        // 拔出批改函數
        void insertFixUp(RBTNode<T>* &root,RBTNode<T>* node);
        // 刪除函數
        void remove(RBTNode<T>* &root,RBTNode<T> *node);
        // 刪除批改函數
        void removeFixUp(RBTNode<T>* &root,RBTNode<T> *node,RBTNode<T> *parent);
        // 燒毀紅黑樹
        void destroy(RBTNode<T>* &tree);
        // 打印紅黑樹
        void print(RBTNode<T>* tree,T key,int direction);
        //
        void deleteBetween(RBTNode<T>* tree,T l,T h);
#define rb_parent(r)   ((r)->parent)
#define rb_color(r) ((r)->color)
#define rb_is_red(r)   ((r)->color==RED)
#define rb_is_black(r)  ((r)->color==BLACK)
#define rb_set_black(r)  do { (r)->color = BLACK; } while (0)
#define rb_set_red(r)  do { (r)->color六合彩規則 = RED; } while (0)
#define rb_set_parent(r,p)  do { (r)->parent = (p); } while (0)
#define rb_set_color(r,c)  do { (r)->color = (c); } while (0)
};
template<class T>
void RBTree<T>::deleteBetween(RBTNode<T>* tree,T h)
{
    if(tree ==NULL) return;
    if(tree->key<l){tree=tree->right;deleteBetween(tree,l,h);return;}
    if(tree->key>h){tree=tree->left;deleteBetween(tree,h);return;}
    remove(tree->key);
    deleteBetween(mRoot,h);
    return;
}
template<class T>
void RBTree<T>::deleteBetween(T l,T h)
{
    deleteBetween(mRoot,h);
}
template<class T>
void RBTree<T>::deleteLessThan(T h)
{
    T t;
    while((t=minimum())<h)
        remove(t);
}
template<class T>
void RBTree<T>::deleteLargerThan(T h)
{
    T t;
    while((t=maximum())>h)
        remove(t);
}
template <class T>
RBTree<T>::RBTree():mRoot(NULL)
{
    mRoot = NULL;
}
template <class T>
RBTree<T>::~RBTree()
{
    destroy();
}
template <class T>
void RBTree<T>::preOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        cout<< tree->key << "大眾 公眾 ;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

template <class T>
void RBTree<T>::preOrder()
{
    preOrder(mRoot);
}
template <class T>
void RBTree<T>::inOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        inOrder(tree->left);
        cout<< tree->key << 公眾 "大眾 ;
        inOrder(tree->right);
    }
}

template <class T>
void RBTree<T>::inOrder()
{
    inOrder(mRoot);
}
template <class T>
void RBTree<T>::postOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << "大眾 公眾 ;
    }
}
template <class T>
void RBTree<T>::postOrder()
{
    postOrder(mRoot);
}
template <class T>
RBTNode<T>* RBTree<T>::search(RBTNode<T>* x,T key) const
{
    if (x==NULL || x->key==key)
        return x;

    if (key < x->key)
        return search(x->left,key);
    else
        return search(x->right,key);
}

template <class T>
RBTNode<T>* RBTree<T>::search(T key)
{
    search(mRoot,key);
}
template <class T>
RBTNode<T>* RBTree<T>::minimum(RBTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}

template <class T>
T RBTree<T>::minimum()
{
    RBTNode<T> *p = minimum(mRoot);
    if (p != NULL)
        return p->key;
    return (T)NULL;
}
template <class T>
RBTNode<T>* RBTree<T>::maximum(RBTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}

template <class T>
T RBTree<T>::maximum()
{
    RBTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;

    return (T)NULL;
}

template <class T>
RBTNode<T>* RBTree<T>::successor(RBTNode<T> *x)
{
    // 若是x存在右孩子,則"大眾x的后繼結點公眾為 "大眾以其右孩子為根的子樹的最小結點"大眾。
    if (x->right != NULL)
        return minimum(x->right);

    // 若是x沒有右孩子。則x有如下兩種可能:
    // (01) x是"大眾一個左孩子公眾,則公眾x的后繼結點"大眾為 "大眾它的父結點"大眾。
    // (02) x是"大眾一個右孩子"大眾,則查找"大眾x的最低的父結點,而且該父結點要具備左孩子"大眾,找到的這個"大眾最低的父結點"大眾便是公眾x的后繼結點公眾。
    RBTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->right))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

template <class T>
RBTNode<T>* RBTree<T>::predecessor(RBTNode<T> *x)
{
    // 若是x存在左孩子,則"大眾x的先驅結點公眾為 "大眾以其左孩子為根的子樹的最大結點公眾。
    if (x->left != NULL)
        return maximum(x->left);

    // 若是x沒有左孩子。則x有如下兩種可能:
    // (01) x是公眾一個右孩子公眾,則"大眾x的先驅結點公眾為 "大眾它的父結點"大眾。
    // (01) x是"大眾一個左孩子"大眾,則查找"大眾x的最低的父結點,而且該父結點要具備右孩子"大眾,找到的這個"大眾最低的父結點公眾便是公眾x的先驅結點"大眾。
    RBTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->left))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

template <class T>
void RBTree<T>::leftRotate(RBTNode<T>* &root,RBTNode<T>* x)
{
    RBTNode<T> *y = x->right;
    x->right = y->left;
    if (y->left != NULL)
        y->left->parent = x;
    y->parent = x->parent;

    if (x->parent == NULL)
    {
        root = y;            // 若是 “x的父親” 是空節點,則將y設為根節點
    }
    else
    {
        if (x->parent->left == x)
            x->parent->left = y;    // 若是 x是它父節點的左孩子,則將y設為“x的父節點的左孩子”
        else
            x->parent->right = y;    // 若是 x是它父節點的左孩子,則將y設為“x的父節點的左孩子”
    }
    y->left = x;
    x->parent = y;
}
template <class T>
void RBTree<T>::rightRotate(RBTNode<T>* &root,RBTNode<T>* y)
{
    RBTNode<T> *x = y->left;

    // 將 “x的右孩子” 設為 “y的左孩子”;
    // 若是"大眾x的右孩子公眾不為空的話,將 “y” 設為 “x的右孩子的父親”
    y->left = x->right;
    if (x->right != NULL)
        x->right->parent = y;

    // 將 “y的父親” 設為 “x的父親”
    x->parent = y->parent;

    if (y->parent == NULL)
    {
        root = x;            // 若是 “y的父親” 是空節點,則將x設為根節點
    }
    else
    {
        if (y == y->parent->right)
            y->parent->right = x;    // 若是 y是它父節點的右孩子,則將x設為“y的父節點的右孩子”
        else
            y->parent->left = x;    // (y是它父節點的左孩子) 將x設為“x的父節點的左孩子”
    }

    // 將 “y” 設為 “x的右孩子”
    x->right = y;

    // 將 “y的父節點” 設為 “x”
    y->parent = x;
}

template <class T>
void RBTree<T>::insertFixUp(RBTNode<T>* &root,RBTNode<T>* node)
{
    RBTNode<T> *parent,*gparent;

    // 若“父節點存在,而且父節點的顏色是赤色”
    while ((parent = rb_parent(node)) && rb_is_red(parent))
    {
        gparent = rb_parent(parent);

        //若“父節點”是“祖父節點的左孩子”
        if (parent == gparent->left)
        {
            // Case 1前提:叔叔節點是赤色
            {
                RBTNode<T> *uncle = gparent->right;
                if (uncle && rb_is_red(uncle))
                {
                    rb_set_black(uncle);
                    rb_set_black(parent);
                    rb_set_red(gparent);
      玩運彩即時比分              node = gparent;
                    continue;
                }
            }
            // Case 2前提:叔叔是玄色,且當前節點是右孩子
            if (parent->right == node)
            {
                RBTNode<T> *tmp;
                leftRotate(root,parent);
                tmp = parent;
                parent = node;
                node = tmp;
            }

            // Case 3前提:叔叔是玄色,且當前節點是左孩子。
            rb_set_black(parent);
            rb_set_red(gparent);
            rightRotate(root,gparent);
        }
        else//若“z的父節點”是“z的祖父節點的右孩子”
        {
            // Case 1前提:叔叔節點是赤色
            {
                RBTNode<T> *uncle = gparent->left;
                if (uncle && rb_is_red(uncle))
                {
                    rb_set_black(uncle);
                    rb_set_black(parent);
                    rb_set_red(gparent);
                    node = gparent;
                    continue;
                }
            }
            // Case 2前提:叔叔是玄色,且當前節點是左孩子
            if (parent->left == node)
            {
                RBTNode<T> *tmp;
                rightRotate(root,parent);
                tmp = parent;
                parent = node;
                node = tmp;
            }

            // Case 3前提:叔叔是玄色,且當前節點是右孩子。
            rb_set_black(parent);
            rb_set_red(gparent);
            leftRotate(root,gparent);
        }
    }

    // 將根節點設為玄色
    rb_set_black(root);
}

template <class T>
void RBTree<T>::insert(RBTNode<T>* &root,RBTNode<T>* node)
{
    RBTNode<T> *y = NULL;
    RBTNode<T> *x = root;

    // 1. 將紅黑樹看成一顆二叉查找樹,將節點增添到二叉查找樹中。
    while (x != NULL)
    {
        y = x;
        if (node->key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    node->parent = y;
    if (y!=NULL)
    {
        if (node->key < y->key)
            y->left = node;
        else
            y->right = node;
    }
    else
        root = node;

    // 2. 配置節點的顏色為赤色
    node->color = RED;

    // 3. 將它從新批改為一顆二叉查找樹
    insertFixUp(root,node);
}

template <class T>
void RBTree<T>::insert(T key)
{
    RBTNode<T> *z=NULL;

    // 若是新建結點掉敗,則返歸。
    if ((z=new RBTNode<T>(key,BLACK,NULL,NULL)) == NULL)
        return ;

    insert(mRoot,z);
}

template <class T>
void RBTree<T>::removeFixUp(RBTNode<T>* &root,RBTNode<T> *parent)
{
    RBTNode<T> *other;

    while ((!node || rb_is_black(node)) && node != root)
    {
        if (parent->left == node)
        {
            other = parent->right;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是赤色的
                rb_set_black(other);
                rb_set_red(parent);
                leftRotate(root,parent);
                other = parent->right;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是玄色,且w的倆個孩子也都是玄色的
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->right || rb_is_black(other->right))
                {
                    // Case 3: x的兄弟w是玄色的,而且w的左孩子是赤色,右孩子為玄色。
                    rb_set_black(other->left);
                    rb_set_red(other);
                    rightRotate(root,other);
                    other = parent->right;
                }
                // Case 4: x的兄弟w是玄色的;而且w的右孩子是赤色的,左孩子恣意顏色。
                rb_set_color(other,rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->right);
                leftRotate(root,parent);
                node = root;
                break;
            }
        }
        else
        {
            other = parent->left;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是赤色的
                rb_set_black(other);
                rb_set_red(parent);
                rightRotate(root,parent);
                other = parent->left;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是玄色,且w的倆個孩子也都是玄色的
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->left || rb_is_black(other->left))
                {
                    // Case 3: x的兄弟w是玄色的,而且w的左孩子是赤色,右孩子為玄色。
                    rb_set_black(other->right);
                    rb_set_red(other);
                    leftRotate(root,other);
                    other = parent->left;
                }
                // Case 4: x的兄弟w是玄色的;而且w的右孩子是赤色的,左孩子恣意顏色。
                rb_set_color(other,rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->left);
                rightRotate(root,parent);
                node = root;
                break;
            }
        }
    }
    if (node)
        rb_set_black(node);
}

template <class T>
void RBTree<T>::remove(RBTNode<T>* &root,RBTNode<T> *node)
{
    RBTNode<T> *child,*parent;
    RBTColor color;

    // 被刪除節點的公眾擺布孩子都不為空"大眾的環境。
    if ( (node->left!=NULL) && (node->right!=NULL) )
    {
        // 被刪省點的后繼節點。(稱為"大眾庖代節點"大眾)
        // 用它來庖代"大眾被刪省點"大眾的地位,然后再將"大眾被刪省點"大眾往失。
        RBTNode<T> *replace = node;

        // 獵取后繼節點
        replace = replace->right;
        while (replace->left != NULL)
            replace = replace->left;

        // "大眾node節點公眾不是根節點(只有根節點不存在父節點)
        if (rb_parent(node))
        {
            if (rb_parent(node)->left == node)
                rb_parent(node)->left = replace;
            else
                rb_parent(node)->right = replace;
        }
        else
            // "大眾node節點"大眾是根節點,更新根節點。
            root = replace;

        // child是"大眾庖代節點公眾的右孩子,也是必要公眾調整的節點"大眾。
        // "大眾庖代節點"大眾一定不存在左孩子!由于它是一個后繼節點。
        child = replace->right;
        parent = rb_parent(replace);
        // 保管"大眾庖代節點公眾的顏色
        color = rb_color(replace);

        // 公眾被刪除節點"大眾是"大眾它的后繼節點的父節點"大眾
        if (parent == node)
        {
            parent = replace;
        }
        else
        {
            // child不為空
            if (child)
                rb_set_parent(child,parent);
            parent->left = child;

            replace->right = node->right;
            rb_set_parent(node->right,replace);
        }

        replace->parent = node->parent;
        replace->color = node->color;
        replace->left = node->left;
        node->left->parent = replace;

        if (color == BLACK)
            removeFixUp(root,child,parent);

        delete node;
        return 539計算公式;
    }

    if (node->left !=NULL)
        child = node->left;
    else
        child = node->right;

    parent = node->parent;
    // 保管公眾庖代節點"大眾的顏色
    color = node->color;

    if (child)
        child->parent = parent;

    // "大眾node節點公眾不是根節點
    if (parent)
    {
        if (parent->left == node)
            parent->left = child;
        else
            parent->right = child;
    }
    else
        root = child;

    if (color == BLACK)
        removeFixUp(root,parent);
    delete node;
}

template <class T>
void RBTree<T>::remove(T key)
{
    RBTNode<T> *node;
    // 查找key對應的節點(node),找到的話就刪除該節點
    if ((node = search(mRoot,key)) != NULL)
        remove(mRoot,node);
}

template <class T>
void RBTree<T>::destroy(RBTNode<T>* &tree)
{
    if (tree==NULL)
        return ;

    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);

    delete tree;
    tree=NULL;
}

template <class T>
void RBTree<T>::destroy()
{
    destroy(mRoot);
}

/*
 * 打印"大眾二叉查找樹"大眾
 *
 * key        -- 節點的鍵值
 * direction  --  0,透露表現該節點是根節點;
 *               -1,透露表現該節點是它的父結點的左孩子;
 *                1,透露表現該節點是它的父結點的右孩子。
 */
template <class T>
void RBTree<T>::print(RBTNode<T>* tree,int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根節點
            cout << setw(2) << tree->key << "大眾(B) is root"大眾 << endl;
        else                // tree是分支節點
            cout << setw(2) << tree->key <<  (rb_is_red(tree)?"大眾(R)"大眾:"大眾(B)公眾) << "大眾 is "大眾 << setw(2) << key << 公眾's 公眾  << setw(12) << (direction==1?公眾right child"大眾 : "大眾left child"大眾) << endl;

        print(tree->left,tree->key,-1);
        print(tree->right,1);
    }
}

template <class T>
void RBTree<T>::print()
{
    if (mRoot != NULL)
        print(mRoot,mRoot->key,0);
}

#endif

主函數

【免責聲明地下539坐車】本站內容轉載自互聯網,其相關談吐僅代表作者小我私家概念盡非權勢巨子,不代表本站態度。如您發明內容存在版權成績,請提交相關鏈接至郵箱:,咱們將實時予以處置。