红黑树C实现

最新推荐文章于 2023-01-19 10:29:05 发布
最新推荐文章于 2023-01-19 10:29:05 发布
阅读量772 收藏 1
点赞数
分类专栏： 数据结构和算法 文章标签： c callback null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adcxf/article/details/2774707
版权
  1. // red-black tree
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <stdarg.h>
  7. #include <time.h>
  8. //
  9. // supplied by user //
  10. //
  12. typedef int KeyType;            // type of key
  14. typedef struct {                // value related to key
  15.     int stuff;
  16. } ValType;
  18. // how to compare keys
  19. #define compLT(a,b) (a < b)
  20. #define compEQ(a,b) (a == b)
  22. /
  23. // implementation independent code //
  24. /
  26. typedef enum {
  27.     RBT_STATUS_OK,
  28.     RBT_STATUS_MEM_EXHAUSTED,
  29.     RBT_STATUS_DUPLICATE_KEY,
  30.     RBT_STATUS_KEY_NOT_FOUND
  31. } RbtStatus;
  33. typedef enum { BLACK, RED } nodeColor;
  35. typedef struct NodeTag {
  36.     struct NodeTag *left;       // left child
  37.     struct NodeTag *right;      // right child
  38.     struct NodeTag *parent;     // parent
  39.     nodeColor color;            // node color (BLACK, RED)
  40.     KeyType key;                // key used for searching
  41.     ValType val;                // data related to key
  42. } NodeType;
  44. #define SENTINEL &sentinel      // all leafs are sentinels(哨兵)
  45. static NodeType sentinel = { SENTINEL, SENTINEL, 0, BLACK, 0};
  47. static NodeType *root = SENTINEL; // root of red-black tree
  49. static void rotateLeft(NodeType *x) {
  51.     // rotate node x to left
  53.     NodeType *y = x->right;
  55.     // establish x->right link
  56.     x->right = y->left;
  57.     if (y->left != SENTINEL) y->left->parent = x;
  59.     // establish y->parent link
  60.     if (y != SENTINEL) y->parent = x->parent;
  61.     if (x->parent) {
  62.         if (x == x->parent->left)
  63.             x->parent->left = y;
  64.         else
  65.             x->parent->right = y;
  66.     } else {
  67.         root = y;
  68.     }
  70.     // link x and y
  71.     y->left = x;
  72.     if (x != SENTINEL) x->parent = y;
  73. }
  75. static void rotateRight(NodeType *x) {
  77.     // rotate node x to right
  79.     NodeType *y = x->left;
  81.     // establish x->left link
  82.     x->left = y->right;
  83.     if (y->right != SENTINEL) y->right->parent = x;
  85.     // establish y->parent link
  86.     if (y != SENTINEL) y->parent = x->parent;
  87.     if (x->parent) {
  88.         if (x == x->parent->right)
  89.             x->parent->right = y;
  90.         else
  91.             x->parent->left = y;
  92.     } else {
  93.         root = y;
  94.     }
  96.     // link x and y
  97.     y->right = x;
  98.     if (x != SENTINEL) x->parent = y;
  99. }
  101. static void insertFixup(NodeType *x) {
  103.     // maintain red-black tree balance
  104.     // after inserting node x
  106.     // check red-black properties
  107.     while (x != root && x->parent->color == RED) {
  108.         // we have a violation
  109.         if (x->parent == x->parent->parent->left) {
  110.             NodeType *y = x->parent->parent->right;
  111.             if (y->color == RED) {
  113.                 // uncle is RED
  114.                 x->parent->color = BLACK;
  115.                 y->color = BLACK;
  116.                 x->parent->parent->color = RED;
  117.                 x = x->parent->parent;
  118.             } else {
  120.                 // uncle is BLACK
  121.                 if (x == x->parent->right) {
  122.                     // make x a left child
  123.                     x = x->parent;
  124.                     rotateLeft(x);
  125.                 }
  127.                 // recolor and rotate
  128.                 x->parent->color = BLACK;
  129.                 x->parent->parent->color = RED;
  130.                 rotateRight(x->parent->parent);
  131.             }
  132.         } else {
  134.             // mirror image of above code
  135.             NodeType *y = x->parent->parent->left;
  136.             if (y->color == RED) {
  138.                 // uncle is RED
  139.                 x->parent->color = BLACK;
  140.                 y->color = BLACK;
  141.                 x->parent->parent->color = RED;
  142.                 x = x->parent->parent;
  143.             } else {
  145.                 // uncle is BLACK
  146.                 if (x == x->parent->left) {
  147.                     x = x->parent;
  148.                     rotateRight(x);
  149.                 }
  150.                 x->parent->color = BLACK;
  151.                 x->parent->parent->color = RED;
  152.                 rotateLeft(x->parent->parent);
  153.             }
  154.         }
  155.     }
  156.     root->color = BLACK;
  157. }
  159. // insert new node (no duplicates allowed)
  160. RbtStatus rbtInsert(KeyType key, ValType val) {
  161.     NodeType *current, *parent, *x;
  163.     // allocate node for data and insert in tree
  165.     // find future parent
  166.     current = root;
  167.     parent = 0;
  168.     while (current != SENTINEL) {
  169.         if (compEQ(key, current->key)) 
  170.             return RBT_STATUS_DUPLICATE_KEY;
  171.         parent = current;
  172.         current = compLT(key, current->key) ?
  173.             current->left : current->right;
  174.     }
  176.     // setup new node
  177.     if ((x = malloc (sizeof(*x))) == 0)
  178.         return RBT_STATUS_MEM_EXHAUSTED;
  179.     x->parent = parent;
  180.     x->left = SENTINEL;
  181.     x->right = SENTINEL;
  182.     x->color = RED;
  183.     x->key = key;
  184.     x->val = val;
  186.     // insert node in tree
  187.     if(parent) {
  188.         if(compLT(key, parent->key))
  189.             parent->left = x;
  190.         else
  191.             parent->right = x;
  192.     } else {
  193.         root = x;
  194.     }
  196.     insertFixup(x);
  198.     return RBT_STATUS_OK;
  199. }
  201. static void deleteFixup(NodeType *x) {
  203.     // maintain red-black tree balance
  204.     // after deleting node x
  206.     while (x != root && x->color == BLACK) {
  207.         if (x == x->parent->left) {
  208.             NodeType *w = x->parent->right;
  209.             if (w->color == RED) {
  210.                 w->color = BLACK;
  211.                 x->parent->color = RED;
  212.                 rotateLeft (x->parent);
  213.                 w = x->parent->right;
  214.             }
  215.             if (w->left->color == BLACK && w->right->color == BLACK) {
  216.                 w->color = RED;
  217.                 x = x->parent;
  218.             } else {
  219.                 if (w->right->color == BLACK) {
  220.                     w->left->color = BLACK;
  221.                     w->color = RED;
  222.                     rotateRight (w);
  223.                     w = x->parent->right;
  224.                 }
  225.                 w->color = x->parent->color;
  226.                 x->parent->color = BLACK;
  227.                 w->right->color = BLACK;
  228.                 rotateLeft (x->parent);
  229.                 x = root;
  230.             }
  231.         } else {
  232.             NodeType *w = x->parent->left;
  233.             if (w->color == RED) {
  234.                 w->color = BLACK;
  235.                 x->parent->color = RED;
  236.                 rotateRight (x->parent);
  237.                 w = x->parent->left;
  238.             }
  239.             if (w->right->color == BLACK && w->left->color == BLACK) {
  240.                 w->color = RED;
  241.                 x = x->parent;
  242.             } else {
  243.                 if (w->left->color == BLACK) {
  244.                     w->right->color = BLACK;
  245.                     w->color = RED;
  246.                     rotateLeft (w);
  247.                     w = x->parent->left;
  248.                 }
  249.                 w->color = x->parent->color;
  250.                 x->parent->color = BLACK;
  251.                 w->left->color = BLACK;
  252.                 rotateRight (x->parent);
  253.                 x = root;
  254.             }
  255.         }
  256.     }
  257.     x->color = BLACK;
  258. }
  260. // delete node
  261. RbtStatus rbtErase(NodeType * z) {
  262.     NodeType *x, *y;
  264.     if (z->left == SENTINEL || z->right == SENTINEL) {
  265.         // y has a SENTINEL node as a child
  266.         y = z;
  267.     } else {
  268.         // find tree successor with a SENTINEL node as a child
  269.         y = z->right;
  270.         while (y->left != SENTINEL) y = y->left;
  271.     }
  273.     // x is y's only child
  274.     if (y->left != SENTINEL)
  275.         x = y->left;
  276.     else
  277.         x = y->right;
  279.     // remove y from the parent chain
  280.     x->parent = y->parent;
  281.     if (y->parent)
  282.         if (y == y->parent->left)
  283.             y->parent->left = x;
  284.         else
  285.             y->parent->right = x;
  286.     else
  287.         root = x;
  289.     if (y != z) {
  290.         z->key = y->key;
  291.         z->val = y->val;
  292.     }
  295.     if (y->color == BLACK)
  296.         deleteFixup (x);
  298.     free (y);
  300.     return RBT_STATUS_OK;
  301. }
  303. // find key
  304. NodeType *rbtFind(KeyType key) {
  305.     NodeType *current;
  306.     current = root;
  307.     while(current != SENTINEL) {
  308.         if(compEQ(key, current->key)) {
  309.             return current;
  310.         } else {
  311.             current = compLT (key, current->key) ?
  312.                 current->left : current->right;
  313.         }
  314.     }
  315.     return NULL;
  316. }
  318. // in-order walk of tree
  319. void rbtInorder(NodeType *p, void (callback)(NodeType *)) {
  320.     if (p == SENTINEL) return;
  321.     rbtInorder(p->left, callback);
  322.     callback(p);
  323.     rbtInorder(p->right, callback);
  324. }
  326. // delete nodes depth-first
  327. void rbtDelete(NodeType *p) {
  328.     if (p == SENTINEL) return;
  329.     rbtDelete(p->left);
  330.     rbtDelete(p->right);
  331.     free(p);
  332. }
  334. void displayNode(NodeType *p) {
  335.     printf("%d %d/n", p->key, p->val.stuff);
  336. }
  338. int main(int argc, char **argv) {
  339.     int maxnum, ct;
  340.     KeyType key;
  341.     RbtStatus status;
  343.     // command-line:
  344.     //
  345.     //   rbt 2000
  346.     //      process 2000 records
  348.     NodeType *p;
  350.     maxnum = atoi(argv[1]);
  352.     printf("maxnum = %d/n", maxnum);
  353.     for (ct = 1000; ct; ct--) {
  354.         key = rand() % 1000 + 1;
  355.         if ((p = rbtFind(key)) != NULL) {
  356.    /*
  357.                      if (p->val.stuff != 10*key) printf("fail val/n");
  358.                         status = rbtErase(p);
  359.                         if (status) printf("fail: status = %d/n", status);*/
  360.             
  361.         } else {
  362.             ValType val;
  363.             val.stuff = 10*key;
  364.             status = rbtInsert(key, val);
  365.             if (status) printf("fail: status = %d/n", status);
  366.         }
  367.     }
  369.     for (ct = 1000; ct; ct--) {
  370.         key = rand() % 100 + 1;
  371.         if ((p = rbtFind(key)) != NULL) {
  372.              status = rbtErase(p);
  373.         }
  374.     }
  375.     // output nodes in order
  376.     rbtInorder(root, displayNode);
  378.     rbtDelete(root);
  380.     return 0;
  381. }
 
adcxf
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通用红黑树（Tree-Map）容器纯C实现
08-05
纯C实现的通用红黑树容器不好找，于是自己琢磨着实现了一个。 算法部分直接剪裁自Linux内核中的rbtree 作者主要是在此基础上封装了一个通用的容器 里面含有 test例子 以及 benchmark基准测试 另外这个是Windows和Linux都可以用的 由于Linux内核的rbtree用了很多C99语法，笔者还得写了一些宏改造内核代码 Linux下的make是完整的 Windows下提供了VS08版的sln文件（只有test木有benchmark） 附带了一个C++里面的STL Map的benchmark
高性能组件-红黑树-C语言版本
qq3073959033的博客
07-31 353
高级数据结构之红黑树
开源C语言库Melon：红黑树
weixin_40960130的博客
01-19 330
红黑树是一种被应用的非常广泛的数据结构，用于快速搜索指定数据集中的数据。本文带大家一起走进开源C库Melon的红黑树模块。
红黑树（C语言实现）
qq_49723651的博客
06-29 4417
红黑树c语言实现
红黑树rbTree.c
05-12
红黑树的遍历，查找过程，以及插入时对红黑树进行位置修复，修复包括左旋右旋，还有就是红黑树节点的删除，删除之后还要对节点修复
红黑树的c实现源码与教程
01-03
红黑树的c实现源码与剖析 原作者：那谁 源码剖析作者：July ===================== July说明： 由于原来的程序没有任何一行注释，我把它深入剖析，并一行一行的添加了注释， 详情请参见此文： 教你彻底实现红黑树：...
红黑树C源码实现及注释
09-18
算法导论中红黑树的C代码实现，已添加注释
红黑树的C实现，算法导论的红黑树C实现
03-21
红黑树的C语言实现 算法导论的红黑树C实现
红黑树的C代码实现，附带详细注释
03-16
红黑树的C代码实现，附带详细注释
红黑树c语言实现
09-29
红黑树使用c语言实现
rbtree:具有类似于C ++ STL的API的高性能红黑树
05-10
rbtree 一棵红黑树，其API与C ++ STL相似。 带有较少堆对象的高性能红黑树。 分期付款 go get -u -v github.com/cdongyang/rbtree 测试 运行测试： ./test.sh coverage: 95.5% of statements 跑步台： /bin/go test -v -benchmem -run=^$ github.com/cdongyang/rbtree -bench ^Benchmark$ 例子 更多示例，请参见example_test.go func ExampleMap () { var slice = [] int { 1 , 4 , 6 , 5 , 3 , 7 , 2 , 9 } // key type: int, value type: *int mp := rbtree . NewMap ( i
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
红黑树c语言,数据结构之红黑树C源码实现与剖析
weixin_39792393的博客
05-19 119
#include typedef int key_t;typedef int data_t;typedef enum color_t{RED = 0,BLACK =1}color_t;typedef struct rb_node_t{struct rb_node_t *left, *right, *parent;key_t key; //这个是关键值data_t data;//这个是标号color...
c语言map的实现-使用内核红黑树
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
C语言实现红黑树
summer的专栏
06-30 2750
红黑树是一种二叉搜索树，具有良好的性质，树高至多2lg(n+1)。  一棵红黑树是满足下列条件的二叉搜索树： 每个节点或是红色的或是黑色的。根节点是黑色的。叶子节点是黑色的。如果一个节点是红色的，那么它的两个孩子是黑色的。对每个节点，从该节点（不包括该节点）到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。 本方案使用一个哨兵Nil来代表所有的NULL，根节点为T，根
交换单链表的任意两个节点
Make Progress Everyday!
04-06 4900
#include iostream>using namespace std;/**//* link node struct */struct Node...{public:    Node():val(0), next(NULL)    ...{    }    Node(int _val,  Node* _next):val(_val), next(_next)    ...{    }  
求 1/1 + 1/2 + 2/3 + 3/5 + 5/8 .... 前 n 项之和!
Make Progress Everyday!
09-28 4818
/* 求 1/1 + 1/2 + 2/3 + 3/5 + 5/8 .... 前 n 项之和! */#include  using namespace std;/* 迭代算法 */double sumOfDouble(int n){    int x = 1;    int y = 1;    double sum = 0;    for (int i
红黑树理论与c++实现
Make Progress Everyday!
08-06 3289
    红黑树（Red-Black Tree）是二叉搜索树（Binary Search Tree）的一种改进。我们知道二叉搜索树在最坏的情况下可能会变成一个链表（当所有节点按从小到大的顺序依次插入后）。而红黑树在每一次插入或删除节点之后都会花O（log N）的时间来对树的结构作修改，以保持树的平衡。也就是说，红黑树的查找方法与二叉搜索树完全一样；插入和删除节点的的方法前半部分节与二叉搜索树完全一样
Josephus问题求解
Make Progress Everyday!
04-08 2874
/**//************************************************************************Josephus问题求解：    设有n个人围坐一个圆桌周围，，现从第S人开始报数，数到第m的人出列，    然后从出列的下一个重新开始报数，数列的第m个人又出列……如此重复，直    到所有的人全部出列为止。对任意给定的n、s、m，求按出列
使用objective-c实现红黑树
最新发布
03-07
Objective-C是一面向对象的编程语言它是基于C语言的扩展虽然Objective-C本身并没有提供红黑树的实现，但可以通过使用Foundation框架中的NSSet类来实现类似红黑树的功能[^2]。 NSSet是Foundation框架中的一个集合类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值