Java 编写自己的2节点或3节点二叉搜索树

我应该创建一个二叉搜索树或B-树，最多有三个节点。任何一个“父”或“子”节点都可以保存1或2个值，这样它就可以有2或3个“子”指针

例如：这是可以的，因为每个集合中最多只有2个值

23 30
/ | \
12 25[35 38]

其中不是：因为根中有3个值和4个“子”节点

121518
/  | |  \
4141620

我能够编写自己的二元搜索树，但我在想如何将其转换为2节点或3节点二元搜索树时遇到了很多困难

有人能帮我用常规的二叉树实现一个2node或3node的二叉搜索树代码吗

public class TreeNode<K extends Comparable<K>, V> 
{
    public K key;
    public V value;

    public TreeNode<K,V> left;
    public TreeNode<K,V> right;


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

}

---

你到底在哪里挣扎？你错过了什么？顺便说一下，2-3树不是二叉树。很抱歉，也许平衡二叉搜索树会更好。我不知道该怎么做。我不太擅长递归，我理解自平衡树的工作原理和必要的步骤，但我不知道如何实现它们@Zulan@JohnDoe尽可能准确地编辑标题很重要，这样知识渊博的人就可以找到它。

  public class BST<K extends Comparable<K>, V>
{
    private TreeNode<K, V> root;

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

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

    private void put(TreeNode<K, V> current, K key, V value)
    {
        int n = key.compareTo(current.key);

        if (n == 0)
        {
            current.value = value;
            return;
        }
        else if (n < 0)
        {
            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);
        }
    }

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

    private V get(TreeNode<K,V> current, K key)
    {
        if (current == null)
            return null;
        else 
        {
            int n = key.compareTo(current.key);

            if (n==0)
                return current.value;
            else if (n < 0)
                return get(current.left, key);
            else
                return get(current.right, key);
        }
    }

    public int size()
    {
        return size(root);
    }

    private int size(TreeNode<K,V> current)
    {
        if(current == null)
            return 0;
        else
            return size(current.left) + size(current.right) + 1;
    }

    public int depth()
    {
        return depth(root) - 1;
    }

    private int depth(TreeNode<K,V> current)
    {
        if(current == null)
            return 0;
        else
            return Math.max(depth(current.left), depth(current.right)) + 1;
    }

}