java 红黑树_Java实现红黑树

1 packagecom.example.lenovo.linehough;2

3 public classGRBTree {4 intiCount;5 int[] treeValue;6 GRBTreeNode root;7 boolean BLACK = false;8 boolean RED = true;9

10 publicGRBTree() {11 root = null;12 }13

14 public GRBTree(inti) {15 Free();16 }17

18 public classGRBTreeNode {19 intkey;20 booleancolor;21 GRBTreeNode left, right, parent;22

23 public GRBTreeNode(int newKey, booleannewColor, GRBTreeNode newLeft, GRBTreeNode newRight) {24 key =newKey;25 color =newColor;26 left =newLeft;27 right =newRight;28 if (left != null)29 left.parent = this;30 if (right != null)31 right.parent = this;32 parent = null;33 }34

35 publicGRBTreeNode() {36 if (left != null)37 left = null;38 if (right != null)39 right = null;40 }41 }42

43 voidFree() {44 if (root != null)45 root = null;46 }47

48 voidDereference() {49 root = null;50 }51

52 publicGRBTreeNode Grandparent(GRBTreeNode n) {53 if (n == null || n.parent == null)54 return null;55 returnn.parent.parent;56 }57

58 publicGRBTreeNode Sibling(GRBTreeNode n) {59 if (n == null || n.parent == null)60 return null;61 if (n ==n.parent.left)62 returnn.parent.right;63 else

64 returnn.parent.left;65 }66

67 publicGRBTreeNode Uncle(GRBTreeNode n) {68 if (n == null)69 return null;70 returnSibling(n.parent);71 }72

73 booleanColorOf(GRBTreeNode n) {74 return n == null ?BLACK : n.color;75 }76

77 public GRBTreeNode Find(intkeyToFind) {78 GRBTreeNode n =root;79 while (n != null) {80 if (keyToFind ==n.key)81 returnn;82 if (keyToFind

85 n =n.right;86 }87 returnn;88 }89

90 voidReplace(GRBTreeNode oldNode, GRBTreeNode newNode) {91 if (oldNode.parent == null)92 root =newNode;93 else{94 if (oldNode ==oldNode.parent.left)95 oldNode.parent.left =newNode;96 else

97 oldNode.parent.right =newNode;98 }99 if (newNode != null)100 newNode.parent =oldNode.parent;101 }102

103 voidRotateLeft(GRBTreeNode n) {104 GRBTreeNode r =n.right;105 Replace(n, r);106 n.right =r.left;107 if (r.left != null)108 r.left.parent =n;109 r.left =n;110 n.parent =r;111 }112

113 voidRotateRight(GRBTreeNode n) {114 GRBTreeNode l =n.left;115 Replace(n, l);116 n.left =l.right;117 if (l.right != null)118 l.right.parent =n;119 l.right =n;120 n.parent =l;121 }122

123 voidInsert1(GRBTreeNode n) {124 if (n.parent == null)125 n.color =BLACK;126 else

127 Insert2(n);128 }129

130 voidInsert2(GRBTreeNode n) {131 if (n.parent.color !=BLACK)132 Insert3(n);133 }134

135 voidInsert3(GRBTreeNode n) {136 GRBTreeNode u =Uncle(n);137 GRBTreeNode g =Grandparent(n);138 if (ColorOf(u) ==RED) {139 n.parent.color =BLACK;140 u.color =BLACK;141 g.color =RED;142 Insert1(g);143 } else

144 Insert4(n);145 }146

147 voidInsert4(GRBTreeNode n) {148 GRBTreeNode g =Grandparent(n);149 if (n == n.parent.right && n.parent ==g.left) {150 RotateLeft(n.parent);151 n =n.left;152 } else if (n == n.parent.left && n.parent ==g.right) {153 RotateRight(n.parent);154 n =n.right;155 }156 Insert5(n);157 }158

159 voidInsert5(GRBTreeNode n) {160 GRBTreeNode g =Grandparent(n);161 n.parent.color =BLACK;162 g.color =RED;163 if (n == n.parent.left && n.parent ==g.left)164 RotateRight(g);165 else

166 RotateLeft(g);167 }168

169 boolean Insert(intnewKey) {170 GRBTreeNode insNode = new GRBTreeNode(newKey, RED, null, null);171 GRBTreeNode n;172

173 if (root == null)174 root =insNode;175 else{176 n =root;177 while (true) {178 if (newKey ==n.key) {179 return false;180 }181

182 if (newKey

187 n =n.left;188 } else{189 if (n.right == null) {190 n.right =insNode;191 break;192 } else

193 n =n.right;194 }195 }196 insNode.parent =n;197 }198

199 Insert1(insNode);200

201 return true;202 }203

204 publicGRBTreeNode Maximum(GRBTreeNode n) {205 if (n == null)206 return null;207

208 while (n.right != null)209 n =n.right;210 returnn;211 }212

213 publicGRBTreeNode Minimum(GRBTreeNode n) {214 if (n == null)215 return null;216

217 while (n.left != null)218 n =n.left;219 returnn;220 }221

222 voidDelete1(GRBTreeNode n) {223 if (n.parent != null)224 Delete2(n);225 }226

227 voidDelete2(GRBTreeNode n) {228 GRBTreeNode s =Sibling(n);229

230 if (ColorOf(s) ==RED) {231 n.parent.color =RED;232 s.color =BLACK;233

234 if (n ==n.parent.left) {235 RotateLeft(n.parent);236 } else{237 RotateRight(n.parent);238 }239 }240 Delete3(n);241 }242

243 voidDelete3(GRBTreeNode n) {244 GRBTreeNode s =Sibling(n);245

246 if (ColorOf(n.parent) == BLACK && ColorOf(s) == BLACK &&

247 ColorOf(s.left) == BLACK && ColorOf(s.right) ==BLACK) {248 s.color =RED;249 Delete1(n.parent);250 } else

251 Delete4(n);252 }253

254 voidDelete4(GRBTreeNode n) {255 GRBTreeNode s =Sibling(n);256

257 if (ColorOf(n.parent) == RED && ColorOf(s) == BLACK &&

258 ColorOf(s.left) == BLACK && ColorOf(s.right) ==BLACK) {259 s.color =RED;260 n.parent.color =BLACK;261 } else

262 Delete5(n);263 }264

265 voidDelete5(GRBTreeNode n) {266 GRBTreeNode s =Sibling(n);267

268 if (n == n.parent.left &&

269 ColorOf(s) == BLACK && ColorOf(s.left) == RED && ColorOf(s.right) ==BLACK) {270 s.color =RED;271 s.left.color =BLACK;272 RotateRight(s);273 } else if (n == n.parent.right &&

274 ColorOf(s) == BLACK && ColorOf(s.right) == RED && ColorOf(s.left) ==BLACK) {275 s.color =RED;276 s.right.color =BLACK;277 RotateLeft(s);278 }279 Delete6(n);280 }281

282 voidDelete6(GRBTreeNode n) {283 GRBTreeNode s =Sibling(n);284

285 s.color =ColorOf(n.parent);286 n.parent.color =BLACK;287 if (n ==n.parent.left) {288 s.right.color =BLACK;289 RotateLeft(n.parent);290 } else{291 s.left.color =BLACK;292 RotateRight(n.parent);293 }294 }295

296 void Delete(intkeyToDel) {297 GRBTreeNode c;298 GRBTreeNode n =Find(keyToDel);299 if (n == null)300 return;301

302 if (n.left != null && n.right != null) {303 GRBTreeNode pred =Maximum(n.left);304 n.key =pred.key;305 n =pred;306 }307

308 c = n.right == null ?n.left : n.right;309 if (ColorOf(n) ==BLACK) {310 n.color =ColorOf(c);311 Delete1(n);312 }313 Replace(n, c);314 if (n.parent == null && c != null)315 c.color =BLACK;316

317 n.left = null;318 n.right = null;319 }320

321 /*前序遍历的结果放到一个数组里面*/

322 private void preOrder(GRBTreeNode n, int width, intheight) {323

324 if (n != null) {325 treeValue[iCount] =n.key;326 iCount++;327 preOrder(n.left, width, height);328 preOrder(n.right, width, height);329 }330

331 }332

333 public int[] preOrder(int width, intheight) {334 treeValue = new int[width *height];335 iCount = 0;336 preOrder(root, width, height);337 returntreeValue;338 }339

340 public intgetiCount() {341 returniCount;342 }343 }