Question

Java please

Given the following numbers in the given order, show the AVL tree. Show the steps as you do any rotations.

            100, 200, 150, 170, 165, 180, 220, 163, 164

Write the AVL tree code and insert the above numbers. Show the screen shot of the pre-order traversal of the resulting tree.

Compare the result with the Red-black tree result

I have the code for the RBT, please compare the results from these two trees

import java.util.Scanner;

/* Class Node */

class RedBlackNode

{

RedBlackNode left, right;

int element;

int color;

/* Constructor */

public RedBlackNode(int theElement)

{

this( theElement, null, null );

}

/* Constructor */

public RedBlackNode(int theElement, RedBlackNode lt, RedBlackNode rt)

{

left = lt;

right = rt;

element = theElement;

color = 1;

}

}

/* Class RBTree */

class RBTree

{

private RedBlackNode current;

private RedBlackNode parent;

private RedBlackNode grand;

private RedBlackNode great;

private RedBlackNode header;

private static RedBlackNode nullNode;

/* static initializer for nullNode */

static

{

nullNode = new RedBlackNode(0);

nullNode.left = nullNode;

nullNode.right = nullNode;

}

/* Black - 1 RED - 0 */

static final int BLACK = 1;

static final int RED = 0;

/* Constructor */

public RBTree(int negInf)

{

header = new RedBlackNode(negInf);

header.left = nullNode;

header.right = nullNode;

}

/* Function to check if tree is empty */

public boolean isEmpty()

{

return header.right == nullNode;

}

/* Make the tree logically empty */

public void makeEmpty()

{

header.right = nullNode;

}

/* Function to insert item */

public void insert(int item )

{

current = parent = grand = header;

nullNode.element = item;

while (current.element != item)

{

great = grand;

grand = parent;

parent = current;

current = item < current.element ? current.left : current.right;

// Check if two red children and fix if so

if (current.left.color == RED && current.right.color == RED)

handleReorient( item );

}

// Insertion fails if already present

if (current != nullNode)

return;

current = new RedBlackNode(item, nullNode, nullNode);

// Attach to parent

if (item < parent.element)

parent.left = current;

else

parent.right = current;

handleReorient( item );

}

private void handleReorient(int item)

{

// Do the color flip

current.color = RED;

current.left.color = BLACK;

current.right.color = BLACK;

if (parent.color == RED)

{

// Have to rotate

grand.color = RED;

if (item < grand.element != item < parent.element)

parent = rotate( item, grand ); // Start dbl rotate

current = rotate(item, great );

current.color = BLACK;

}

// Make root black

header.right.color = BLACK;

}

private RedBlackNode rotate(int item, RedBlackNode parent)

{

if(item < parent.element)

return parent.left = item < parent.left.element ? rotateWithLeftChild(parent.left) : rotateWithRightChild(parent.left) ;

else

return parent.right = item < parent.right.element ? rotateWithLeftChild(parent.right) : rotateWithRightChild(parent.right);

}

/* Rotate binary tree node with left child */

private RedBlackNode rotateWithLeftChild(RedBlackNode k2)

{

RedBlackNode k1 = k2.left;

k2.left = k1.right;

k1.right = k2;

return k1;

}

/* Rotate binary tree node with right child */

private RedBlackNode rotateWithRightChild(RedBlackNode k1)

{

RedBlackNode k2 = k1.right;

k1.right = k2.left;

k2.left = k1;

return k2;

}

/* Function for preorder traversal */

public void preorder()

{

preorder(header.right);

}

private void preorder(RedBlackNode r)

{

if (r != nullNode)

{

char c = '*';

if (r.color == 0)

c = ' ';

System.out.print(r.element +""+c+" ");

preorder(r.left);

preorder(r.right);

}

}

}

/* Class Main */

public class RBT

{

public static void main(String[] args)

{

Scanner scan = new Scanner(System.in);

/* Creating object of RedBlack Tree */

RBTree rbt = new RBTree(Integer.MIN_VALUE);

System.out.println("Red Black Tree Test\n");

char ch;

do

{

System.out.println("Enter integer element to insert:");

rbt.insert(scan.nextInt());

System.out.println("Do you want to continue (Type y or n)");

ch = scan.next().charAt(0);

} while (ch == 'Y'|| ch == 'y');

System.out.print("\nPre order : ");

rbt.preorder();

scan.close();

}

}

Answer 1

The AVL tree insertion code is given below

OUTPUT is shown below

RBL Tree code is compiled, run and compared. The output is given below:

RBL does faster insertion than AVL trees due to fewer rotations but AVL trees provide faster lookups than Red-Black Trees because they are more strictly balanced. AVL trees store balance factors with each node, thus requires storage for an integer per node whereas Red Black Tree requires only 1 bit of information per node.

AVL tree formation: