程序博客网 > xshell mac

算法导论中红黑树的C++实现

来源：互联网 发布：xshell mac 编辑：程序博客网 时间：2024/04/29 13:26

1、头文件 RBTree.h

  1. #ifndef RBTREE__JOHN__DMRC
  2. #define RBTREE__JOHN__DMRC
  3. /********************   Class Node   **********************/
  4. template <typename T>
  5. class Node{
  6. public:
  7.     Node() : red(false), exist(false), left(NULL), right(NULL), parent(NULL){}
  8.     Node(T &t) : data(t), red(true), exist(true), left(NULL), right(NULL), parent(NULL){}
  9.     //function
  10.     // max & min
  11.     Node<T>* maximum();
  12.     Node<T>* minimum();
  13.     // successor & predecessor
  14.     Node<T>* successor();
  15.     Node<T>* predecessor();
  16.     // exist
  17.     bool isExist() { return this ->exist; }
  18.     bool isNULL() { return !this ->exist; }
  19.     // red & black ( black = 0 & red = 1 )
  20.     bool getColor() { return this ->red; }
  21.     bool isRed(){ return this ->red; }
  22.     bool isBlack() { return !this ->red; }
  23.     void setColor(bool c) { this ->red = c; }
  24.     void setRed() { this ->red = true; }
  25.     void setBlack() { this ->red = false; }
  26.     //varables
  27.     T data;
  28.     bool red;
  29.     bool exist;
  30.     Node<T>* left;
  31.     Node<T>* right;
  32.     Node<T>* parent;
  33. };
  35. /********************   Class RBTree   ********************/
  36. template <typename T, typename E>
  37. class RBTree{
  38. public:
  39.     RBTree() : root(NULL){}
  40.     ~RBTree();
  41.     bool Insert(T &);
  42.     bool Delete(T &, E);
  43.     // debug
  44.     T get_head(){ return root ->data;}
  45. private:
  46.     // delete_tree;
  47.     void delete_tree(Node<T>*);
  48.     // delete a node;
  49.     bool delete_node(T&, Node<T>*);
  50.     // rotates
  51.     void left_rotate(Node<T>*);
  52.     void right_rotate(Node<T>*);
  53.     // fixups
  54.     void insert_fixup(Node<T>*);
  55.     void delete_fixup(Node<T>*);
  56.     Node<T>* root;
  57. };
  59. #endif

2、实现 RBTree.cpp

  1. #include "RBTree.h"
  2. /********************   Class Node   **********************/
  3. template <typename T>
  4. Node<T>* Node<T>::maximum(){
  5.     Node<T>* x = this;
  6.     while(x ->right ->isExist())
  7.         x = x ->right;
  8.     return x;
  9. }
  11. template <typename T>
  12. Node<T>* Node<T>::minimum(){
  13.     Node<T>* x = this;
  14.     while(x ->left ->isExist())
  15.         x = x ->left;
  16.     return x;
  17. }
  19. template <typename T>
  20. Node<T>* Node<T>::successor(){
  21.     Node<T>* y;
  22.     Node<T>* x;
  23.     if(this ->right ->isExist())
  24.         return this ->right ->minimum();
  25.     x = this;
  26.     y = x ->parent;
  27.     while(y != NULL && x == y ->right){
  28.         x = y;
  29.         y = x ->parent;
  30.     }
  31.     return y;
  32. }
  34. template <typename T>
  35. Node<T>* Node<T>::predecessor(){
  36.     Node<T>* y;
  37.     Node<T>* x;
  38.     if(this ->left ->isExist())
  39.         return this ->left ->maximum();
  40.     x = this;
  41.     y = x ->parent;
  42.     while(y != NULL && x == y ->left){
  43.         x = y;
  44.         y = x ->parent;
  45.     }
  46.     return y;
  47. }
  48. /*******************   Class RBTree   *********************/
  49. template <typename T, typename E>
  50. RBTree<T, E>::~RBTree(){
  51.     this ->delete_tree(this ->root);
  52. }
  54. template <typename T, typename E>
  55. void RBTree<T, E>::delete_tree(Node<T>* p){
  56.     if(p){
  57.         if(p ->left)
  58.             this ->delete_tree(p ->left);
  59.         if(p ->right)
  60.             this ->delete_tree(p ->right);
  61.         delete p;
  62.     }
  63. }
  65. // Insert & fixup
  66. template <typename T, typename E>
  67. bool RBTree<T, E>::Insert(T &t){
  68.     if(this ->root == NULL || this ->root ->isNULL()){
  69.         if(this ->root)
  70.             delete this ->root;
  71.         this ->root = new Node<T>(t);
  72.         this ->root ->left = new Node<T>();
  73.         this ->root ->left ->parent = this ->root;
  74.         this ->root ->right = new Node<T>();
  75.         this ->root ->right ->parent = this ->root;
  76.         this ->root ->setBlack();
  77.         return true;
  78.     }
  79.     Node<T>* p = this ->root;
  80.     while(1){
  81.         if(t == p ->data)
  82.             return false;
  83.         if(t < p ->data){
  84.             if(p ->left ->isNULL()){
  85.                 delete p ->left;
  86.                 p ->left = new Node<T>(t);
  87.                 p ->left ->parent = p;
  88.                 p ->left ->left = new Node<T>();
  89.                 p ->left ->left ->parent = p ->left;
  90.                 p ->left ->right = new Node<T>();
  91.                 p ->left ->right ->parent = p ->left;
  92.                 this ->insert_fixup(p ->left);
  93.                 return true;
  94.             }
  95.             else
  96.                 p = p ->left;
  97.         }
  98.         else{
  99.             if(p ->right ->isNULL()){
  100.                 delete p ->right;
  101.                 p ->right = new Node<T>(t);
  102.                 p ->right ->parent = p;
  103.                 p ->right ->left = new Node<T>();
  104.                 p ->right ->left ->parent = p ->left;
  105.                 p ->right ->right = new Node<T>();
  106.                 p ->right ->right ->parent = p ->left;
  107.                 this ->insert_fixup(p ->right);
  108.                 return true;
  109.             }
  110.             else
  111.                 p = p ->right;
  112.         }
  113.     }
  114.     return false;
  115. }
  117. template <typename T, typename E>
  118. void RBTree<T, E>::insert_fixup(Node<T>* z){
  119.     Node<T>* y;
  121.     while(z ->parent && z ->parent ->isRed()){
  122.         if(z ->parent == z ->parent ->parent ->left){
  123.             y = z ->parent ->parent ->right;
  124.             if(y ->isRed()){
  125.                 //case 1
  126.                 z ->parent ->setBlack();
  127.                 y ->setBlack();
  128.                 z ->parent ->parent ->setRed();
  129.                 z = z ->parent ->parent;
  130.             }
  131.             else{ 
  132.                 if(z == z ->parent ->right){
  133.                     // case 2 ( fall through to case 3 )
  134.                     z = z ->parent;
  135.                     this ->left_rotate(z);
  136.                 }
  137.                 // case 3
  138.                 z ->parent ->setBlack();
  139.                 z ->parent ->parent ->setRed();
  140.                 this ->right_rotate(z ->parent ->parent);
  141.             }
  142.         }
  143.         else{
  144.             y = z ->parent ->parent ->left;
  145.             if(y ->isRed()){
  146.                 // case 4
  147.                 z ->parent ->setBlack();
  148.                 y ->setBlack();
  149.                 z ->parent ->parent ->setRed();
  150.                 z = z ->parent ->parent;
  151.             }
  152.             else{ 
  153.                 if(z == z ->parent ->left){
  154.                     // case 5 ( fall through to case 6 )
  155.                     z = z ->parent;
  156.                     this ->right_rotate(z);
  157.                 }
  158.                 // case 6
  159.                 z ->parent ->setBlack();
  160.                 z ->parent ->parent ->setRed();
  161.                 this ->left_rotate(z ->parent ->parent);
  162.             }
  163.         }
  164.     }
  165.     this ->root ->setBlack();
  166. }
  167. // delete & fixup
  168. template <typename T, typename E>
  169. bool RBTree<T, E>::Delete(T &t, E e){
  170.     Node<T>* p = this ->root;
  171.     while(p ->isExist()){
  172.         if(p ->data == e)
  173.             return this ->delete_node(t, p);
  174.         else if(e < p ->data)
  175.             p = p ->left;
  176.         else
  177.             p = p ->right;
  178.     }
  179.     return false;
  180. }
  182. template <typename T, typename E>
  183. bool RBTree<T, E>::delete_node(T& t, Node<T>* z){
  184.     Node<T>* y;
  185.     Node<T>* x;
  187.     if(z ->left ->isNULL() || z ->right ->isNULL())
  188.         y = z;
  189.     else
  190.         y = z ->successor();
  191.     if(y ->left ->isExist()){
  192.         x = y ->left;
  193.         if(y ->right ->isNULL())
  194.             delete y ->right;
  195.     }
  196.     else{
  197.         x = y ->right;
  198.         if(y ->left ->isNULL())
  199.             delete y ->left;
  200.     }
  201.     x ->parent = y ->parent;
  202.     if(y ->parent == NULL)
  203.         this ->root = x;
  204.     else if(y == y ->parent ->left)
  205.         y ->parent ->left = x;
  206.     else
  207.         y ->parent ->right = x;
  208.     if(y != z){
  209.         T temp = z ->data;
  210.         z ->data = y ->data;
  211.         y ->data = temp;
  212.     }
  213.     if(y ->isBlack())
  214.         this ->delete_fixup(x);
  215.     t = y ->data;
  217.     delete y;
  219.     return true;
  220. }
  222. template <typename T, typename E>
  223. void RBTree<T, E>::delete_fixup(Node<T>* x){
  224.     Node<T>* w;
  225.     while(x != this ->root && x ->isBlack()){
  226.         if(x == x ->parent ->left){
  227.             w = x ->parent ->right;
  228.             if(w ->isRed()){
  229.                 // case 1 ( fall through )
  230.                 w ->setBlack();
  231.                 x ->parent ->setRed();
  232.                 this ->left_rotate(x ->parent);
  233.                 w = x ->parent ->right;
  234.             }
  235.             if(w ->left ->isBlack() && w ->right ->isBlack()){
  236.                 // case 2 ( new circle with x's value changed )
  237.                 w ->setRed();
  238.                 x = x ->parent;
  239.             }
  240.             else{
  241.                 if(w ->right ->isBlack()){
  242.                     // case 3 ( fall through to case 4 )
  243.                     w ->left ->setBlack();
  244.                     w ->setRed();
  245.                     this ->right_rotate(w);
  246.                     w = x ->parent ->right;
  247.                 }
  248.                 // case 4 ( exit the while with x = root )
  249.                 w ->setColor(x ->parent ->getColor());
  250.                 x ->parent ->setBlack();
  251.                 w ->right ->setBlack();
  252.                 this ->left_rotate(x ->parent);
  253.                 x = this ->root;
  254.             }
  255.         }
  256.         else{
  257.             w = x ->parent ->left;
  258.             if(w ->isRed()){
  259.                 // case 5 ( fall through )
  260.                 w ->setBlack();
  261.                 x ->parent ->setRed();
  262.                 this ->right_rotate(x ->parent);
  263.                 w = x ->parent ->left;
  264.             }
  265.             if(w ->left ->isBlack() && w ->right ->isBlack()){
  266.                 // case 6 ( new circle with x's value changed )
  267.                 w ->setRed();
  268.                 x = x ->parent;
  269.             }
  270.             else{ 
  271.                 if(w ->left ->isBlack()){
  272.                     // case 7 ( fall through to case 8 )
  273.                     w ->right ->setBlack();
  274.                     w ->setRed();
  275.                     this ->left_rotate(w);
  276.                     w = x ->parent ->left;
  277.                 }
  278.                 // case 8 ( exit the while with x = root)
  279.                 w ->setColor(x ->parent ->getColor());
  280.                 x ->parent ->setBlack();
  281.                 w ->left ->setBlack();
  282.                 this ->right_rotate(x ->parent);
  283.                 x = this ->root;
  284.             }
  285.         }
  286.     }
  287.     x ->setBlack();
  288. }
  290. // rotate
  291. template <typename T, typename E>
  292. void RBTree<T, E>::left_rotate(Node<T>* x){
  293.     Node<T>* y = x ->right;
  294.     // set beta
  295.     x ->right = y ->left;
  296.     if(y ->left)
  297.         y ->left ->parent = x;
  298.     // set parent
  299.     y ->parent = x ->parent;
  300.     if(x ->parent == NULL)
  301.         this ->root = y;
  302.     else{
  303.         if(x == x ->parent ->left)
  304.             x ->parent ->left = y;
  305.         else
  306.             x ->parent ->right = y;
  307.     }
  308.     // set relation
  309.     y ->left = x;
  310.     x ->parent = y;
  311. }
  313. template <typename T, typename E>
  314. void RBTree<T, E>::right_rotate(Node<T>* x){
  315.     Node<T>* y = x ->left;
  316.     // set beta
  317.     x ->left = y ->right;
  318.     if(y ->right)
  319.         y ->right ->parent = x;
  320.     // set parent
  321.     y ->parent = x ->parent;
  322.     if(x ->parent == NULL)
  323.         this ->root = y;
  324.     else{
  325.         if(x == x ->parent ->left)
  326.             x ->parent ->left = y;
  327.         else
  328.             x ->parent ->right = y;
  329.     }
  330.     // set relation
  331.     y ->right = x;
  332.     x ->parent = y;
  333. }

 

3、简单的应用 main.cpp

 

  1. #include <iostream>
  2. #include <string>
  4. template<typename T, typename E> class RBTree;
  6. using namespace std;
  8. int main(void){
  9.     RBTree<int, int> s;
  10.     int i, a[10] = { 1, 2, 3, 4, 6, 8, 0, 7, 5, 9};
  11.     for(i = 0; i < 10; i ++){
  12.         s.Insert(a[i]);
  13.         cout << s.get_head() << endl;
  14.     }
  15.     return 0;
  17. }
xshell mac xshell mac
原创粉丝点击
热门IT博客
免费名片设计软件下载免费名片设计软件下载
淘宝官网东西是真的吗淘宝官网东西是真的吗
python 微秒时间戳
淘宝网 支付宝的功能
室内广告机软件
八字喜忌查询软件
怎么查看淘宝账号违规
python pyswip
淘宝女模特图片和名字
数据库置疑什么意思
ps4怎么查看网络
txt看书软件
域名未授权破解
winner知乎
数据采集与处理
网络图片侵权案例
如何传软件
淘宝网上的衣服能买吗
网页flash抓取器 mac
unity3d 不火了
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 自体隆胸价钱 隆胸对比图 做隆胸要多少钱 隆胸修复术 硅胶隆胸的价格 颈霜可以擦脸吗 汉臣氏益生菌 汉臣氏 汉臣氏益生菌粉四联菌 汉臣氏益生菌多少钱 汉臣氏dha怎么样 汉臣氏米粉怎么样 汉臣氏招聘 汉臣氏乳钙胶囊 汉臣氏dha多少钱一盒 潮臣氏月饼 汉臣氏益生菌粉 丰融园二手房 丰裕口旅游攻略 丰裕口 丰裕妇女 丰裕妇女tx 裕丰英伦 裕丰家具 丰谷老窖青花瓷 吾谷丰登 丰谷1700白酒价格 诸暨谷丰东城府 丰谷浓香型白酒价格 丰谷酒业地址 丰谷酒图片 丰谷酒价格 丰谷酒怎么样 丰谷酒报价 丰谷酒网站 丰谷酒王多少钱 丰谷酒38度 丰谷酒皇 丰谷酒王15年 52度丰谷酒王 十年丰谷酒王

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里