2. 程式人生 > >用Java實現紅黑樹的完整程式碼

用Java實現紅黑樹的完整程式碼

阿新 • • 發佈：2019-01-04
 //對某個節點進行左旋
 public void leftRonate(RBNode<T> x) {
  RBNode<T> y = x.rightChild;
  
  if(y.leftChild!=null) {
   y.leftChild.parent = x;
  }
  
  x.rightChild = y.leftChild;
     y.leftChild = x;
     y.parent = x.parent;
    
    
    
     if(x.parent!=null) {
      if(x.parent.leftChild == x) {
       x.parent.leftChild = y;
      }else {
       x.parent.rightChild = y;
      }
     }else {
      this.mroot = y;
     }
     x.parent = y;
    
 }
 
 //對某個節點進行右旋
 public void rightRonate(RBNode<T> x) {
  RBNode<T> y = x.leftChild;
  
  if(y.rightChild!=null) {
   y.rightChild.parent = x;
  }
  
  y.parent = x.parent;
  x.leftChild = y.rightChild;
  y.rightChild = x;
  
  if(x.parent!=null) {
   if(x.parent.leftChild == x) {
    x.parent.leftChild = y;
   }else {
    x.parent.rightChild = y;
   }
  }else {
   this.mroot = y;
  }
  x.parent = y;
 }
 
 
 
 //紅黑樹新增修復
 public void insertFixUp(RBNode<T> node) {
  RBNode<T> parent,gparent;
  while(((parent = parentOf(node))!=null)&&isRed(parent)) {
   gparent = parentOf(parent);
   if(gparent.leftChild == parent) {
    RBNode<T> uncle = gparent.rightChild;
    if(isRed(uncle)){
     setBlack(parent);
     setBlack(uncle);
     setRed(gparent);
     
     node = gparent;
     continue;
    }else {
     if(parent.rightChild == node) {
       leftRonate(parent);
       RBNode<T> temp = node;
       node = parent;
       parent = temp;
     }
     
     setBlack(parent);
     setRed(gparent);
     rightRonate(gparent);
     
    }
   }else {
    
    RBNode<T> uncle = gparent.leftChild;
    if(isRed(uncle)) {
     setBlack(parent);
     setBlack(uncle);
     setRed(gparent);
     
     node = gparent;
     continue;
    }else {
     if(parent.leftChild == node) {
      rightRonate(parent);
      RBNode<T> temp = node;
      node = parent;
      parent = temp;
     }
     setBlack(parent);
     setRed(gparent);
     leftRonate(gparent);
    }
   }
  }
  
  if(mroot == node) {
   setBlack(node);
  }
 }
 //紅黑樹刪除修復
 public void deleteFixUp(RBNode<T> node,RBNode<T> parent) {
     
  RBNode<T> other;
  while(isBlack(node)&&node!=this.mroot) {
      
       if(parent.leftChild == node) {
        other = parent.rightChild;
        if(isRed(other)) {
         setRed(parent);
         setBlack(other);
         leftRonate(parent);
         continue;
        }else {
         if(isBlack(other.leftChild)&&isBlack(other.rightChild)) {
          setRed(other);
          node = parent;
          parent = parentOf(node);
         
        
         }else if(isRed(other.leftChild)&&isBlack(other.rightChild)) {
          setRed(other);
          setBlack(other.leftChild);
          rightRonate(other);
         }else if(isRed(other.rightChild)) {
          setColor(other,colorOf(parent));
          setBlack(parent);
          setBlack(other.rightChild);
          leftRonate(parent);
          break;
         }
        }
       }else {
        other = parent.leftChild;
        if(isRed(other)) {
         setBlack(other);
         setRed(parent);
         rightRonate(parent);
         continue;
        }else {
         if(isBlack(other.leftChild)&&isBlack(other.rightChild)) {
          setRed(other);
          node = parent;
          parent = parentOf(node);
         
        
         }else if(isRed(other.rightChild)&&isBlack(other.leftChild)) {
          setRed(parent);
          setBlack(other.rightChild);
          leftRonate(other);
         }else if(isRed(other.leftChild)) {
          setColor(other, colorOf(parent));
          setBlack(parent);
          setBlack(other.leftChild);
          rightRonate(parent);
          break;
         }
        }
        }
  }
  
  setBlack(node);
 
 }
 
 
 //紅黑樹新增操作
 public void insert(RBNode<T> node) {
 
      int com;
      RBNode<T> x = this.mroot;
      RBNode<T> y = null;
      while(x!=null) {
       y = x;
       com = node.key.compareTo(x.key);
      
       if(com<0) {
       x=x.leftChild;
       }else{
       x=x.rightChild;
       }
      
      }
     
      node.parent = y;
     
      if(y!=null) {
       com = node.key.compareTo(y.key);
       if(com<0) {
        y.leftChild = node;
       }else {
        y.rightChild = node;
       }
      }else {
       this.mroot = node;
      }
      setRed(node);
      insertFixUp(node);
 }
 
     public void insert(T key) {
  
  RBNode<T> node = new RBNode<T>(BLACK,key,null,null,null);
  
  if(node!=null) {
   insert(node);
  }
  }
 
 //紅黑樹刪除操作
 public void delete(RBNode<T> node) {
  
  RBNode<T> child,parent,replace;
  boolean color = true;
  if(node.leftChild!=null&&node.rightChild!=null) {
   replace = successor(node);
   
   parent = parentOf(replace);
   child = replace.rightChild;
   color = colorOf(replace);
   
   if(node == parentOf(replace)) {
     parent = replace;
   }else {
    if(child!=null) {
       setParent(child,parentOf(replace));
    }
    replace.parent.leftChild = child;
    replace.rightChild = node.rightChild;
    setParent(node.rightChild,replace);
   }
   
   setParent(replace, parentOf(node));
   replace.leftChild = node.leftChild;
   setParent(node.leftChild,replace);
   setColor(replace,colorOf(node));
   
   if(parentOf(node)!=null) {
    if(node.parent.leftChild==node) {
     node.parent.leftChild = replace;
    }else {
     node.parent.rightChild = replace;
    }
   }else {
    this.mroot = replace;
   } 
   
   if(color==BLACK){
       deleteFixUp(child, parent);
   }
  }else {
  
   if(node.leftChild!=null) {
    replace = node.leftChild;
   }else {
    replace = node.rightChild;
   }
   
     parent = parentOf(node);
     
     if(parent!=null) {
      if(parent.leftChild==node) {
       parent.leftChild = replace;
      }else {
       parent.rightChild = replace;
      }
     }else {
      this.mroot = replace;
     }
     setParent(replace, parent);
   
      color = colorOf(node);
      child = replace;
   if(color==BLACK) {
    deleteFixUp(child, parent);
   }
  } 
    
 }
 
 public void delete(T key) {
  RBNode<T> node;
  if((node=search(key,this.mroot))!=null) {
   delete(node);
  }
 }
 
 //前序遍歷
 public void preOrder(RBNode<T> node) {
   if(node!=null) {  
  System.out.print(node.key+" ");
  preOrder(node.leftChild);
  preOrder(node.rightChild);
   } 
 }
 
 public void preOrder() {
  preOrder(this.mroot);
 }
 
 //中序遍歷
 public void inOrder(RBNode<T> node) {
  if(node!=null) {
   inOrder(node.leftChild);
   System.out.print(node.key+" ");
   inOrder(node.rightChild);
  }
 }
 public void inOrder() {
  inOrder(this.mroot);
 }
 
 //後序遍歷
 public void postOrder(RBNode<T> node) {
  if(node!=null) {
   postOrder(node.leftChild);
   postOrder(node.rightChild);
   System.out.print(node.key+" ");
  }
 }
 
 public void postOrder() {
  postOrder(this.mroot);
 }
 
 //列印紅黑樹
 public void print(RBNode<T> node,int direction) {
   if(node!=null) { 
  if(direction == 0) {
   System.out.printf("%2d(%s) is root\n",node.key,node.color==false?"R":"B");
  }else {
   System.out.printf("%2d(%s) is %s child 父節點  %2d\n",node.key,node.color==false?"R":"B",direction==-1?"left":"right",node.parent.key);
  }
  print(node.leftChild,-1);
  print(node.rightChild,1);
   } 
 }
 
 public void print() {
  print(this.mroot,0);
 }
 public static void main(String[] args) {
  
  DRBTree<Integer> tree = new DRBTree<Integer>();
  
  int[] a = {10,20,30,40,50,60,70,80,90};
  
  //紅黑樹新增測試
  for(int i=0;i<a.length;i++) {
   tree.insert(a[i]);
  }
  
  System.out.print("前序遍歷: ");
  tree.preOrder();
  
  System.out.print("\n中序遍歷: ");
  tree.inOrder();
  
  System.out.print("\n後序遍歷: ");
  tree.postOrder();
  
  System.out.println();
  tree.print();
  
  System.out.print("\n輸入要刪除的節點:");
  Scanner scan = new Scanner(System.in);
  
  int key = scan.nextInt();
  
  //紅黑樹刪除測試
  tree.delete(key);
  
  System.out.println();
  tree.print();
 }
}

相關推薦

用Java實現紅黑樹的完整程式碼

 //對某個節點進行左旋  public void leftRonate(RBNode<T> x) {   RBNode<T> y = x.rightChild;      if(y.leftChild!=null) {    y.leftChild.parent = x;   }  

基於Java實現紅黑樹的基本操作

首先，在閱讀文章之前，我希望讀者對二叉樹有一定的瞭解，因為紅黑樹的本質就是一顆二叉樹。所以本篇部落格中不在將二叉樹的增刪查的基本操作了。 有隨機數節點組成的二叉樹的平均高度為logn，所以正常情況下二叉樹查詢的時間複雜度為O(logn)。但是，根據二叉樹的特性，在最壞的情況下，比如儲存的是一個有

用c++實現紅黑樹的判斷、插入、遍歷操作

紅黑樹        紅黑樹是一棵二叉搜尋樹，它在每個節點上增加了一個儲存位來表示節點的顏色，可以是Red或Black。通過對任何一條從根到葉子簡單路徑上的顏色來約束，紅黑樹保證最長路徑不超過最短路徑的兩倍，因而近似於平衡。 紅黑樹是滿足下面紅黑性質的二叉搜尋樹： 1.

【演算法】java版紅黑樹演算法的完整實現及swing介面演示程式

【前言】 當初因為覺得資料結構及演算法是碼農的基礎（正如鋤頭對農民一樣）才決定話費時間來補習的，但是真正自行實現演算法及演算法的視覺化演示的時候才發現難度是如此之大。 演算法寫起來慢，swing介面寫起來也慢。 紅黑樹的結構最重要就是幾個規則： 1、根節點為黑色，NIL

Java 基於紅黑樹的TreeMap,TreeSet實現原理

TreeSet and TreeMap 總體介紹 之所以把TreeSet和TreeMap放在一起講解，是因為二者在Java裡有著相同的實現，前者僅僅是對後者做了一層包裝，也就是說TreeSet裡面有一個TreeMap（介面卡模式）**。因此本文將重點分析TreeMap。

c++實現紅黑樹

現在只是簡單的實現了紅黑樹的調整功能，其餘功能還沒有實現好，等後面的學習中再來新增 #ifndef _RB_TREE_H_ #define _RB_TREE_H_ typedef bool _color_type; const _color_type _color_red

關於用Java實現傳送簡訊（部分程式碼來源於網路）

第一步： 訪問中國網建SMS簡訊通網頁註冊賬號。儲存金鑰。 第二步：編碼實現 編寫JavaBean,定義變數phonenumber，生成get/set方法 建立介面 //傳送簡訊 void send(Player player) throws Exception; //實現

C++實現紅黑樹（插入功能）

lse space num 節點 fine 兩個 外部 type gre practice1.h #ifndef PRACTICE1_H_INCLUDED #define PRACTICE1_H_INCLUDED template<class Comparable

Java 集合 | 紅黑樹 | 前置知識

一、前言 0tnv1e.png 為啥要學紅黑樹吖？ 因為筆者最近在趕專案的時候，不忘抽出時間來複習 Java 基礎知識，現在準備看集合的原始碼啦啦。聽聞，HashMap 在 jdk 1.8 的時候，底層的資料結構發生了變化，變成了陣列+連結串列+紅黑樹。很好，沒了解過紅黑樹，所以就趁今天閒暇學習一下啦 二

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

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

高階資料結構---紅黑樹及其插入左旋右旋程式碼java實現

前面我們說到的二叉查詢樹，可以看到根結點是初始化之後就是固定了的，後續插入的數如果都比它大，或者都比它小，那麼這個時候它就退化成了連結串列了，查詢的時間複雜度就變成了O(n),而不是理想中O(logn),就像這個樣子      如果我們有一個平衡機制，讓這棵樹可以動起來，比如將

數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java）

啟示 dpa con 技術分享 節點數 src 通知 一點 this 　　最終還是決定把紅黑樹的篇章一分為二，插入操作一篇，刪除操作一篇，因為合在一起寫篇幅實在太長了，寫起來都覺得累，何況是閱讀並理解的讀者。 　　　　　　紅黑樹刪除操作請參考 數據結構 - 紅黑樹（Red

數據結構 - 紅黑樹（Red Black Tree）刪除詳解與實現（Java）

replace ati 轉載 之前 9.png one com 四種 簡單 　　本篇要講的就是紅黑樹的刪除操作 　　　　　　紅黑樹插入操作請參考 數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java） 　　紅黑樹的刪除是紅黑樹操作中比較麻煩且比較有意

二叉樹與紅黑樹的java實現

二叉樹的java實現 public class BinaryTree { /** * 根節點 */ private static Node root; static class Node { int key; Node l

深入剖析紅黑樹以及JAVA實現

作者：美團技術團隊 連結：https://zhuanlan.zhihu.com/p/24367771 來源：知乎 著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。   紅黑樹是平衡二叉查詢樹的一種。為了深入理解紅黑樹，我們需要從二叉查詢樹開始講起。 BST

紅黑樹（Red Black Tree）刪除詳解與實現（Java）

　　本篇要講的就是紅黑樹的刪除操作 　　紅黑樹的刪除是紅黑樹操作中比較麻煩且比較有意思的一部分。 　　在此之前，重申一遍紅黑樹的五個定義： 1. 紅黑樹的節點要不是黑色的要不是紅色的 　　　　2. 紅黑樹的根節點一定是黑色的 　　　　3. 紅黑樹的所有葉子節點都是黑色的（注意：紅黑樹的葉子節點指Nil節點

紅黑樹深入剖析及Java實現

紅黑樹是平衡二叉查詢樹的一種。為了深入理解紅黑樹，我們需要從二叉查詢樹開始講起。 BST 二叉查詢樹（Binary Search Tree，簡稱BST）是一棵二叉樹，它的左子節點的值比父節點的值要小，右節點的值要比父節點的值大。它的高度決定了它的查詢效率。 在理想的情況

紅黑樹刪除java實現

package Algorithms; import java.security.Key; public class RedAndBlackDelete<Key extends Comparable<Key>,Value> {     publi

從2-3-4樹到紅黑樹(下) Java與C的實現

歡迎探討，如有錯誤敬請指正 相關部落格： 1. 實現技巧 為了簡化程式碼和減少不必要的開銷，在具體的實現中我們定義一個偽根節點ROOT且只定義一個NIL節點。偽根節點的左子支永遠指向NIL節點，NIL節點的左右子支又指向它自身。偽根節點的右子支才表示真正的紅黑樹。 2. Java語言實現 packa

演算法#16--B樹完整程式碼Java實現

定義 在電腦科學中，B樹（英語：B-tree）是一種自平衡的樹，能夠保持資料有序。這種資料結構能夠讓查詢資料、順序訪問、插入資料及刪除的動作，都在對數時間內完成。 為什麼要引入B樹? 首先，包括前面我們介紹的紅黑樹是將輸入存入記憶體的一種內部查詢樹。 而