紅黑樹（紅黑樹研究記錄-程式碼實現）

阿新 • • 發佈：2019-02-10

程式碼可以根據《紅黑樹研究記錄-例項》那篇文章的圖來驗證

main.cpp

#include <iostream.h>
#include "RBTree.h"

using namespace std;

int main(int argc, char *argv[])
{
    int arr[20] = {12, 1, 9, 2, 0, 11, 7, 19, 4, 15, 18, 5, 14, 13, 10, 16, 6, 3, 8, 17};
    RBTree *tree = new RBTree();
    for(int i = 0; i < 20; i++)
        tree 
->InsertNode(arr[i]);
    
    
    std::cout<<"PreOrder:"<<std::endl;
    tree->PreOrder();
    std::cout<<"InOrder:"<<std::endl;
    tree->InOrder();
    std::cout<<"PostOrder:"<<std::endl;
    tree->PostOrder();
    
    std::cout<<std::endl<<" 
Delete Node:"<<std::endl;
    cout<<"Delete 12:"<<endl;
    tree->DeleteNode(12);
    tree->PreOrder();
    cout<<"Delete 1:"<<endl;
    tree->DeleteNode(1);
    tree->PreOrder();
    cout<<"Delete 9:"<<endl;
    tree->DeleteNode(9);
    tree->PreOrder();
    cout 
<<"Delete 2:"<<endl;
    tree->DeleteNode(2);
    tree->PreOrder();    
    cout<<"Delete 0:"<<endl;
    tree->DeleteNode(0);
    tree->PreOrder();
    cout<<"Delete 11:"<<endl;
    tree->DeleteNode(11);
    tree->PreOrder();
    cout<<"Delete 7:"<<endl;
    tree->DeleteNode(7);
    tree->PreOrder();
    cout<<"Delete 19:"<<endl;
    tree->DeleteNode(19);
    tree->PreOrder();
    cout<<"Delete 4:"<<endl;
    tree->DeleteNode(4);
    tree->PreOrder();
    cout<<"Delete 15:"<<endl;
    tree->DeleteNode(15);
    tree->PreOrder();    
    cout<<"Delete 18:"<<endl;
    tree->DeleteNode(18);
    tree->PreOrder();
    cout<<"Delete 5:"<<endl;
    tree->DeleteNode(5);
    tree->PreOrder();
    cout<<"Delete 14:"<<endl;
    tree->DeleteNode(14);
    tree->PreOrder();
    cout<<"Delete 13:"<<endl;
    tree->DeleteNode(13);
    tree->PreOrder();
    cout<<"Delete 10:"<<endl;
    tree->DeleteNode(10);
    tree->PreOrder();    
    cout<<"Delete 6:"<<endl;
    tree->DeleteNode(6);
    tree->PreOrder();
    cout<<"Delete 16:"<<endl;
    tree->DeleteNode(16);
    tree->PreOrder();
    cout<<"Delete 3:"<<endl;
    tree->DeleteNode(3);
    tree->PreOrder();
    cout<<"Delete 8:"<<endl;
    tree->DeleteNode(8);
    tree->PreOrder();
    cout<<"Delete 17:"<<endl;
    tree->DeleteNode(17);
    tree->PreOrder();
    return  0;
}

RBTree.h

#ifndef _RBTREE_HEADER_
#define _RBTREE_HEADER_

#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>

enum NodeColor{
    RED,
    BLACK
};

struct RBNode
{
    int value;
    NodeColor color;
    RBNode *pParent;
    RBNode *pLeft;
    RBNode *pRight;
};

class RBTree
{
public:
    RBTree();
    ~RBTree();
    
    int InsertNode(int);
    int DeleteNode(int);
    RBNode *FindNode(int value);
    
    void PreOrder();
    void InOrder();
    void PostOrder();
private:
    void DeleteAll();
    void TurnLeft(RBNode *pNode);
    void TurnRight(RBNode *pNode);
    int DeleteNode(RBNode *);
    RBNode *GetSuccessor(RBNode *);
    int InsertNode(RBNode *);
    void DeleteFixup(RBNode *);
    void InsertFixup(RBNode *);
private:
    RBNode *m_root;
};

#endif

RBTree.cpp

#include "RBTree.h"
#include <deque>
#include <queue>

using namespace std;

RBTree::RBTree()
{
    m_root = NULL;
}

RBTree::~RBTree()
{
    DeleteAll();
}

void RBTree::TurnLeft(RBNode *pNode)
{
    if(!pNode || !pNode->pParent)
        return;
    RBNode *pp = pNode->pParent->pParent;
    if(pp)
        if(pp->pLeft == pNode->pParent)
            pp->pLeft = pNode;
        else
            pp->pRight = pNode;
    pNode->pParent->pParent = pNode;
    pNode->pParent->pRight = pNode->pLeft;
    if(pNode->pLeft)
        pNode->pLeft->pParent = pNode->pParent;
    pNode->pLeft = pNode->pParent;    
    pNode->pParent = pp;    
}

void RBTree::TurnRight(RBNode *pNode)
{
    if(!pNode || !pNode->pParent)
        return;
    RBNode *pp = pNode->pParent->pParent;
    if(pp)
        if(pp->pLeft == pNode->pParent)
            pp->pLeft = pNode;
        else
            pp->pRight = pNode;
    pNode->pParent->pParent = pNode;
    pNode->pParent->pLeft = pNode->pRight;
    if(pNode->pRight)
        pNode->pRight->pParent = pNode->pParent;
    pNode->pRight = pNode->pParent;    
    pNode->pParent = pp;
}

void RBTree::DeleteAll()
{
    if(!m_root)
        std::cout<<"The tree is null"<<std::endl;
    queue<RBNode*> qu;
    qu.push(m_root);
    while(qu.size() > 0)
    {
        RBNode *pCur = qu.front();
        qu.pop();
        std::cout<<"Delete:"<<pCur->value<<"("<<pCur->color<<"), "<<std::endl;
        if(pCur->pLeft)
            qu.push(pCur->pLeft);
        if(pCur->pRight)
            qu.push(pCur->pRight);
        delete pCur;
        pCur = NULL;
    }
}

int RBTree::InsertNode(int value)
{
    if(FindNode(value))
        return -1;
    RBNode *pNew = new RBNode();
    pNew->value = value;
    pNew->pParent = NULL;
    pNew->color = RED;
    pNew->pLeft = NULL;
    pNew->pRight = NULL;
    
    return InsertNode(pNew);
}

int RBTree::InsertNode(RBNode* pNode)
{
    if(!pNode)
        return -1;
    if(!m_root)
    {
        m_root = pNode;
        m_root->color = BLACK;
        return 0;
    }
    RBNode *tmp = m_root;
    RBNode *tmpParent = NULL;
    while(tmp)
    {
        tmpParent = tmp;
        if(tmp->value > pNode->value)
            tmp = tmp->pLeft;
        else
            tmp = tmp->pRight;
    }
    if(tmpParent->value > pNode->value)
        tmpParent->pLeft = pNode;
    else
        tmpParent->pRight = pNode;
    pNode->pParent = tmpParent;
    
    InsertFixup(pNode);
}

void RBTree::InsertFixup(RBNode *pNode)
{
    if(!pNode)
        return;
    RBNode *pUncle = NULL;
    while(pNode->pParent && pNode->pParent->color == RED)
    {
        if(pNode->pParent == pNode->pParent->pParent->pLeft)
        {
            pUncle = pNode->pParent->pParent->pRight;
            if(pUncle && pUncle->color == RED)            //case 1
            {
                pNode->pParent->color = BLACK;
                pUncle->color = BLACK;
                pNode->pParent->pParent->color = RED;
                pNode = pNode->pParent->pParent;
            }
            else
            {
                if(pNode == pNode->pParent->pRight)        //case 2
                {
                    TurnLeft(pNode);
                    pNode = pNode->pLeft;
                }
                pNode->pParent->color = BLACK;            //case 3
                pNode->pParent->pParent->color = RED;
                TurnRight(pNode->pParent);
                if(!pNode->pParent->pParent)
                    m_root = pNode->pParent;
            }
        }
        else
        {
            pUncle = pNode->pParent->pParent->pLeft;
            if(pUncle && pUncle->color == RED)                    //case 1
            {
                pNode->pParent->color = BLACK;
                pUncle->color = BLACK;
                pNode->pParent->pParent->color = RED;
                pNode = pNode->pParent->pParent;
            }
            else
            {
                if(pNode == pNode->pParent->pLeft)        //case 2
                {
                    TurnRight(pNode);
                    pNode = pNode->pRight;
                }
                pNode->pParent->color = BLACK;            //case 3
                pNode->pParent->pParent->color = RED;
                TurnLeft(pNode->pParent);
                if(!pNode->pParent->pParent)
                    m_root = pNode->pParent;
            }
        }
    }
    m_root->color = BLACK;
}

int RBTree::DeleteNode(int value)
{
    RBNode *pNode = NULL;
    if(!(pNode = FindNode(value)))
        return -1;
    return DeleteNode(pNode);
}

RBNode *RBTree::GetSuccessor(RBNode *pNode)
{
    RBNode *pThis = pNode->pRight;
    while(pThis->pLeft)
        pThis = pThis->pLeft;
    return pThis;
}

int RBTree::DeleteNode(RBNode *pNode)
{
    if(!pNode)
        return -1;
    RBNode *pDel = NULL;
    RBNode *pThis = NULL;
    //search the Node
    if(!pNode->pLeft && !pNode->pRight)
    {
        pThis = pNode;
        pDel = pNode;
    }
    else if(!pNode->pLeft || !pNode->pRight)
        pDel = pNode;
    else
        pDel = GetSuccessor(pNode);
    
    //delete the Node
    if(pDel->pLeft)
        pThis = pDel->pLeft;
    else if(pDel->pRight)
        pThis = pDel->pRight;
    else
        pThis = pDel;
    
    if(pThis != pDel)
    {
        pThis->pParent = pDel->pParent;
        
        if(!pDel->pParent)
            m_root = pThis;
        else if(pDel == pDel->pParent->pLeft)
            pDel->pParent->pLeft = pThis;
        else
            pDel->pParent->pRight = pThis;
    }
    if(pDel != pNode)
        pNode->value = pDel->value;
    if(pDel->color == BLACK)
        DeleteFixup(pThis);
        
    if(pThis == pDel)
        if(pDel == pDel->pParent->pLeft)
            pDel->pParent->pLeft = NULL;
        else
            pDel->pParent->pRight = NULL;
    if(pDel == m_root)
        m_root = NULL;
    delete pDel;
    pDel = NULL;
}

void RBTree::DeleteFixup(RBNode *pNode)
{
    RBNode *pBrother = NULL;
    while(pNode != m_root && pNode->color == BLACK)
    {
        if(pNode == pNode->pParent->pLeft)
        {
            pBrother = pNode->pParent->pRight;
            if(pBrother->color == RED)        //case 1
            {
                pBrother->color = BLACK;
                pNode->pParent->color = RED;
                TurnLeft(pBrother);
                pBrother = pNode->pParent->pRight;    
            }
            if((!pBrother->pLeft || pBrother->pLeft->color == BLACK) 
                && (!pBrother->pRight || pBrother->pRight->color == BLACK))        //case 2
            {
                pBrother->color = RED;
                pNode = pNode->pParent;
            }
            else
            {
                if(!pBrother->pRight || pBrother->pRight->color == BLACK)        //case 3
                {
                    pBrother->pLeft->color = BLACK;
                    pBrother->color = RED;
                    TurnRight(pBrother->pLeft);
                    pBrother = pNode->pParent->pRight;
                }
                pBrother->color = pNode->pParent->color;    //case 4
                pNode->pParent->color = BLACK;
                pBrother->pRight->color = BLACK;
                TurnLeft(pBrother);
                pNode = m_root;
            }
        }
        else
        {
            pBrother = pNode->pParent->pLeft;
            if(pBrother->color == RED)        //case 1
            {
                pBrother->color = BLACK;
                pNode->pParent->color = RED;
                TurnRight(pBrother);
                pBrother = pNode->pParent->pLeft;
            }
            if((!pBrother->pLeft || pBrother->pLeft->color == BLACK) 
                && (!pBrother->pRight || pBrother->pRight->color == BLACK))    //case 2
            {
                pBrother->color = RED;
                pNode = pNode->pParent;
            }
            else
            {
                if(!pBrother->pLeft || pBrother->pLeft->color == BLACK)        //case 3
                {
                    pBrother->pRight->color = BLACK;
                    pBrother->color = RED;
                    TurnLeft(pBrother->pRight);
                    pBrother = pNode->pParent->pLeft;
                }
                pBrother->color = pNode->pParent->color;
                pNode->pParent->color = BLACK;
                pBrother->pLeft->color = BLACK;
                TurnRight(pBrother);
                pNode = m_root;
            }
        }
    }
    pNode->color = BLACK;
}

RBNode *RBTree::FindNode(int value)
{
    if(!m_root)
        return NULL;
    RBNode *tmp = m_root;
    while(tmp)
    {
        if(value > tmp->value)
            tmp = tmp->pRight;
        else if(value < tmp->value)
            tmp = tmp->pLeft;
        else
            break;
    }
    return tmp;
}

void RBTree::PreOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    queue<RBNode*> qu;
    qu.push(m_root);
    while(qu.size() > 0)
    {
        RBNode *pCur = qu.front();
        qu.pop();
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        if(pCur->pLeft)
            qu.push(pCur->pLeft);
        if(pCur->pRight)
            qu.push(pCur->pRight);
    }
    std::cout<<std::endl;
}

void RBTree::InOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    
    deque<RBNode*> de;
    RBNode *pCur = m_root;
    bool bPush = false;
    
    while(pCur)
    {
        if(pCur->pLeft && !bPush)
        {
            de.push_back(pCur);
            pCur = pCur->pLeft;
            continue;
        }
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        
        if(pCur->pRight)
        {
            pCur = pCur->pRight;
            bPush = false;
        }
        else
        {
            if(de.size() == 0)
                break;
            pCur = de.back();
            de.pop_back();
            bPush = true;
        }
    }
    std::cout<<std::endl;
}

void RBTree::PostOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    deque<RBNode*> de;
    int flag = 0;
    RBNode *pCur = m_root;
    while(pCur)
    {
        if(pCur->pLeft && flag < 1)
        {
            de.push_back(pCur);
            pCur = pCur->pLeft;
            continue;
        }
        if(pCur->pRight && flag < 2)
        {
            de.push_back(pCur);
            pCur = pCur->pRight;
            flag = 0;
            continue;
        }
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        
        if(de.size() == 0)
            break;
        RBNode *pParent = de.back();
        de.pop_back();
        
        if(pCur == pParent->pLeft)
        {
            flag = 1;
            pCur = pParent;
        }
        else if(pCur == pParent->pRight)
        {
            flag = 2;
            pCur = pParent;
        }
    }
    std::cout<<

紅黑樹（紅黑樹研究記錄-程式碼實現）

程式碼可以根據《紅黑樹研究記錄-例項》那篇文章的圖來驗證 main.cpp #include <iostream.h> #include "RBTree.h" using namespace std; int main(int argc, char *a

APP利用token機制進行身份認證（理解token機制+簡單Java程式碼實現）

什麼是token token的意思是令牌，想象一下用過的qq令牌，是來自（騰訊）服務端生成的一串字元，作為客戶端（我們自己）進行請求的一個標識。比如說：改qq密碼。而這裡我們是自己開發App，我們的使用者用token請求登入，我們對他進行身份認證。當用戶第一

【演算法】紅黑樹（二叉樹）概念與查詢（一）

誒，演算法這個東西，其實沒那麼簡單，但是也沒那麼難。紅黑樹，其實已經有很多大佬都整理過了，而且文章部落格都寫得超好，我寫這篇文章的目的是：自己整理一次，這些知識才是自己的，否則永遠是別人的~ 該系列到現在暫只有3篇文章：【演算法】紅黑樹（二叉樹）概念與查詢（一）：h

紅黑樹Red-Black tree初步詳解（Java程式碼實現）

紅黑樹Red-Blacktree初步詳解本部落格的參考資料：演算法導論 http://blog.csdn.net/v_july_v/article/details/6105630 http://www.cnblogs.com/skywang12345/p/3624343

【演算法】手撕紅黑樹（上）—— 基本性質以及插入實現（附帶程式碼實現）

在閱讀其他博主關於紅黑樹增刪實現的時候，博主們大多直接使用文字圖片描述，對整個增刪整體的流程突出的不太明顯（當然dalao們寫得還是很棒得，不然我也寫不出這篇文章），所以我特意花了2天時間用CAD製作了一張插入操作的流程圖和一張刪除操作的流程圖（刪除見下篇）並手撕程式碼（好吧，其實大部分時間在除錯程式碼，畢

新手算法學習之路----二叉樹（二叉樹的路徑和）

== style oid 添加 roo span 一個 int 二叉題目：給定一個二叉樹，找出所有路徑中各節點相加總和等於給定目標值的路徑。一個有效的路徑，指的是從根節點到葉節點的路徑。代碼加思路： public List<List<Intege

刷題總結——二逼平衡樹（bzoj3224線段樹套splay）

++ output 數列 turn 表示 roo string 修改和我題目： Description 您需要寫一種數據結構（可參考題目標題），來維護一個有序數列，其中需要提供以下操作：1.查詢k在區間內的排名2.查詢區間內排名為k的值3.修改某一位值上的數值4.查詢

208 Implement Trie (Prefix Tree) 字典樹（前綴樹）

tar ref ems clas next 字典樹 ted imp arc 實現一個 Trie (前綴樹)，包含 insert, search, 和 startsWith 這三個方法。註意:你可以假設所有的輸入都是小寫字母 a-z。詳見：https://leetcode.c

AVL樹（自平衡樹）——c++實現

html pub private 檢查具體實現 htm lose show data- AVL樹是高度平衡的而二叉樹。它的特點是：AVL樹中任何節點的兩個子樹的高度最大差別為1。 AVL樹本質上還是一棵二叉搜索樹，它的特點是： 1.本身首先是一棵二叉

劍指Offer 61. 序列化二叉樹（二叉樹）

題目描述請實現兩個函式，分別用來序列化和反序列化二叉樹題目地址 https://www.nowcoder.com/practice/cf7e25aa97c04cc1a68c8f040e71fb84?tpId=13&tqId=11214&rp=3&ru=/ta/coding-inte

劍指Offer 59. 按之字形順序列印二叉樹（二叉樹）

題目描述請實現一個函式按照之字形列印二叉樹，即第一行按照從左到右的順序列印，第二層按照從右至左的順序列印，第三行按照從左到右的順序列印，其他行以此類推。題目地址 https://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?tpId=

51nod 1443 路徑和樹（最短路樹）

題目連結：路徑和樹題意：給定無向帶權連通圖，求從u開始邊權和最小的最短路樹，輸出最小邊權和。題解：構造出最短路樹，把存留下來的邊權全部加起來。（跑dijkstra的時候鬆弛加上$ < $變成$ <= $，因為之後跑到該頂點說明是傳遞下來的，該情況邊權和最小。）以樣例作說明：第一次從頂點

二叉樹（建立，遍歷，求深度）

#include <stdio.h> #include <stdlib.h> typedef struct node { char data; struct node *lchild,*rchild; }BSTree; void Initiate(BSTr

字典樹（判斷有指定字首的單詞個數）

#include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define maxn 500005 int ch[maxn

ml課程：決策樹、隨機森林、GBDT、XGBoost相關（含程式碼實現）

以下是我的學習筆記，以及總結，如有錯誤之處請不吝賜教。基礎概念：熵Entropy：是衡量純度的一個標準,表示式可以寫為：資訊增益Information Gain：熵變化的一個量，表示式可以寫為：資訊增益率Gain Ratio：資訊增益的變化率，表示式可以寫為：

Bailian 2808 校門外的樹（入門線段樹）

題目連結：http://bailian.openjudge.cn/practice/2808?lang=en_US 總時間限制: 1000ms 記憶體限制: 65536kB 描述某校大門外長

哈夫曼樹詳細講解（帶例題和C語言程式碼實現——全註釋）

** 哈夫曼樹詳細講解（帶例題和C語言程式碼實現——全註釋） ** 定義哈夫曼樹又稱最優二叉樹，是一種帶權路徑長度最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點的權值乘上其到根結點的路徑長度（若根結點為0層，葉結點到根結點的路徑長度為葉結點

字尾樹系列二:線性時間內構建字尾樹（包含程式碼實現）

　　上一篇文章已經介紹了字尾樹的前前後後的知識，並且採用各種技巧逼近線性時間了，至於具體怎麼操作大家看完之後應該多多少少有點想法了。而之所以將本文跟上一篇文章分開，主要考慮有三：第一，和在一起文章就會太長了，看的頭疼。第二，理論跟實現本來就有差異，本文中一些

hdu1754I Hate It解題報告---線段樹（單點替換 & 區間最值）

I Hate I

Leetcode 951：翻轉等價二叉樹（超詳細的解法！！！）

我們可以為二叉樹 T 定義一個翻轉操作，如下所示：選擇任意節點，然後交換它的左子樹和右子樹。只要經過一定次數的翻轉操作後，能使 X 等於 Y，我們就稱二叉樹 X 翻轉等價於二叉樹 Y。編寫一個判斷兩個二叉樹是否是翻轉等價的函式。這些樹由根節點 root1 和 root2 給出

紅黑樹（紅黑樹研究記錄-程式碼實現）

相關推薦