JAVA红黑树

最新推荐文章于 2022-12-30 13:05:04 发布
最新推荐文章于 2022-12-30 13:05:04 发布
阅读量573 收藏 1
点赞数
分类专栏： 数据结构与算法

概念：每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色，提高二叉树的查找性能;

特性：

性质1. 节点是红色或黑色。

　　性质2. 根是黑色。

　　性质3. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

　　性质4. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

 

性能：O(log n)的时间之外，每次插入或删除需要O(log n)的空间。
实现：

JAVAQueue:用linkedlist写的队列

[java]  view plain copy
  1. import java.util.LinkedList;  
  2.   
  3. public class JavaQueue {  
  4.   
  5.     /** 
  6.      * @param args 
  7.      */  
  8.     private LinkedList list = new LinkedList();  
  9.   
  10.     public void push(Object v) {  
  11.         list.addFirst(v);  
  12.     }  
  13.     public Object pop() {  
  14.         return list.removeFirst();  
  15.     }  
  16.   
  17.     public Object get() {  
  18.         return list.removeLast();  
  19.     }  
  20.   
  21.     public boolean isEmpty(){  
  22.         return list.isEmpty();  
  23.     }  
  24.   
  25. }  

 

JAVAStack:用linkedlist写的堆栈

              

[java]  view plain copy
  1. import java.util.ArrayList;  
  2. import java.util.HashMap;  
  3. import java.util.LinkedList;  
  4. import java.util.Map;  
  5.   
  6. import com.sun.xml.internal.bind.v2.schemagen.xmlschema.List;  
  7.   
  8. public class JavaStack {  
  9.     private LinkedList list = new LinkedList();  
  10.     public void push(Object v) {  
  11.         list.addFirst(v);  
  12.     }  
  13.     public Object pop(){  
  14.         return list.removeFirst();  
  15.     }  
  16.     public Object top(){  
  17.         return list.getFirst();  
  18.     }  
  19.     public boolean  IsNull(){  
  20.         if(list.size()==0) return true;  
  21.         else return false;  
  22.     }  
  23.     /*public static void main(String[] args) { 
  24.         // TODO Auto-generated method stub 
  25.         JavaStack stack=new JavaStack(); 
  26.         for(int i=0;i<10;i++) 
  27.         { 
  28.             stack.push(i); 
  29.         } 
  30.             System.out.println(stack.top()); 
  31.             stack.pop(); 
  32.             System.out.println(stack.top()); 
  33.         Map map=new HashMap(); 
  34.         A a=new A(); 
  35.         A b=new A(); 
  36.         A c=new A(); 
  37.         int i=0; 
  38.         map.put(i, a); 
  39.         map.put(i++, b); 
  40.         map.put(i++, c); 
  41.     } 
  42. */  
  43. }  

TreeNode:定义的节点类

               

[java]  view plain copy
  1. public class TreeNode {  
  2.     //应该包含五个域,left,right,p,key,color;  
  3.     TreeNode leftNode;//指示左结点  
  4.     TreeNode rightNode;//指示右结点  
  5.     TreeNode pNode;//指示父结点或者NIL(T)哨兵结点  
  6.     int key;//结点的值  
  7.     int color;//其中0表示红，1表示黑  
  8.     public TreeNode getLeftNode() {  
  9.         return leftNode;  
  10.     }  
  11.     public void setLeftNode(TreeNode leftNode) {  
  12.         this.leftNode = leftNode;  
  13.     }  
  14.     public TreeNode getRightNode() {  
  15.         return rightNode;  
  16.     }  
  17.     public void setRightNode(TreeNode rightNode) {  
  18.         this.rightNode = rightNode;  
  19.     }  
  20.     public TreeNode getPNode() {  
  21.         return pNode;  
  22.     }  
  23.     public void setPNode(TreeNode node) {  
  24.         pNode = node;  
  25.     }  
  26.     public int getKey() {  
  27.         return key;  
  28.     }  
  29.     public void setKey(int key) {  
  30.         this.key = key;  
  31.     }  
  32.     public int getColor() {  
  33.         return color;  
  34.     }  
  35.     public void setColor(int color) {  
  36.         this.color = color;  
  37.     }  
  38.     //默认构造函数  
  39.     public TreeNode(TreeNode leftNode,TreeNode rightNode,TreeNode pNode,int  key,int color){  
  40.         this.leftNode=leftNode;  
  41.         this.rightNode=rightNode;  
  42.         this.pNode=pNode;  
  43.         this.key=key;  
  44.         this.color=color;  
  45.     }  
  46. }  

TestRBT类：主要功能实现

              

[java]  view plain copy
  1. import javax.swing.JOptionPane;  
  2. import javax.swing.text.DefaultEditorKit.InsertBreakAction;  
  3.   
  4. import sun.management.counter.Variability;  
  5.   
  6. import com.sun.org.apache.regexp.internal.recompile;  
  7. import com.sun.org.apache.xml.internal.security.Init;  
  8.   
  9. public class TestRBT {  
  10.   
  11.     /** 
  12.      * @param args 
  13.      */  
  14.     public static void main(String[] args) {  
  15.         // TODO Auto-generated method stub  
  16.         // 1.建立一棵树，并进行初始化，也可通过插入节点进行建树  
  17.         // TreeNode[] node = new TreeNode[23];  
  18.         // 插入结点操作  
  19.         TreeNode nil = new TreeNode(null, null, null, -1, 1);//设定哨兵节点  
  20.         creatTree(nil);// 通过插入结点创建树，并以哨兵节点的父指针指向根节点  
  21.         showTree(nil.pNode, nil);// 展示插入建树后的结果  
  22.         deleteTree(nil, 8);// 删除节点，删除的节点也可从外部传入  
  23.         System.out.println("删除结点后：");  
  24.         showTree(nil.pNode, nil);// 展示删除树结点的结果  
  25.     }  
  26.   
  27.     public static void initTree(TreeNode node, TreeNode nil) {  
  28.         //初始化构造树int[] a={1,2,5,7,8,11,14,15,4}  
  29.         TreeNode tempnode = new TreeNode(nil, nil, nil, -1, 1);  
  30.         node.leftNode = new TreeNode(nil, nil, node, 2, 0);  
  31.         node.rightNode = new TreeNode(nil, nil, node, 14, 1);  
  32.   
  33.         tempnode = node.leftNode;  
  34.         tempnode.leftNode = new TreeNode(nil, nil, tempnode, 1, 1);  
  35.         tempnode.rightNode = new TreeNode(nil, nil, tempnode, 7, 1);  
  36.   
  37.         tempnode = tempnode.rightNode;  
  38.         tempnode.leftNode = new TreeNode(nil, nil, tempnode, 5, 0);  
  39.         tempnode.rightNode = new TreeNode(nil, nil, tempnode, 8, 0);  
  40.   
  41.         tempnode = node.rightNode;  
  42.         tempnode.rightNode = new TreeNode(nil, nil, tempnode, 15, 0);  
  43.         /* 
  44.          * int i = 2; while (i < 23) { if ((i == 2) || (i == 3) || (i == 4) || 
  45.          * (i == 6) || (i == 7) || (i == 9) || (i == 11) || (i == 12) || (i == 
  46.          * 14) || (i == 17) || (i == 18) || (i == 19) || (i == 20) || (i == 22)) 
  47.          * node[i] = new TreeNode(nil, nil, nil, i, 1); i++; } // 赋值 
  48.          * node[7].setLeftNode(node[4]); node[7].setRightNode(node[11]); 
  49.          * node[4].setLeftNode(node[3]); node[4].setRightNode(node[6]); 
  50.          * node[4].setPNode(node[7]); node[3].setLeftNode(node[2]); 
  51.          * node[3].setPNode(node[4]); node[2].setPNode(node[3]); 
  52.          * node[6].setPNode(node[4]); 
  53.          *  
  54.          * node[11].setLeftNode(node[9]); node[11].setRightNode(node[18]); 
  55.          * node[11].setPNode(node[7]); 
  56.          *  
  57.          * node[18].setLeftNode(node[14]); node[18].setRightNode(node[19]); 
  58.          * node[18].setPNode(node[11]); 
  59.          *  
  60.          * node[14].setLeftNode(node[12]); node[14].setRightNode(node[17]); 
  61.          * node[14].setPNode(node[18]); 
  62.          *  
  63.          * node[19].setRightNode(node[22]); node[19].setPNode(node[18]); 
  64.          *  
  65.          * node[22].setLeftNode(node[20]); node[22].setPNode(node[19]); 
  66.          *  
  67.          * node[12].setPNode(node[14]); node[17].setPNode(node[14]); 
  68.          * node[20].setPNode(node[22]); // show(node); 
  69.          *  
  70.          */  
  71.     }  
  72.   
  73.     public static void showTree(TreeNode node, TreeNode nil) {  
  74.         // 中序循环遍历树  
  75.         /* 
  76.          * JavaStack stack = new JavaStack(); // 将根结点输入栈中 while (node != nil || 
  77.          * !stack.IsNull()) { if (node != nil) { stack.push(node); node = 
  78.          * node.leftNode; } else { TreeNode tempnode = (TreeNode) stack.pop(); 
  79.          * System.out.print(tempnode.key+" " ); if (tempnode.rightNode != nil) 
  80.          * node = tempnode.rightNode; } } 
  81.          */  
  82.         // 层次遍历，分别打印出树的根结点,不用递归用循环提高效率  
  83.         JavaQueue queue = new JavaQueue();  
  84.         queue.push(node);// 将根结点输入栈中  
  85.         while (!queue.isEmpty()) {//队列不为空则出队列，继续添加新节点  
  86.             /**/  
  87.             TreeNode tempnode = (TreeNode) queue.get();  
  88.             int key = tempnode.key;  
  89.             StringBuffer str = new StringBuffer();//通过StringBuffer进行输出  
  90.             str.append("key:" + key);  
  91.             if (tempnode.color == 0) {  
  92.                 str.append(" color:红色");  
  93.             } else {  
  94.                 str.append(" color:黑色");  
  95.             }  
  96.             if (tempnode.leftNode != nil && tempnode.leftNode != null) {  
  97.                 str.append(" lefttree:" + tempnode.leftNode.key);  
  98.                 queue.push(tempnode.leftNode);  
  99.             }  
  100.   
  101.             if (tempnode.rightNode != nil) {  
  102.                 str.append(" righttree:" + tempnode.rightNode.key);  
  103.                 queue.push(tempnode.rightNode);  
  104.             }  
  105.             System.out.println(str.toString());  
  106.         }  
  107.     }  
  108.   
  109.     public static void leftRotate(TreeNode xnode, TreeNode nil) {  
  110.         //左旋转的实际为改变节点的前趋后继,三个节点，当前节点，当前节点的右节点，当前节点右节点的左节点  
  111.         TreeNode yNode = xnode.rightNode;// 设置右孩子为y结点  
  112.         xnode.rightNode = yNode.leftNode;  
  113.         if (yNode.leftNode != nil)  
  114.             yNode.leftNode.pNode = xnode;  
  115.         yNode.pNode = xnode.pNode;  
  116.         if (xnode.pNode == nil) {  
  117.             nil.pNode = yNode;  
  118.         } else if (xnode == xnode.pNode.leftNode) {  
  119.             xnode.pNode.leftNode = yNode;  
  120.         } else {  
  121.             xnode.pNode.rightNode = yNode;  
  122.         }  
  123.         yNode.leftNode = xnode;  
  124.         xnode.pNode = yNode;  
  125.     }  
  126.   
  127.     public static void rightRotate(TreeNode xnode, TreeNode nil) {  
  128.         TreeNode yNode = xnode.leftNode;// 设置左孩子为y结点  
  129.         xnode.leftNode = yNode.rightNode;  
  130.         if (yNode.rightNode != nil) {  
  131.   
  132.             yNode.rightNode.pNode = xnode;  
  133.         }  
  134.         yNode.pNode = xnode.pNode;  
  135.         if (xnode.pNode == nil) {  
  136.             nil.pNode = yNode;  
  137.         } else if (xnode == xnode.pNode.rightNode) {  
  138.             xnode.pNode.rightNode = yNode;  
  139.         } else {  
  140.             xnode.pNode.leftNode = yNode;  
  141.         }  
  142.         yNode.rightNode = xnode;  
  143.         xnode.pNode = yNode;  
  144.     }  
  145.   
  146.     public static void InsertTreeNode(int i, TreeNode nil) {  
  147.         TreeNode newnode = new TreeNode(nil, nil, nil, i, 0);// 设置新插入结点初始值为i  
  148.         TreeNode tempnode = new TreeNode(nil, nil, nil, -1, 0);// 设置比较结点的父结点  
  149.         TreeNode recnode = new TreeNode(nil, nil, nil, -1, 0);// 设置一个循环树结点  
  150.         // 执行查找过程，找到相应的位置并进行插入，随后进行红黑性质的插入调整  
  151.         recnode = nil.pNode;  
  152.         if (recnode == null) {  
  153.             nil.pNode = newnode;  
  154.             newnode.color = 1;  
  155.         } else {  
  156.             while (recnode != nil) {  
  157.                 tempnode = recnode;  
  158.                 if (i < recnode.key) {  
  159.                     recnode = recnode.leftNode;  
  160.                 } else {  
  161.                     recnode = recnode.rightNode;  
  162.                 }  
  163.             }  
  164.             newnode.pNode = tempnode;  
  165.             if (newnode.key < tempnode.key) {  
  166.                 tempnode.leftNode = newnode;  
  167.             } else {  
  168.                 tempnode.rightNode = newnode;  
  169.             }  
  170.             // 执行修补程序  
  171.             InsertTreeNodeFixup(nil, newnode);  
  172.         }  
  173.     }  
  174.   
  175.     public static void InsertTreeNodeFixup(TreeNode nil, TreeNode newnode) {  
  176.         TreeNode tempnode = new TreeNode(nil, nil, nil, -1, 0);  
  177.         /*执行插入主要解决红红冲突，具体情况有三种，注意插入的结点默认均为红色 
  178.          * 1.newnode 的叔叔为红,即将其父，叔结点均置为黑 
  179.          * 2.newnode 的叔叔是黑，newnode为父结点的右孩子 
  180.          * 3.newnode 的叔叔是黑，newnode为父结点的左孩子 
  181.          * 2,3的解决办法是先进行一次相应方向的旋转(左子树即左转，右子树即右转)，然后将newnode设为祖父结点， 
  182.          * 进行相应的反方向转动，最后设置根结点值为黑色 
  183.          * 插入操作可通过两次旋转彻底解决平衡问题 
  184.         */  
  185.         while (newnode.pNode.color == 0) {  
  186.             if (newnode.pNode == newnode.pNode.pNode.leftNode) {  
  187.                 tempnode = newnode.pNode.pNode.rightNode;// 叔父结点为爷爷的左子树  
  188.                 if (tempnode.color == 0) {// 叔父结点为红  
  189.                     newnode.pNode.color = 1;  
  190.                     tempnode.color = 1;  
  191.                     newnode.pNode.pNode.color = 0;  
  192.                     newnode = newnode.pNode.pNode;  
  193.                 } else {  
  194.                     if (newnode == newnode.pNode.rightNode)// 叔父结点为黑并为其父爷点的左子树  
  195.                     {  
  196.                         newnode = newnode.pNode;  
  197.                         leftRotate(newnode, nil);  
  198.                     }  
  199.                     newnode.pNode.color = 1;  
  200.                     newnode.pNode.pNode.color = 0;  
  201.                     rightRotate(newnode.pNode.pNode, nil);  
  202.                 }  
  203.             } else {  
  204.                 tempnode = newnode.pNode.pNode.leftNode;// 叔父结点为爷爷的右子树  
  205.                 if (tempnode.color == 0) {// 叔父结点为红  
  206.                     newnode.pNode.color = 1;  
  207.                     tempnode.color = 1;  
  208.                     newnode.pNode.pNode.color = 0;  
  209.                     newnode = newnode.pNode.pNode;  
  210.                 } else // 叔父结点为黑并为其父爷点的左子树  
  211.                 {  
  212.                     if (newnode == newnode.pNode.leftNode) {  
  213.                         newnode = newnode.pNode;  
  214.                         rightRotate(newnode, nil);  
  215.                     }  
  216.                     newnode.pNode.color = 1;  
  217.                     newnode.pNode.pNode.color = 0;  
  218.   
  219.                     leftRotate(newnode.pNode.pNode, nil);  
  220.                 }  
  221.             }  
  222.         }  
  223.         nil.pNode.color = 1;  
  224.     }  
  225.   
  226.     public static void creatTree(TreeNode nil) {  
  227.         // 新建NIL[T]结点  
  228.         // int number = Integer.parseInt(JOptionPane.showInputDialog("请输入个数:"));  
  229.         int[] number = new int[] { 1, 2, 5, 7, 8, 11, 14, 15, 4 };  
  230.         // int[] number = new int[] { 8,11,17,15,6,1,22,25,27 };  
  231.         for (int i = 0; i < number.length; i++) {  
  232.             // int inputValue = Integer.parseInt(JOptionPane  
  233.             // .showInputDialog("请输入树节点值:"));  
  234.             int inputValue = number[i];  
  235.             InsertTreeNode(inputValue, nil);  
  236.         }  
  237.     }  
  238.   
  239.     public static void deleteTree(TreeNode nil, int i) {  
  240.         /*删除结点主要考虑三个问题： 
  241.          * 1.删除的为叶子节点，即左右子树为空 
  242.          * 2.删除的为带一棵子树的结点 
  243.          * 前面两种情况可以合并讨论，都是直接让父结点指向孩子结点或空节点(左右子树为空时)，删除后设置 
  244.          * 旋转结点，进行修复 
  245.          * 3.删除的为有左右子树的结点，需要取得其后继结点，作为新结点 
  246.          *  
  247.           
  248.          *  
  249.          * 
  250.          *  
  251.          *  
  252.          * */  
  253.         // 查找到删除节点，从根结点开始循环遍历  
  254.         TreeNode zNode = new TreeNode(nil, nil, nil, i, 1);  
  255.         TreeNode xNode = new TreeNode(nil, nil, nil, -1, 1);  
  256.         TreeNode tempNode = nil.pNode;// 设置根结点  
  257.         TreeNode rootnode= new TreeNode(nil, nil, nil, -1, 1);  
  258.   
  259.         boolean mark = false;// 查找对象结点  
  260.         while (tempNode != nil && mark == false) {  
  261.             if (zNode.key < tempNode.key) {  
  262.                 tempNode = tempNode.leftNode;  
  263.             } else if (zNode.key > tempNode.key) {  
  264.                 tempNode = tempNode.rightNode;  
  265.             } else {  
  266.                 zNode = tempNode;  
  267.                 mark = true;  
  268.             }  
  269.         }  
  270.         // zNode即为当前节点，进行删除操作  
  271.         TreeNode yNode = new TreeNode(nil, nil, nil, -1, 1);//y结点用于指示被删除节点  
  272.         if ((zNode.leftNode == nil) || (zNode.rightNode == nil)) {  
  273.             yNode = zNode;// 用yNode指向将被删除的结点  
  274.         } else {  
  275.             yNode = lookAfterNode(nil, zNode);// 寻找后继节点  
  276.         }  
  277.         // 进行删除，通过后继与父母结点之间建立双向关系进行删除  
  278.         if (yNode.leftNode != nil) {  
  279.             xNode = yNode.leftNode;  
  280.         } else {  
  281.             xNode = yNode.rightNode;  
  282.         }  
  283.         if ((zNode.leftNode == nil) && (zNode.rightNode == nil)) {  
  284.             rootnode=xNode.pNode;//此时指向空值时，nil的父母节点会改变，所以在此保留根结点，最后恢复时可用  
  285.         }  
  286.         xNode.pNode = yNode.pNode;  
  287.         // //  
  288.   
  289.         if (yNode.pNode == nil) {  
  290.             nil.pNode = xNode;  
  291.         } else if (yNode == yNode.pNode.leftNode) {  
  292.             yNode.pNode.leftNode = xNode;  
  293.         } else {  
  294.             yNode.pNode.rightNode = xNode;  
  295.         }  
  296.         if (yNode != zNode) {  
  297.             zNode.key = yNode.key;  
  298.         }  
  299.         if (yNode.color == 1) {//解决黑黑冲突，如果为红则不需要改变  
  300.             deleteTreeFixUp(nil, xNode);  
  301.         }  
  302.         nil.pNode=rootnode;//还原根结点为nit的父母结点  
  303.     }  
  304.   
  305.     public static TreeNode lookAfterNode(TreeNode nil, TreeNode node) {  
  306.         TreeNode returnNode = new TreeNode(nil, nil, nil, -1, 0);  
  307.         if (node.rightNode != nil) {  
  308.             returnNode = node.rightNode;  
  309.             while (returnNode.leftNode != nil) {  
  310.                 returnNode = returnNode.leftNode;  
  311.             }  
  312.             return returnNode;  
  313.         }  
  314.         returnNode = node.pNode;  
  315.         while (returnNode != nil && node == returnNode.rightNode) {  
  316.             node = returnNode;  
  317.             returnNode = node.pNode;  
  318.         }  
  319.         return returnNode;  
  320.     }  
  321.   
  322.     public static void deleteTreeFixUp(TreeNode nil, TreeNode xNode) {  
  323.         /*  删除修复： 
  324.          *  1.x的兄弟w是红色的 
  325.          *  2.x的兄弟w是黑色的，而且w的两个孩子都是黑色的 
  326.          *  3.x的兄弟w是黑色的，而且w的左孩子为红，右孩子为黑 
  327.          *  4.x的兄弟w是黑色的，而且w的左孩子为黑，右孩子为红 
  328.          *  */  
  329.         TreeNode adjustNode = new TreeNode(nil, nil, nil, -1, 1);  
  330.         while (xNode != nil.pNode && xNode.color == 1) {  
  331.             if (xNode == xNode.pNode.leftNode) {  
  332.                 adjustNode = xNode.pNode.rightNode;  
  333.                 if (adjustNode.color == 0) {  
  334.                     adjustNode.color = 1;  
  335.                     xNode.pNode.color = 0;  
  336.                     leftRotate(xNode.pNode, nil);  
  337.                     adjustNode = xNode.pNode.rightNode;  
  338.                 }  
  339.                 if (adjustNode.leftNode.color == 1  
  340.                         && adjustNode.rightNode.color == 1) {  
  341.                     adjustNode.color = 0;  
  342.                     xNode = xNode.pNode;  
  343.                 } else if (adjustNode.rightNode.color == 1) {  
  344.                     adjustNode.leftNode.color = 1;  
  345.                     adjustNode.color = 0;  
  346.                     rightRotate(adjustNode, nil);  
  347.                     adjustNode = xNode.pNode.rightNode;  
  348.                 }  
  349.                 adjustNode.color = adjustNode.pNode.color;  
  350.                 adjustNode.pNode.color = 1;  
  351.                 adjustNode.rightNode.color = 1;  
  352.                 leftRotate(xNode.pNode, nil);  
  353.                 xNode = nil.pNode;  
  354.             } else {  
  355.                 adjustNode = xNode.pNode.leftNode;  
  356.                 if (adjustNode.color == 0) {  
  357.                     adjustNode.color = 1;  
  358.                     xNode.pNode.color = 0;  
  359.                     rightRotate(xNode.pNode, nil);  
  360.                     adjustNode = xNode.pNode.leftNode;  
  361.                 }  
  362.                 if (adjustNode.rightNode.color == 1  
  363.                         && adjustNode.leftNode.color == 1) {  
  364.                     adjustNode.color = 0;  
  365.                     xNode = xNode.pNode;  
  366.                 } else if (adjustNode.leftNode.color == 1) {  
  367.                     adjustNode.rightNode.color = 1;  
  368.                     adjustNode.color = 0;  
  369.                     leftRotate(adjustNode, nil);  
  370.                     adjustNode = xNode.pNode.leftNode;  
  371.                 }  
  372.                 adjustNode.color = adjustNode.pNode.color;  
  373.                 adjustNode.pNode.color = 1;  
  374.                 adjustNode.leftNode.color = 1;  
  375.                 rightRotate(xNode.pNode, nil);  
  376.                 xNode = nil.pNode;  
  377.             }  
  378.         }  
  379.         xNode.color = 1;  
  380.     }  
  381. }  

海阔天空&沫语
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 红黑树实现.rar
04-27
java 实现红黑树的增删改查
Java——红黑树
m0_60867520的博客
12-14 1808
红黑树的概念，性质，插入的详细代码及讲解，验证红黑树的代码及详解，附带详细图解
java——红黑树
weixin_46362658的博客
03-01 415
红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构 每一个节点可以是红或者黑；红黑树不是通过高度平衡的，他的平衡时通过“红黑规则”进行实现的 红黑规则 每一个节点或者红色，或者是黑色，根节点必须是黑色。 如果一个节点没有子节点或者父节点，则该节点相应的制作属性值为Nil，则这些Nil视为叶节点，叶节点是黑色 如果某一个节点是红色，那么他的子节点必须是黑色（不能出现两个红色节点相连的情况） 每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点 与其他二叉树对比，多了一.
Java-红黑树
weixin_45203607的博客
01-28 550
学习注意事项 必须会二叉搜索树 必须会AVL树 必须知道什么是L , R ,RL , LR 这些旋转概念 以上概念,我博客里都有自行寻找…下面就开始红黑树的讲解了 介绍 红黑树必须满足的5个条件 和AVL树的比较 AVL树是一棵严格的平衡树，它所有的子树都满足二叉平衡树的定义。因此AVL树高被严格控制在(-1 ,1,+1)，因此AVL树的查找比较高效。但AVL树插入、删除结点后旋转的次数比红黑树多。红黑树用非严格的平衡来降低插入删除时旋转的次数。因此，如果你的业务中查找远远多于插入、删除，那选
Java之红黑树
qq_41720578的博客
04-28 4859
1、简介 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。 红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是
最简单的Java红黑树的变色、旋转与自平衡原理.pptx
11-11
最简单的Java红黑树的变色、旋转与自平衡原理。红黑树的定义性质与原理，红黑树自平衡的原子操作，权威最简单红黑树的新增操作。
Java红黑树代码-节点
02-23
红黑树关键代码，遍历的代码可以自己写，也可以参考我的，不过里面有个队列要自己实现。
java实现红黑树
12-31
用java实现的红黑树，参照《算法导论》第三版实现。OrdRow.java--这个为节点的定义；OrdDataSet.java为红黑树的实现
Java红黑树代码
02-23
红黑树关键代码，遍历的代码可以自己写，也可以参考我的，不过里面有个队列要自己实现。
Java 红黑树
u012737182的博客
08-25 500
概要 前面分别介绍红黑树的理论知识、红黑树的C语言和C++的实现。本章介绍红黑树的Java实现，若读者对红黑树的理论知识不熟悉，建立先学习红黑树的理论知识，再来学习本章。还是那句老话，红黑树的C/C++/Java实现，原理一样，择其一了解即可。 目录1. 红黑树的介绍2. 红黑树的Java实现(代码说明)3. 红黑树的Java实现(完整源码)4. 红黑树的Java测试程序 转载请注明出处：更多内容：
java红黑树
weixin_35755434的博客
12-30 320
Java 红黑树是一种平衡二叉树，它的每个节点都有一个颜色属性，可以是 "红" 或 "黑"。它的每条路径都至少包含相同数量的黑色节点，这使得它的最坏情况下的查询性能比一般二叉搜索树要优秀。红黑树的插入、删除和查找操作的时间复杂度均为 O(logn)，这使得它在需要频繁执行这些操作的场景中非常有用。 Java 红黑树是 Java 的 java.util.TreeMap 类的底层数据结构。它用于存储有...
Java红黑树
u012075079的专栏
04-28 202
https://www.cnblogs.com/CarpenterLee/p/5503882.html 红黑树的特点： 1. 一个节点只能是黑色或者红色 2. 根节点必须是黑色 3. 不能有两个红色节点相互连接 4. 任何一个节点，它到所有叶子节点对应的所有路径必须包含相同数目的黑色节点 当有节点添加或删除的时候，为了保证红黑树的这四个特征不变，必须对树进行调整： 1
java的红黑树_java红黑树
weixin_39631445的博客
02-16 60
红黑树性质1、每个结点或是红色的，或是黑色的2、根节点是黑色的3、每个叶结点(NIL)是黑色的4、如果一个节点是红色的，则它的两个儿子都是黑色的。5、对于每个结点，从该结点到其叶子结点构成的所有路径上的黑结点个数相同。和AVL树的比较AVL树是一棵严格的平衡树，它所有的子树都满足二叉平衡树的定义。因此AVL树高被严格控制在XXX，因此AVL树的查找比较高效。但AVL树插入、删除结点后旋转的次数比红...
java红黑树_JAVA红黑树
weixin_33458169的博客
02-12 39
是一颗绝对平衡的树import java.util.ArrayList;public class RBTree, V> {private static final boolean RED = true;private static final boolean BLACK = false;private class Node{public K key;public V value;public...
红黑树（Java实现）
weixin_45567738的博客
05-09 1560
RBTree 根节点是黑色 每个叶子节点都是黑色的空结点（NIL结点）（为了简单期间，一般会省略该节点） 如果一个节点是红色的，则它的子节点必须是黑色的（父子不能同为红） 从任一结点到其每个叶子的所有路径都包含相同数目的黑色结点（平衡的关键） 新插入节点默认为红色，插入后需要校验红黑树是否符合规则，不符合则需要进行平衡 节点 package com.richard.brtree; public class BRTreeNode { private int key; private
Java实现红黑树
HMH_huige的博客
06-06 213
Java实现红黑树
java 红黑树实现
最新发布
11-15
以下是一个简单的Java红黑树实现示例： ```java public class RBNode<T extends Comparable<T>> { boolean color;//颜色 T key;//关键字(键值) RBNode<T> left;//左子节点 RBNode<T> right;//右子节点 RBNode...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值