通用BST的实施

时间:2015-03-14 17:14:26

标签: java

您好我想知道如何设置一个具有私有Node类的面向对象的BST类。(两个类都是通用的) 到目前为止,我有这个,但我有一些编译错误。一些解释会很好。我复制了这段代码,但我知道有些错误需要修复。你还将如何设置bst的构造函数?

@SuppressWarnings("unchecked")
//public class BinarySearchTree<T extends Comparable<? super T>> {
public class BST<T extends Comparable<T>> implements Iterable<T>
{
    private Node <T> root;
    //  public BST(){
    //      root=null;
    //  }

    private T search(T target, BST <T> p)
    {

        int comp=target.compareTo(p.data);
        T c=target.compareTo(P.data);
        if(comp==0)
            return c;
    }


    private class Node<T extends Comparable<T>> implements Iterable {
        T data;
        Node<T> left, right;

        public Node(T t)
        {
            data=t; 
        }

        @Override
        public Iterator iterator() {
            // TODO Auto-generated method stub
            return null;
        }

        public T search(T target)
        {
            return search(target, root);
        }
    }

    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return null;
    }


}

1 个答案:

答案 0 :(得分:1)

你最初注释掉的默认构造函数应该没问题应该没问题。是否有一个特定的用例,你不记得它不满足?

像这样的东西。因为Node类是私有内部类,所以它不必是通用的,而是可以使用其父类中指定的类型,这是我认为你想要的。

节点类实际上不需要搜索方法,因为它只包含一个值。没有必要搜索是否只有一个值。这也是它不需要迭代器的原因。实际上没有必要只迭代一个值。

在设计诸如BST之类的抽象数据类型时,最好考虑一下如何使用它:它应该支持哪些操作,也就是说。它的API。下面的实现支持2个操作:插入和搜索。可能的扩展可能包括remove和/或contains操作。

树上的操作通常是递归的。这是因为你从根开始并且必须遍历内部节点,内部节点本身可以​​被视为各自子树的根。尝试浏览一些示例插入和搜索,以说服自己为什么这样做。

import java.util.Iterator;

public class BST<T extends Comparable<T>> implements Iterable<T> {
    private Node root;

    public BST(){
        root=null;
    }

    private void insertInternal(T value, Node parent) {
        int comp=value.compareTo(parent.data);
        if(comp < 0) {
            if(parent.left == null) {
                parent.left = new Node(value);
            }
            else {
                insertInternal(value, parent.left);
            }
        }
        else if(comp > 0) {
            if(parent.right == null) {
                parent.right = new Node(value);
            }
            else {
                insertInternal(value, parent.right);
            }
        }
    }

    public void insert(T value) {
        if(root == null) {
            root = new Node(value);
            return;
        }
        insertInternal(value, root);
    }

    private Node searchInternal(T target, Node node) {
        if(node == null) {
            return null;
        }
        int comp=target.compareTo(node.data);
        if(comp < 0) {
            return searchInternal(target, node.left);
        }
        else if(comp > 0) {
            return searchInternal(target, node.right);
        }
        return node;
    }

    public Node search(T target) {
        return searchInternal(target, root);
    }

    private class Node {
        T data;
        Node left, right;

        public Node(T t) {
            data=t;
        }
    }

    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return null;
    }

    public static void main(String[] args) {
        BST<Integer> bst = new BST<Integer>();
        bst.insert(2);
        bst.insert(6);
        System.out.println(bst.search(2) != null);
        System.out.println(bst.search(6) != null);
        System.out.println(bst.search(8) == null);
    }
}