ipl-logo

DSLectureNotes7

.docx
School
New York Institute of Technology, Manhattan**We aren't endorsed by this school
Course
CSCI 507
Subject
Computer Science
Date
Dec 18, 2024
Pages
23
Uploaded by AgentExplorationHamster52
Lecture Notes 7Data StructuresSpring 2022CSCI 260Prof. F. FischmanRed-Black TreesAVL Trees and Red-Black Trees are both self-balancing BSTs, but they differ in terms of their balancing strategies and theproperties they maintain. Here are the key differences between AVL Trees and Red-Black Trees:Balancing Strategy:AVL Trees:AVL Trees use a stricter balancing strategy. They ensure that the balance factor (the height differencebetween left and right subtrees) for every node is at most 1, which results in a balanced tree. AVL Trees require more rotations to maintain this strict balance, making them slightly more rigid but potentially morebalanced.Red-Black Trees:Red-Black Trees use a more relaxed balancing strategy. They ensure that certain properties aremaintained, such as ensuring that no two consecutive nodes are red and that the black height of every path from theroot to any leaf node is the same. While this doesn't guarantee perfect balance, it does ensure that the tree remainsrelatively balanced and requires fewer rotations.Rotation Operations:AVL Trees:AVL Trees may require more rotation operations during insertion and deletion to maintain balance. Theserotations are LL (Left-Left), LR (Left-Right), RR (Right-Right), and RL (Right-Left) rotations.Red-Black Trees:Red-Black Trees typically require fewer rotations compared to AVL Trees. The primary rotations usedare left rotations and right rotations to maintain the Red-Black properties.Height:AVL Trees: AVL Trees tend to have a more balanced height due to their strict balancing criteria. The height is guaranteedto be logarithmic in the number of nodes.Red-Black Trees: Red-Black Trees may have a slightly larger height on average compared to AVL Trees but still maintain aheight that is logarithmic in the number of nodes.Memory Overhead:AVL Trees: AVL Trees require more memory to store additional height information for each node, as they need tomaintain a strict balance.Red-Black Trees:Red-Black Trees have a smaller memory overhead compared to AVL Trees, making them morememory-efficient.Performance:AVL Trees:AVL Trees tend to have slightly faster lookup times than Red-Black Trees due to their stricter balancing.However, the cost of maintaining balance through rotations can make insertion and deletion slightly slower.
Background image
Red-Black Trees: Red-Black Trees are efficient for insertion and deletion operations, especially in cases where theseoperations are frequent. They are often favored in scenarios like databases where data is frequently modified.A BST with the following extra characteristics is known as a red-black tree:Both red and black are used to color each node.Black marks the rootThe "no multiple reds" rule states that a red node cannot have another red child. There are exactly as many black nodeson each path that leads to a null, which is known as the "equal exit cost".Naturally, the nodes aren't colored in reality. Each node only sports a flag designating whether it is regarded as red orblack.Example: Valid Red-Black TreeThe root node (10) is black.There are no two consecutive red nodes along any path (no red node has a red child).If you examine any path from the root to a null (e.g., from 10 to 2 or from 20 to 35), you will see that there is the samenumber of black nodes along each path (2 black nodes).This tree satisfies all the Red-Black tree properties and is valid.
Background image
Example: Invalid Red-Black Tree The path from the node with value 30 to the node with value 35 violates the "no multiple reds" rule because there aretwo consecutive red nodes (30 and 35) along this path. This tree does not satisfy the Red-Black tree properties and isinvalid.In practical implementations, red nodes are typically represented using a single bit or flag (e.g., a boolean variable)associated with each node, rather than explicitly storing a color attribute, to minimize memory usage making themsuitable for practical implementations in various data structures and algorithms.Example: Consider a Red-Black treeWe represent the color of each node using a single bit. Here's how the tree would look in memory:Node: 10 (Black)- Color: 0 (Black)- Left: Pointer to Node 5- Right: Pointer to Node 20- Value: 10Node: 5 (Red)- Color: 1 (Red)- Left: Pointer to Node 2- Right: Pointer to Node 7- Value: 5Node: 20 (Red)- Color: 1 (Red)- Left: Pointer to Node 15- Right: Pointer to Node 30- Value: 20
Background image
Node: 2 (Black)- Color: 0 (Black)- Left: Null- Right: Null- Value: 2Node: 7 (Black)- Color: 0 (Black)- Left: Null- Right: Null- Value: 7Node: 15 (Black)- Color: 0 (Black)- Left: Null- Right: Null- Value: 15Node: 30 (Black)- Color: 0 (Black)- Left: Null- Right: Pointer to Node 35- Value: 30Node: 35 (Red)- Color: 1 (Red)- Left: Null- Right: Null- Value: 35Each node has a color attribute that requires only a single bit to indicate red or black. The left and right attributes pointto the child nodes, and the value attribute stores the value associated with each node. The color bits are 0 for black and1 for red.In practical implementations, black nodes are typically represented using a single bit or flag (e.g., a boolean variable)associated with each node, rather than explicitly storing a color attribute. This approach minimizes memory usage whilestill ensuring proper balancing.In a Red-Black tree, instead of explicitly storing a color attribute, you can use a single bit to indicate whether a node isblack. This color bit can be a boolean variable, where false represents black and true represents red. This way, eachnode only requires an extra bit to store its color, which is efficient in terms of memory usage.Example: Consider a Red-Black tree:
Background image
We represent the color of each node using a single bit, with false indicating black and true indicating red. Here's how thetree would look in memory:Node: 10- Color Bit: false (Black)- Left: Pointer to Node 5- Right: Pointer to Node 20- Value: 10Node: 5- Color Bit: false (Black)- Left: Pointer to Node 2- Right: Pointer to Node 7- Value: 5Node: 20- Color Bit: true (Red)- Left: Pointer to Node 15- Right: Pointer to Node 30- Value: 20Node: 2- Color Bit: false (Black)- Left: Null- Right: Null- Value: 2Node: 7- Color Bit: false (Black)- Left: Null- Right: Null- Value: 7Node: 15- Color Bit: false (Black)- Left: Null- Right: Null- Value: 15Node: 30- Color Bit: false (Black)
Background image
- Left: Null- Right: Pointer to Node 35- Value: 30Node: 35- Color Bit: true (Red)- Left: Null- Right: Null- Value: 35Each node has a single color bit attribute, which requires only a single bit to indicate whether it is black (false) or red(true).The left and right attributes point to the child nodes, and the value attribute stores the value associated with each node.The color bit is false for black nodes and true for red nodes.It is more practical, to think of each node as a toll booth rather than the colors. The black toll booths cost $1 each, butthe red toll booths are free as you move from the root to one of the null references (an exit). No matter which exit youchoose, the cost of the trip will be the same, according to the "same exit cost" criterion.Many authors choose to substitute dummy black leaves for the nulls because they are a bit of a hassle. Next, eitherevery node is one of those dummy leaves or has two children. In an algorithms course, it's nice that the most succinct descriptions condense red-black trees to 2-4 trees, but here is asimpler way of doing it.Think of AVL Trees
Background image
You add a node as usual and give it the color red. If its parent is also red, rearrange according to the illustration. The rednode continues all the way to the root. If necessary, repeat. Color the red node black if it reaches the root.How come it works? The cost of passing through the nodes remains the same after the transformation; it is $1 both before and after. If itcomes to that, altering the root from red to black simply raises the cost of each journey by $1.Use the normal removal procedure for BSTs first, just like with insertion. Keep in mind that the eliminated node in thatalgorithm has just one child at most. A node with two children is never removed; instead, it is filled with the value of anode with one child or less before the other node is eliminated.It's simple in two circumstances. The removal is not problematic if the node to be removed is red because the final treewill still be a red-black tree. Next, suppose the node that is being removed has a child. The child must be red in order tocomply with the "same exit cost" requirement. Just make the child black and take away the parent.The removal of a black leaf presents a challenging situation. It would be too cheap to replace it with a null if we simplyremoved it. Rather, we'll first make it a red node. First carry out the safe removal, then transform. In this way, nulls anddummy leaves won't be an issue.The black leaf X should be eliminated from six different spots. Keep in mind that a black leaf must always have a sibling,and a red parent cannot have a red sibling.
Background image
Temporarily "bubble up" the expenses by increasing the cost of the parent by $1 and decreasing the cost of the childrenby $1 in order to change a black node into a red one.It is obvious that "bubbling up" keeps all path costs constant.Bubbling up simply changes the red node into a black one and the black ones become red ones in the first column of thesix situations mentioned above. The red one is taken out. With one of its offspring, the other might result in a double-red violation, in which case we repair it. But in the other situations, a fresh issue appears. Nodes with prices of 2 or -1are what are referred to as double-black and negative-red, respectively. In the analogy of the toll booth, a double-blacknode costs $2, and every time you pass through a negative-red node, you receive $1. These are obviously invalid nodesin a red-black tree, so we must remove them.The transformation depicted below, or its mirror counterpart, can delete the pair since a negative-red node is always achild of a double-black node.The development of a double-black node can occasionally result in a double-red violation below. By using the transformbroadly, we may correct the double-red violation. Any cost that the gray node has is lowered by $1.
Background image
The preservation of all trip expenses by both transformations can be easily verified. When neither of the twotransformations is applicable, we must occasionally "bubble up" once more, bringing the double-black node closer to theroot.We can swap out the double-black node for a standard black node if it reaches the root.import java.util.ArrayList;import java.util.List;
Background image
public class RBTree{Node rootRBT; // Package access, for testingstatic final int BLK = 1;static final int Red = 0;private static final int Neg_Red = -1;private static final int Double_BLK = 2;public RBTree(){rootRBT = null;}public void addRBT(Comparable objRBT){Node newNodeRBT = new Node();newNodeRBT.data = objRBT;newNodeRBT.leftRBT = null;newNodeRBT.rightRBT = null;if (rootRBT == null) { rootRBT = newNodeRBT; }else { rootRBT.addNodeRBT(newNodeRBT); }fixAfterAddRBT(newNodeRBT);}public boolean find(Comparable objRBT){Node currentRBT = rootRBT;while (currentRBT != null){int dRBT = currentRBT.dataRBT.compareTo(objRBT);if (dRBT == 0) return true;else if (dRBT > 0) currentRBT = currentRBT.leftRBT;else currentRBT = currentRBT.rightRBT;}return false;}public void remove(Comparable obj){Node beRemovedRBT = rootRBT;boolean foundRBT = false;while (!foundRBT && beRemovedRBT != null){int dRBT = beRemovedRBT.dataRBT.compareTo(objRBT);if (dRBT == 0) { foundRBT = true; }else{if (dRBT > 0) { beRemovedRBT = beRemovedRBT.leftRBT; }else { beRemovedRBT = beRemovedRBT.rightRBT; }}}
Background image
if (!foundRBT) { return; }if (beRemovedRBT.leftRBT == null || beRemovedRBT.rightRBT == null){Node newChildRBT;if (beRemovedRBT.leftRBT == null) { newChildRBT = beRemovedRBT.rightRBT; }else { newChildRBT = beRemovedRBT.leftRBT; }fixBeforeRemoveRBT(beRemovedRBT); if (toBeRemovedRBT.parentRBT == null) { rootRBT = newChildRBT; } else { toBeRemoved.replaceWith(newChild); }return;}Node smallestRBT = beRemovedRBT.rightRBT;while (smallestRBT.leftRBT != null){smallestRBT = smallestRBT.leftRBT;}beRemovedRBT.dataRBT = smallestRBT.dataRBT;fixBeforeRemoveRBT(smallestRBT);smallestRBT.replaceWithRBT(smallestRBT.rightRBT);}public void inOrderVisitRBT(Visitor vRBT){inOrderVisitRBT(rootRBT, vRBT);}public static interface VisitorRBT{void visitRBT(Node nRBT);}private static void inOrderVisitRBT(Node nRBT, Visitor vRBT){if (nRBT == null) return;inOrderVisitRBT(nRBT.leftRBT, vRBT);vRBT.visitRBT(nRBT);inOrderVisitRBT(nRBT.rightRBT, vRBT);}static class NodeRBTree{
Background image
public Comparable dataRBT;public Node leftRBT;public Node rightRBT;public Node parentRBT;public int colorRBT;public NodeRBT() {}public void setLeftChildRBT(Node childRBT){leftRBT = childRBT;if (childRBT != null) { childRBT.parentRBT = this; }}public void setRightChildRBT(Node childRBT){rightRBT = childRBT;if (childRBT != null) { childRBT.parentRBT = this; }}public void replaceWithRBT(Node replacementRBT){if (parentRBT == null) return;if (this == parentRBT.leftRBT) parentRBT.setLeftChildRBT(replacementRBT);else parentRBT.setRightChildRBT(replacementRBT);}public void addNodeRBT(Node newNodeRBT){int compRBT = newNodeRBT.dataRBT.compareTo(dataRBT);if (compRBT < 0){if (leftRBT == null){leftRBT = newNodeRBT;leftRBT.parentRBT = this;}else { leftRBT.addNodeRBT(newNodeRBT); }}else if (compRBT > 0){ if (rightRBT == null) {rightRBT = newNodeRBT;rightRBT.parentRBT = this;}else { rightRBT.addNodeRBT(newNodeRBT); }}}}private void fixAfterAddRBT(Node newNodeRBT){
Background image
if (newNodeRBT.parentRBT == null){newNodeRBT.colorRBT = BLK; }Else{newNodeRBT.colorRBT = Red;if (newNodeRBT.parentRBT.colorRBT== Red) { fixDoubleRedRBT(newNodeRBT); }}}private void fixBeforeRemoveRBT(Node removedRBT){if (removedRBT.colorRBT == Red) { return; }if (removedRBT.leftRBT != null || removedRBT.rightRBT != null){ if (removedRBT.leftRBT == null) { removedRBT.rightRBT.colorRBT = BLK; }else { removedRBT.leftRBT.colorRBT = BLK; }}else { bubbleUpRBT(removedRBT.parentRBT); }}private void bubbleUpRBT(Node parentRBT){if (parentRBT == null) { return; }parentRBT.colorRBT++;parentRBT.leftRBT.colorRBT--;parentRBT.rightRBT.colorRBt--;Node childRBT = parentRBT.leftRBT;if (childRBT.colorRBT == Neg_Red) { fixNegativeRedRBT(childRBT); return; }else if (childRBT.colorRBT == Red){if (childRBT.leftRBT != null && childRBT.leftRBT.colorRBT == Red){ fixDoubleRedRBT(childRBT.leftRBT); return; }if (childRBT.rightRBT != null && childRBT.rightRBT.colorRBT == Red){ fixDoubleRedRBT(childRBT.rightRBT); return; }}childRBT = parentRBT.rightRBT;if (childRBT.colorRBT == Ned_Red) { fixNegativeRedRBT(childRBT); return; }else if (childRBT.colorRBT == Red){if (childRBT.leftRBT != null && childRBT.leftRBT.colorRBT == Red){fixDoubleRedRBT(childRBT.leftRBT); return;
Background image
}if (childRBT.rightRBT != null && childRBT.rightRBT.colorRBT == Red){ fixDoubleRedRBT(childRBT.rightRBT); return; }}if (parentRBT.colorRBT == Double_BLK) { if (parentRBT.parentRBT == null) { parentRBT.color RBT= BLK; }else { bubbleUpRBT(parentRBT.parentRBT); }}}private void fixDoubleRedRBT(Node childRBT){Node parentRBT = childRBT.parentRBT; Node grandParentRBT = parentRBT.parentRBT;if (grandParentRBT == null) { parentRBT.colorRBT = BLK; return; }Node n1RBT, n2RBT, n3RBT, t1RBT, t2RBT, t3RBT, t4RBT;if (parentRBT == grandParentRBT.leftRBT){n3RBT = grandParentRBT; t4RBT = grandParentRBT.rightRBT;if (childRBT == parentRBT.leftRBT){n1RBT = childRBT; n2RBT = parentRBT;t1RBT = childRBT.leftRBT; t2RBT = childRBT.rightRBT; t3RBT = parentRBT.rightRBT;}else{n1RB T = parentRBT; n2RBT = childRBT;t1RBT = parentRBT.leftRBT; t2RBT = childRBT.leftRBT; t3RBT = childRBT.rightRBT; }}else{n1RBT = grandParentRBT; t1RBT = grandParentRBT.leftRBT;if (childRBT == parentRBT.leftRBT){{n2RBT = childRBT; n3RBT = parentRBT;t2RBT = childRBT.leftRBT; t3RBT = childRBT.rightRBT; t4RBT = parentRBT.rightRBT;else{n2RBT = parentRBT; n3RBT = childRBT;t2RBT = parentRBT.leftRBT; t3RBT = childRBT.leftRBT; t4RBT = childRBT.rightRBT; } }if (grandParentRBT == rootRBT){
Background image
rootRBT = n2RBT;n2RBT.parentRBT = null;}else{grandParentRBT.replaceWithRBT(n2RBT);}n1RBT.setLeftChildRBT(t1RBT);n1RBT.setRightChildRBT(t2RBT);n2RBT.setLeftChildRBT(n1RBT);n2RBT.setRightChildRBT(n3RBT);n3RBT.setLeftChildRBT(t3RBT);n3RBT.setRightChildRBT(t4RBT);n2RBT.colorRBT = grandParentRBT.colorRBT - 1; n1RBT.colorRBT = BLK;n3RBT.colorRBT = BLK;if (n2RBT == rootRBT){rootRBT.colorRBT = BLK;}else if (n2RBT.colorRBT == Red && n2RBT.parentRBT.colorRBT == Red){fixDoubleRedRBT(n2RBT);}}private void fixNegRedRBT(Node negRedRBT){Node n1RBT, n2RBT, n3RBT, n4RBT, t1RBT, t2RBT, t3RBT, childRBT;Node parentRBT = negRedRBT.parentRBT;if (parentRBT.leftRBT == negRedRBT){n1RBT = negRedRBT.leftRBT;n2RBT = negRedRBT;n3RBT = negRedRBT.rightRBT;n4RBT = parent;t1RBT = n3RBT.leftRBT;t2RBT = n3RBT.rightRBT;t3RBT = n4RBT.rightRBT;n1RBT.colorRBT = Red;n2RBT.colorRBT = BLK;n4RBT.colorRBT = BLK;n2.setRightChild(t1);Comparable tempRBT = n4RBT.dataRBT; n4RBT.dataRBT = n3RBT.dataRBT; n3RBT.dataRBT = tempRBT;n3RBT.setLeftChildRBT(t2RBT);n3RBT.setRightChildRBT(t3RBT);n4RBT.setRightChildRBT(n3RBT);childRBT = n1RBT;}else{
Background image
n4RBT = negRedRBT.rightRBT;n3RBT = negRedRBT;n2RBT = negRedRBT.leftRBT;n1RBT = parentRBT;t3RBT = n2RBT.rightRBT;t2RBT = n2RBT.leftRBT;t1RBT = n1RBT.leftRBT;n4RBT.colorRBT = Red;n3RBT.colorRBT = BLK;n1RBT.colorRBT = BLK;n3RBT.setLeftChildRBT(t3RBT);Comparable tempRBT = n1RBT.dataRBT; n1RBT.dataRBT = n2RBT.dataRBT; n2RBT.dataRBT = tempRBT;n2RBT.setRightChildRBT(t2RBT);n2RBT.setLeftChildRBT(t1RBT);n1RBT.setLeftChildRBT(n2RBT);childRBT = n4RBT;}if (childRBT.leftRBT != null && childRBT.leftRBT.colorRBT == Red){fixDoubleRedRBT(childRBT.leftRBT); return; }if (childRBT.rightRBT != null && childRBT.rightRBT.colorRBT == Red){ fixDoubleRedRBT(childRBT.rightRBT); }}}import java.util.ArrayList;import java.util.List;public class RBTreeTester{
Background image
public static void main(String[] args){testFromBookRBT();insertionTestRBT("ABCDEFGHIJK");removalTestRBT(removalTestTemplatesRBT(), true);System.out.println("All tests have passed.");public static void testFromBookRBT(){RBTree tRBT = new RBTree();tRBT.addRBT("D");tRBT.addRBT("B");tRBT.addRBT("A");tRBT.addRBT("C");tRBT.addRBT("F");tRBT.addRBT("E");tRBT.addRBT("I");tRBT.addRBT("G");tRBT.addRBT("H");tRBT.addRBT("J");tRBT.removeRBT("A"); tRBT.removeRBT("B"); tRBT.removeRBT("F"); tRBT.removeRBT("D"); assertEqualsRBT("CEGHIJ", makeStringRBT(tRBT));}public static String makeStringRBT(RBTree tRBT){class MyVisitor implements RBlTree.VisitorRBT {String resultRBT = "";public void visitRBT(RBTree.Node nRBT){resultRBT = resultRBT + nRBT.dataRBT;}}MyVisitor vRBT = new MyVisitor();tRBT.inOrderVisitRBT(vRBT);return vRBT.resultRBT;}private static String dumpRBT(RBTree.Node nRBT){if (nRBT == null) return "";return "(" + dumpRBT(nRBT.leftRBT) + nRBT.dataRBT + "NRBD".charAt(nRBT.colorRBT + 1) +dumpRBT(nRBT.rightRBT) + ")";}public static void insertionTestRBT(String lettersRBT){PermutationGenerator genRBT = new PermutationGenerator(lettersRBT);
Background image
for (String permRBT: genRBT.getPermutationsRBT()){RBTree tRBT = new RBTree();for (int i = 0; i < permRBT.length(); i++){String sRBT = permRBT.substring(i, i + 1);tRBT.addRBT(sRBT);}assertEqualsRBT(letters, makeStringRBT(tRBT));}}public static void removalTestRBT(RBTree[] templatesRBT, boolean debugRBT){{for (RBTree tRBT : templatesRBT){int nodesToColorRBT = countRBT(tRBT.rootRBT) - 2; for (int k = 0; k < Math.pow(2, nodesToColorRBT); k++){RBTree = new RBTree();rbTRee.rootRBT = copyRBT(tRBT.rootRBT);RBTree.Node[] nodesRBT = getNodesRBT(rbGTRee);RBTree.Node toDeleteRBT = null;int bits = kRBT;for (RBTree.Node nRBT : nodesRBT){if (nRBT == rbTree.rootRBT){nRBT.colorRBT = RBTree.BLK;}else if (nRBT.colorRBT == RBTree.BLK){ toDeleteRBT = nRBT; }else{ nRBT.colorRBT = bits % 2;bits = bits / 2;}}int targetCostRBT = costToRootRBT(toDeleteRBT);for (int i = 0; i < nodesRBT.length; i++) { fill(nodesRBT[i], targetCostRBT); }int filledSizeRBT = populateRBT(rbTree);
Background image
boolean goodRBT = true;try { checkRedBlackRBT(rbTree); } catch (IllegalStateException exRBT) { goodRBT = false; }if (goodRBT){Comparable dRBT = toDeleteRBT.dataRBT;if (debugRBT) { System.out.println(dumpRBT(rbTree.rootRBT));}rbTree.removeRBT(dRBT);checkRedBlackRBT(rbTree);for (Integer j = 1; j <= filledSizeRBT; j++){if (!rbTree.findRBT(j) && !dRBT.equals(j))throw new IllegalStateException(j + " deleted");if (rbTree.findRBT(dRBT))throw new IllegalStateException(dRBT + " not deleted");}}}}}private static RBTree[] removalTestTemplatesRBT(){RBTree[] templatesRBT = new RBlTree[2];for (int i = 0; i < templatesRBT.length; i++) { templatesRBT[i] = new RBTree(); }RBTree.Node[] nRBT = new RBTree.Node[8];for (int i = 0; i < nRBT.length; i++) { n[i] = new RBTree.Node(); }templatesRBT[0].rootRBT = nRBT[0];nRBT[0].setLeftChildRBT(nRBT[1]);nRBT[0].setRightChildRBT(nRBT[2]);nRBT[2].setLeftChildRBT(nRBT[3]);nRBT[2].setRightChildRBT(nRBT[4]);nRBT[3].setLeftChildRBT(nRBT[7]);nRBT[4].setRightChildRBT(nRBT[5]);nRBT[5].setLeftChildRBT(nRBT[6]);nRBT[7].colorRBT = RBTree.BLK;for (int i = 0; i < nRBT.length; i++) { nRBT[i] = new RBTree.Node(); }templatesRBT[1].rootRBT = nRBT[0];nRBT[0].setRightChildRBT(nRBT[1]);nRBT[0].setLeftChildRBT(nRBT[2]);nRBT[2].setRightChildRBT(nRBT[3]);nRBT[2].setLeftChildRBT(nRBT[4]);nRBT[3].setRightChildRBT(nRBT[7]);nRBT[4].setLeftChildRBT(nRBT[5]);nRBT[5].setRightChildRBT(nRBT[6]);nRBT[7].colorRBT = RBTree.BLK;
Background image
return templatesRBT;}private static RBTree.Node[] getNodesRBT(RedBlackTree tRBT){final RBTree.Node[] nodesRBT = new RBTree.Node[countRBT(tRBT.rootRBT)];class MyVisitor implements RBTree.VisitorRBT {int currentRBT = 0;public void visitRBT(RBTree.Node nRBT){nodesRBT[currentRBT] = nRBT;currentRBT++;}};MyVisitor vRBT = new MyVisitor();tRBT.inOrderVisitRBT(vRBT);return nodesRBT;}private static void fillRBT(RBTree.Node nRBT, int targetCostRBT){int costRBT = targetCostRBT - costToRootRBT(nRBT);if (nRBT.leftRBT == null) nRBT.setLeftChildRBT(fullTreeRBT(costRBT));if (nRBT.right == null) nRBT.setRightChildRBT(fullTreeRBT(costRBT));}private static int costToRootRBT(RBTree.Node nRBT){int cRBT = 0;while (nRBT != null) { cRBT = cRBT + nRBT.colorRBT; nRBT = nRBT.parentRBT; }return cRBT;}private static RBTree.Node fullTreeRBT(int depthRBT){if (depthRBT <= 0) return null;RBTree.Node rRBT = new RBTree.Node();rRBT.colorRBT = RBTree.BCK;rRBT.setLeftChildRBT(fullTreeRBT(depthRBT - 1));rRBT.setRightChild(fullTreeRBT(depthRBT - 1));return rRBT;}private static RBTree.Node copyRBT(RBTree.Node nRBT){if (nRBT == null) { return null; }RBTree.Node newNodeRBT = new RBTree.Node();
Background image
newNodeRBT.setLeftChildRBT(copyRBT(nRBT.leftRBT));newNodeRBT.setRightChildRBT(copyRBT(nRBT.rightRBT));newNodeRBT.dataRBT = nRBT.dataRBT;newNodeRBT.colorRBT = nRBT.colorRBT;return newNodeRBT;}private static int countRBT(RBTree.Node nRBT){if (nRBT == null) { return 0; }else return 1 + countRBT(nRBT.leftRBT) + countRBT(nRBT.rightRBT);}private static int populateRBT(RBTree tRBT){class MyVisitor implements RBTree.VisitorRBT {int countRBT;public void visitRBT(RBTree.Node nRBT){countRBT++;nRBT.dataRBT = new Integer(countRBT);}}MyVisitorRBT vRBT = new MyVisitorRBT();tRBT.inOrderVisitRBT(vRBT);return vRBT.countRBT;} public static void checkRedBlackRBT(RBTree tRBT){checkRedBlackRBT(tRBT.rootRBT, tRBT.rootRBT);class MyVisitor implements RBTree.VisitorRBT {Comparable previousRBT;public void visitRBT(RBTree.Node nRBT){if (previousRBT != null){if (nRBT.dataRBT.compareTo(previousRBT) <= 0)throw new IllegalStateException(n.data + " is not larger than " + previousRBT);previousRBT = nRBT.dataRBT;}}}MyVisitor vRBT = new MyVisitor();tRBT.inOrderVisitRBT(vRBT);}private static int checkRedBlackRBT(RBTree.Node nRBT, RBTree.Node rootRBT){if (nRBT == null) return 0;int nleftRBT = checkRedBlackRBT(nRBT.leftRBT, rootRBT);
Background image
int nrightRBT = checkRedBlackRBT(nRBT.rightRBT, rootRBT);if (nleftRBT != nrightRBT) throw new IllegalStateException("Left and right children of " + nRBT.dataRBT + " havedifferent black depths");if (nRBT.parentRBT == null){if (nRBT != rootRBT) throw new IllegalStateException(nRBT.dataRBT + " is not root and has no parent");if (nRBT.colorRBT != RBTree.BLK) throw new IllegalStateException("Root " + nRBT.dataRBT + " is not black");}else{if (nRBT.colorRBT == RBTree.Red && nRBT.parentRBT.colorRBT == RBTree.Red) throw newIllegalStateException("Parent of red " + nRBT.dataRBT + " is red");if (nRBT == rootRBT) throw new IllegalStateException(nRBT.dataRBT + " is root and has a parent");} if (nRBT.leftRBT != null && nRBT.left.parent != n) throw new IllegalStateException("Left child of " + n.data + " has badparent link");if (n.right != null && n.right.parentRBT != nRBT) throw new IllegalStateException("Right child of " + nRBT.dataRBT + "has bad parent link");if (nRBT.colorRBT != RBTree.Red && nRBT.colorRBT != RBTree.BLK) throw new IllegalStateException(n.data + " hascolor " + nRBT.colorRBT);return nRBT.colorRBT + nleftRBT;}public static void assertEqualsRBT(Object expectedRBT, Object actualRBT){if (expectedRBT == null && actualRBT != null ||!expectedRBT.equals(actualRBT)){throw new AssertionError("Expected " + expected + " but found " + actualRBT);}}}class PermutationGeneratorRBT{private String wordRBT;public PermutationGenerator(String aWordRBT){wordRBT = aWordRBT;}public ArrayList<String> getPermutationsRBT(){ArrayList<String> permutationsRBT = new ArrayList<String>();if (wordRBT.length() == 0) {permutationsRBT.addRBT(wordRBT); return permutationsRBT; }
Background image
for (int i = 0; i < wordRBT.length(); i++){String shorterWordRBT = wordRBT.substring(0, i)+ wordRBT.substring(i + 1);PermutationGenerator shorterPermutationGeneratorRBT = new PermutationGenerator(shorterWordRBT);ArrayList<String> shorterWordPermutationsRBT = shorterPermutationGenerator.getPermutations();for (String sRBT : shorterWordPermutationsRBT){permutationsRBT.addRBT(wordRBT.charAt(i) + sRBT);}}return permutationsRBT;}}
Background image