将常规的二进制搜索树变成平衡的二进制搜索树

Question

I was able to write my own Binary Search Tree, but I am having a lot of trouble figuring out how to turn that into a Balanced Binary Search tree.

Could someone help me implement a Balanced binary search tree code with the regular binary tree.

I think I was successful in changing my TreeNode class to have the necessary changes.

I added another key and another value along with another TreeNode middle to hold the middle pointer when you get to a 3 node in the tree.

I then added another constructor to hold the case if it was a 3 node. I believe I did this right.

public class TreeNode<V> 
{
public int key;
public int key1;
public V value;
public V value1;
public TreeNode<V> left;
public TreeNode<V> right;
public TreeNode<V> middle;

public TreeNode(int key, V value)
{
    this.key = key;
    this.value = value;
    this.left = null;
    this.right = null;
}

public TreeNode(int key, V value, int key1, V value1)
{
    this.key = key;
    this.key1 = key1;
    this.value = value;
    this.value1 = value1;       
    this.left = null;
    this.right = null;
    this.middle = null;
}

The tough part comes to when I need to change the actual BST Class. I know the put is going to change quite a bit because we have to check and see if it is a 2 node or a 3 node, as well as check for what the parent node is.

Here is what I have so far:

public class BST<V>
{
private TreeNode<V> root;

public BST()
{
    this.root = null;
}

public V get(int key)
{
    return get(root, key);
}

private V get(TreeNode<V> current, int key)
{
    if (current == null)
        return null;
    else if (key == current.key)
        return current.value;
    else if (key < current.key)
        return get(current.left, key);
    else
        return get(current.right, key);
}

public void put(int key, V value)
{
    if (root == null)
        root = new TreeNode<>(key, value);
    else
        put(root, key, value);
}

private void put(TreeNode<V> current, int key, V value)
{
    if (key == current.key)
    {
        current.value = value;
        return;
    }
    else if (key < current.key)
    {
        if (current.left == null)
        {
            current.left = new TreeNode<>(key, value);
            return;
        }
        else
            put(current.left, key, value);
    }
    else
    {
        if (current.right == null)
        {
            current.right = new TreeNode<>(key, value);
            return;
        }
        else
            put(current.right, key, value);
    }
  } 
}

My difficultly comes most with the recursion. I understand how basic recursion works, but using it to implement a balanced binary search tree is seeming a much more difficult talk than originally thought.

Answer 1

You only want a binary search tree, correct? If so, there isn't really a need for keys (Which are used for M-ary trees).

This isn't exactly an answer, but hopefully this will help simplify your code at least a little bit.