red在c语言窗口,red-black tree c语言实现

于 2021-05-17 19:10:50 发布
阅读量196 收藏
点赞数
文章标签： red在c语言窗口

1 /*-----------------------------------------------------------2 RB-Tree的插入和删除操作的实现算法3 参考资料:4 1) <>5 2) [url]http://lxr.linux.no/linux/lib/rbtree.c[/url]6 7 作者：[url]http://www.cppblog.com/converse/[/url]8 您可以自由的传播，修改这份代码，转载处请注明原作者9 10 红黑树的几个性质:11 1) 每个结点只有红和黑两种颜色12 2) 根结点是黑色的13 3)空节点是黑色的(红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点)。14 4) 如果一个结点是红色的,那么它的左右两个子结点的颜色是黑色的15 5) 对于每个结点而言,从这个结点到叶子结点的任何路径上的黑色结点16 的数目相同17 -------------------------------------------------------------*/

18

19 #include 

20 #include 

21 #include 

22

23 typedef int key_t;

24 typedef int data_t;

25

26 typedef enum color_t

27 {

28     RED = 0,

29     BLACK = 1

30 }color_t;

31

32 typedef struct rb_node_t

33 {

34     struct rb_node_t *left, *right, *parent;

35     key_t key;

36     data_t data;

37     color_t color;

38 }rb_node_t;

39

40 /*forward declaration*/

41 rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root);

42 rb_node_t* rb_search(key_t key, rb_node_t* root);

43 rb_node_t* rb_erase(key_t key, rb_node_t* root);

44

45 int main()

46 {

47     int i, count = 900000;

48     key_t key;

49     rb_node_t* root = NULL, *node = NULL;

50

51     srand(time(NULL));

52     for (i = 1; i 

53     {

54         key = rand() % count;

55         if ((root = rb_insert(key, i, root)))

56         {

57             printf("[i = %d] insert key %d success!\n", i, key);

58         }

59         else

60         {

61             printf("[i = %d] insert key %d error!\n", i, key);

62             exit(-1);

63         }

64

65         if ((node = rb_search(key, root)))

66         {

67             printf("[i = %d] search key %d success!\n", i, key);

68         }

69         else

70         {

71             printf("[i = %d] search key %d error!\n", i, key);

72             exit(-1);

73         }

74         if (!(i % 10))

75         {

76             if ((root = rb_erase(key, root)))

77             {

78                 printf("[i = %d] erase key %d success\n", i, key);

79             }

80             else

81             {

82                 printf("[i = %d] erase key %d error\n", i, key);

83             }

84         }

85     }

86

87     return 0;

88 }

89

90 static rb_node_t* rb_new_node(key_t key, data_t data)

91 {

92     rb_node_t *node = (rb_node_t*)malloc(sizeof(struct rb_node_t));

93

94     if (!node)

95     {

96         printf("malloc error!\n");

97         exit(-1);

98     }

99     node->key = key, node->data = data;

100

101     return node;

102 }

103

104 /*-----------------------------------------------------------105 |   node           right106 |   / \    ==>     / \107 |   a  right     node  y108 |       / \           / \109 |       b  y         a   b110 -----------------------------------------------------------*/

111 static rb_node_t* rb_rotate_left(rb_node_t* node, rb_node_t* root)

112 {

113     rb_node_t* right = node->right;

114

115     if ((node->right = right->left))

116     {

117         right->left->parent = node;

118     }

119     right->left = node;

120

121     if ((right->parent = node->parent))

122     {

123         if (node == node->parent->right)

124         {

125             node->parent->right = right;

126         }

127         else

128         {

129             node->parent->left = right;

130         }

131     }

132     else

133     {

134         root = right;

135     }

136     node->parent = right;

137

138     return root;

139 }

140

141 /*-----------------------------------------------------------142 |       node           left143 |       / \            / \144 |    left  y   ==>    a   node145 |   / \               / \146 |  a   b             b   y147 -----------------------------------------------------------*/

148 static rb_node_t* rb_rotate_right(rb_node_t* node, rb_node_t* root)

149 {

150     rb_node_t* left = node->left;

151

152     if ((node->left = left->right))

153     {

154         left->right->parent = node;

155     }

156     left->right = node;

157

158     if ((left->parent = node->parent))

159     {

160         if (node == node->parent->right)

161         {

162             node->parent->right = left;

163         }

164         else

165         {

166             node->parent->left = left;

167         }

168     }

169     else

170     {

171         root = left;

172     }

173     node->parent = left;

174

175     return root;

176 }

177

178 static rb_node_t* rb_insert_rebalance(rb_node_t *node, rb_node_t *root)

179 {

180     rb_node_t *parent, *gparent, *uncle, *tmp;

181

182     while ((parent = node->parent) && parent->color == RED)

183     {

184         gparent = parent->parent;

185

186         if (parent == gparent->left)

187         {

188             uncle = gparent->right;

189             if (uncle && uncle->color == RED)

190             {

191                 uncle->color = BLACK;

192                 parent->color = BLACK;

193                 gparent->color = RED;

194                 node = gparent;

195             }

196             else

197             {

198                 if (parent->right == node)

199                 {

200                     root = rb_rotate_left(parent, root);

201                     tmp = parent;

202                     parent = node;

203                     node = tmp;

204                 }

205

206                 parent->color = BLACK;

207                 gparent->color = RED;

208                 root = rb_rotate_right(gparent, root);

209             }

210         }

211         else

212         {

213             uncle = gparent->left;

214             if (uncle && uncle->color == RED)

215             {

216                 uncle->color = BLACK;

217                 parent->color = BLACK;

218                 gparent->color = RED;

219                 node = gparent;

220             }

221             else

222             {

223                 if (parent->left == node)

224                 {

225                     root = rb_rotate_right(parent, root);

226                     tmp = parent;

227                     parent = node;

228                     node = tmp;

229                 }

230

231                 parent->color = BLACK;

232                 gparent->color = RED;

233                 root = rb_rotate_left(gparent, root);

234             }

235         }

236     }

237

238     root->color = BLACK;

239

240     return root;

241 }

242

243 static rb_node_t* rb_erase_rebalance(rb_node_t *node, rb_node_t *parent, rb_node_t *root)

244 {

245     rb_node_t *other, *o_left, *o_right;

246

247     while ((!node || node->color == BLACK) && node != root)

248     {

249         if (parent->left == node)

250         {

251             other = parent->right;

252             if (other->color == RED)

253             {

254                 other->color = BLACK;

255                 parent->color = RED;

256                 root = rb_rotate_left(parent, root);

257                 other = parent->right;

258             }

259             if ((!other->left || other->left->color == BLACK) &&

260                 (!other->right || other->right->color == BLACK))

261             {

262                 other->color = RED;

263                 node = parent;

264                 parent = node->parent;

265             }

266             else

267             {

268                 if (!other->right || other->right->color == BLACK)

269                 {

270                     if ((o_left = other->left))

271                     {

272                         o_left->color = BLACK;

273                     }

274                     other->color = RED;

275                     root = rb_rotate_right(other, root);

276                     other = parent->right;

277                 }

278                 other->color = parent->color;

279                 parent->color = BLACK;

280                 if (other->right)

281                 {

282                     other->right->color = BLACK;

283                 }

284                 root = rb_rotate_left(parent, root);

285                 node = root;

286                 break;

287             }

288         }

289         else

290         {

291             other = parent->left;

292             if (other->color == RED)

293             {

294                 other->color = BLACK;

295                 parent->color = RED;

296                 root = rb_rotate_right(parent, root);

297                 other = parent->left;

298             }

299             if ((!other->left || other->left->color == BLACK) &&

300                 (!other->right || other->right->color == BLACK))

301             {

302                 other->color = RED;

303                 node = parent;

304                 parent = node->parent;

305             }

306             else

307             {

308                 if (!other->left || other->left->color == BLACK)

309                 {

310                     if ((o_right = other->right))

311                     {

312                         o_right->color = BLACK;

313                     }

314                     other->color = RED;

315                     root = rb_rotate_left(other, root);

316                     other = parent->left;

317                 }

318                 other->color = parent->color;

319                 parent->color = BLACK;

320                 if (other->left)

321                 {

322                     other->left->color = BLACK;

323                 }

324                 root = rb_rotate_right(parent, root);

325                 node = root;

326                 break;

327             }

328         }

329     }

330

331     if (node)

332     {

333         node->color = BLACK;

334     }

335

336     return root;

337 }

338

339 static rb_node_t* rb_search_auxiliary(key_t key, rb_node_t* root, rb_node_t** save)

340 {

341     rb_node_t *node = root, *parent = NULL;

342     int ret;

343

344     while (node)

345     {

346         parent = node;

347         ret = node->key - key;

348         if (0 

349         {

350             node = node->left;

351         }

352         else if (0 > ret)

353         {

354             node = node->right;

355         }

356         else

357         {

358             return node;

359         }

360     }

361

362     if (save)

363     {

364         *save = parent;

365     }

366

367     return NULL;

368 }

369

370 rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)

371 {

372     rb_node_t *parent = NULL, *node;

373

374     parent = NULL;

375     if ((node = rb_search_auxiliary(key, root, &parent)))

376     {

377         return root;

378     }

379

380     node = rb_new_node(key, data);

381     node->parent = parent;

382     node->left = node->right = NULL;

383     node->color = RED;

384

385     if (parent)

386     {

387         if (parent->key > key)

388         {

389             parent->left = node;

390         }

391         else

392         {

393             parent->right = node;

394         }

395     }

396     else

397     {

398         root = node;

399     }

400

401     return rb_insert_rebalance(node, root);

402 }

403

404 rb_node_t* rb_search(key_t key, rb_node_t* root)

405 {

406     return rb_search_auxiliary(key, root, NULL);

407 }

408

409 rb_node_t* rb_erase(key_t key, rb_node_t *root)

410 {

411     rb_node_t *child, *parent, *old, *left, *node;

412     color_t color;

413

414     if (!(node = rb_search_auxiliary(key, root, NULL)))

415     {

416         printf("key %d is not exist!\n");

417         return root;

418     }

419

420     old = node;

421

422     if (node->left && node->right)

423     {

424         node = node->right;

425         while ((left = node->left) != NULL)

426         {

427             node = left;

428         }

429         child = node->right;

430         parent = node->parent;

431         color = node->color;

432

433         if (child)

434         {

435             child->parent = parent;

436         }

437         if (parent)

438         {

439             if (parent->left == node)

440             {

441                 parent->left = child;

442             }

443             else

444             {

445                 parent->right = child;

446             }

447         }

448         else

449         {

450             root = child;

451         }

452

453         if (node->parent == old)

454         {

455             parent = node;

456         }

457

458         node->parent = old->parent;

459         node->color = old->color;

460         node->right = old->right;

461         node->left = old->left;

462

463         if (old->parent)

464         {

465             if (old->parent->left == old)

466             {

467                 old->parent->left = node;

468             }

469             else

470             {

471                 old->parent->right = node;

472             }

473         }

474         else

475         {

476             root = node;

477         }

478

479         old->left->parent = node;

480         if (old->right)

481         {

482             old->right->parent = node;

483         }

484     }

485     else

486     {

487         if (!node->left)

488         {

489             child = node->right;

490         }

491         else if (!node->right)

492         {

493             child = node->left;

494         }

495         parent = node->parent;

496         color = node->color;

497

498         if (child)

499         {

500             child->parent = parent;

501         }

502         if (parent)

503         {

504             if (parent->left == node)

505             {

506                 parent->left = child;

507             }

508             else

509             {

510                 parent->right = child;

511             }

512         }

513         else

514         {

515             root = child;

516         }

517     }

518

519     free(old);

520

521     if (color == BLACK)

522     {

523         root = rb_erase_rebalance(child, parent, root);

524     }

525

526     return root;

527 }

韩北樱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
red-black-tree:C - 左倾红黑树实现
06-02
左倾红黑树是一种自平衡二叉查找树（AVL树的一种变种），它在保持红黑树特性的同时，通过特定的旋转策略优化了插入...这个压缩包中的"red-black-tree-master"可能包含了源代码文件，用于演示和学习这种数据结构的实现。
red-black-tree.zip
02-05
在"red_black_tree.c"中，可能包含了红黑树的插入、删除、查找等核心操作的实现。这些操作需要考虑到旋转（左旋和右旋）以及重新着色等平衡调整策略，以确保性质5的维持。 "misc.c"可能包含了一些辅助函数，比如...
红黑树与C实现算法 - RedBlackTree.c
恒
11-16 5954
红黑树（red-black-tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"。本文根据相关资料整理，最主要的是提供了对set的支持，提供了完整的红黑树的C语言实现代码。
算法导论之Red-Black-Tree(C语言实现)&&平衡二叉树(C++实现)
struver的博客
10-19 371
**算法导论之红黑树（C语言实现）** **与平衡二叉树（C++实现）** 红黑树： /********************************************** 红黑树有如下五个性质： 1-3：每个结点或红或黑、根节点黑、叶结点（NULL）黑 4： 若结点是红的，则孩子是黑的...
red在c语言窗口,Red编程语言目标：世界上第一个完整的堆栈语言！
weixin_29662775的博客
05-17 495
最近，新出了一款编程语言叫Red。什么？你没听过？没关系，接下来就是详细介绍(附带github地址)。在此，我想替广大程序员说一句“真心好累”，本来编程世界就很拥挤了，编程语言更是多到根本学不完，这就又来了一门新的。Red编程语言网站将其描述为：下一代编程语言，是受到了REBOL的强烈启发。下一代编程语言？听起来口气不小啊！Red的目标是建立世界上第一个完整的堆栈语言，一种可以从系统编程任务到DS...
Red Black Tree in C
weixin_30260399的博客
02-26 65
http://web.mit.edu/~emin/www.old/source_code/red_black_tree/index.html 转载于:https://www.cnblogs.com/lilei9110/p/4302283.html
红黑树（red_black_tree）的c语言实现
pingpangbingo的专栏
10-26 725
// red_black_tree.cpp : 定义控制台应用程序的入口点。 // /* ** red_black_tree.cpp ** 基本的数据结构是使用双向链表（需要经常访问PARENT，GRANDPARENT and UNCLE）实现的二叉树 ** ** ** */ #include "stdafx.h" #include #include #include
red-black-tree-c.rar_red black tree_tree c语言
09-21
这种数据结构在计算机科学中有着广泛的应用，特别是在实现关联数组、数据库索引、优先队列等数据结构时。在C语言中实现红黑树，需要理解其核心性质并能有效地编写代码来维护这些性质。 红黑树的性质如下： 1. 每个...
Red-Black-Tree.tar.gz
05-15
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer于1972年提出。它在数据结构中扮演着重要的角色，特别是在需要高效插入、删除和查找操作的场景下。红黑树在C语言和C++编程中被广泛应用...
红黑树 RBTREE red-black-tree RBTree RED BLACK TREE
01-22
这一版代码个人认为９９.９９%正确，本人使用些结构及算法用于实现嵌入式迅雷Server的任务管理。此代码经本人学习研究之后从C语言版BT源代码中的宏定义式代码中分离出来，并做成一个测试版。你也可以做一些微小的...
红黑树rbTree.c
05-12
红黑树的遍历，查找过程，以及插入时对红黑树进行位置修复，修复包括左旋右旋，还有就是红黑树节点的删除，删除之后还要对节点修复
C语言宏定义用法大全
06-11
关于C语言宏定义的用法，作了一个总结，除了常用宏定义外，还有类似函数的宏的用法
sistence-rbtree：C ++中的持久性红黑树
02-04
sistence-rbtree：C ++中的持久性红黑树
C语言对DFS简单应用(Red and Black
LieYingZhiYan的专栏
02-03 1657
#include int dir[4][2]={{1,0},{0,-1},{0,1},{-1,0}}; char maze[25][25]; int num,m,n; void DFS(int x,int y) { num++; maze[x][y]='#';//防止重复记录 for(int k=0;k<4;k++) { int X=x+dir[k]
rbtree 红黑树的 C 语言实现
jhkwei的专栏
01-18 1252
rbtree 红黑树的 C 语言实现，主要是照搬了《算法导论》，红黑树是一种比较有实用意义的平衡树，不过也挻复杂，主要是利用其它兄弟节点再加以旋转来实现平衡，不过在并发上增删操作不太方便，这时用 skip list 跳跃表有一定的优势。不过用来实现key-->value 数据结构 map , dictation, set 还是不错，现在把源码和测试表如下：/* * rbtree.h * *
Linux kernel rbtree
u010758403的专栏
12-21 800
1.rbtree.h/* Red Black Trees (C) 1999 Andrea Arcangeli This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as publish
linux内核分析之rbtree的使用
Bloom and Grow
01-06 1万+
一、理论基础       红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求: 性质1. 节点是红色或黑色。 性质2. 根是黑色。 性质3. 所有叶子都是黑色（叶子是NIL节点）。 性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点
红黑树(二)之 C语言的实现
kk的博客
04-02 393
概要 红黑树在日常的使用中比较常用，例如Java的TreeMap和TreeSet，C++的STL，以及Linux内核中都有用到。之前写过一篇文章专门介绍红黑树的理论知识，本文将给出红黑数的C语言的实现代码，后序章节再分别给出C++和Java版本的实现。还是那句话，三种实现原理相同，择其一了解即可；若文章有错误或不足的地方，望不吝指出！ 目录1. 红黑树的介绍2. 红黑树的C实现...
RBtree插入跟删除图解代码
热门推荐
sowhat
04-09 2万+
一、红黑树的简介 红黑树是一种平衡的二叉查找树，是一种计算机科学中常用的数据结构，最典型的应用是实现数据的关联，例如map等数据结构的实现。 红黑树有以下限制： 1. 节点必须是红色或者是黑色 2. 根节点是黑色的 3. 所有的叶子节点是黑色的。 4. 每个红色节点的两个子节点是黑色的，也就是不能存在父子两个节点全是红色 5. 从任意每个节点到其每个叶子节
c语言红黑树
最新发布
06-01
下面是一个基于C语言实现的红黑树示例代码： ```c #include #include #define RED 0 #define BLACK 1 typedef struct Node { int value; int color; struct Node* left; struct Node* right; struct Node*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值