Question

为了练习数据结构，我正在实现自己的Trees库。我从BST开始，随后我将要实现AVL树，红黑树等等。 AVL和RBT也是BST树，因此某些类层次结构相当明显。我遇到的问题是所有这些树都具有其他类型的节点-AvlNode具有平衡因子标志，RgbNode具有颜色标志，BstNode不需要任何其他信息（尽管引用了所有Node需要的父，子和值）。所以我有一个节点层次结构和一个树层次结构。我可以给BstNode提供一些flag属性，并在扩展类中使用它，但这肯定不是一个好方法。

问题是如何处理这样的事实，例如Bst.findNode（）将返回BstNode，但在Avl中我需要AvlNode，尽管findNode（）方法在这两者中都相同（除了返回类型）。

我需要计划层次结构方面的帮助，或者如果这些并行层次结构（作为代码味道）通常不是一个好主意，则我需要一种变通方法，因为我不知道如何以正确的方式进行操作。

BstTree类：

public class BstTree<T extends Comparable> implements Iterable
{
    private BstNode<T> root;

    public void addValue(T value)
    {
        BstNode node = new BstNode(value);
        addNode(node);
    }

    public void addNode(BstNode<T> node)
    {
        ...
    }

    public boolean removeNode(T value)
    {
       ...
    }


    public BstNode findNode(T value)
    {
        ...
    }
    //other less significant methods
}

BstNode类：

public class BstNode<T extends Comparable>
{
    private static int lastId = 0;
    private int id;
    private T value;
    private BstNode parent = null;
    private BstNode leftChild = null;
    private BstNode rightChild = null;

    public BstNode(T value) {
        this.id = ++lastId;
        this.value = value;
    }

    public boolean isGreaterThan(BstNode n)
    {
        //...
    }

    public boolean hasLeftChild()
    {
        //...
    }

    public boolean hasRightChild()
    {
        //...
    }

    public boolean hasParent()
    {
        //...
    }

    public boolean isLeaf()
    {
        //...
    }

    public boolean hasOnlyOneChild()
    {
        //...
    }

    public BstNode getOnlyChild(BstNode node)
    {
        ...
    }

    public boolean isLeftChildren()
    {
        ...
    }

    public BstNode getConsequentNode()
    {
        ...
    }
}

我猜想上面的职责分离可能不是完美的，如果错了，那么我可能会得到一些从Node到Tree类的方法，但这不是什么大问题。

Answer 1

我会做这样的事情：

public abstract class BstTree<T extends Comparable,N extends BstNode<T,N>> {
    private N root;
...

    public void addValue(T value)
    {
        N node = newNode(value);
        addNode(node);
    }

    public abstract N newNode(T value);

    public void addNode(N node)
    {
        // ...
    }
}

public class BstNode<T extends Comparable,N extends BstNode<T,N>>
{
    private T value;
    private N parent = null;
    private N leftChild = null;
    private N rightChild = null;

    public BstNode(T value) {
        this.value = value;
    }

    public N getOnlyChild(N node)
    {
        // ...
    }
...
}

public class AVLTree<T extends Comparable> extends BstTree<T,AVLNode<T>> {
    ...
    @Override
    public AVLNode<T> newNode(T value) {
        return new AVLNode<>(value);
    }
}

public class AVLNode<T extends Comparable> extends BstNode<T,AVLNode<T>> {
    ...

    public AVLNode(T value) {
        super(value);
    }

    @Override
    public AVLNode<T> getOnlyChild(AVLNode<T> node) {
        return super.getOnlyChild(node);
    }
    ...
}

Java：实现树及其节点的并行层次结构

1 个答案: