Java：如何实现一个通用的二进制搜索树？

到目前为止，我一直在编写一个节点类作为

class Node {
        private  value;
        private Node left;
        private Node right;

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public Node getLeft() {
            return left;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public Node getRight() {
            return right;
        }

        public void setRight(Node right) {
            this.right = right;
        }
    } 

二叉搜索树

public class BinarySearchTree {
    private Node root;

    public BinarySearchTree(int value) {
        root = new Node(value);
    }

    public void insert(int value) {
      Node node = new Node(value);
        // insert logic goes here to search and insert
    }
}

现在我想支持BinarySearchTree，让它可以插入任何类型的节点，比如字符串、人物

如何使其成为通用的以保存任何类型？

使用泛型：

class Node<T extends Comparable<T>> {
        private T value;
        ...
}

public class BinarySearchTree<T extends Comparable<T>> {
    private Node<T> root;

    public BinarySearchTree(T value) {
        root = new Node<T>(value);
    }

    public void insert(T value) {
      Node<T> node = new Node<T>(value);
        // insert logic goes here to search and insert
    }
}

类节点{
私人T值；
...
}
公共类二进制搜索树{
私有节点根；
公共二进制搜索树（T值）{
根=新节点（值）；
}
公共空白插入（T值）{
节点=新节点（值）；
//插入逻辑在这里进行搜索和插入
}
}

您有两个选择：

1） 您可以进入泛型/模板

---

2） 让您的树接受类型

对象，而不是
int
，并让用户负责强制转换。
关于第二个问题，您应该使用模板：


关于第一点：


http://en.wikipedia.org/wiki/Tree_rotation （插入）

也许这会更快阅读：


好好学习
 只需将
节点
和
二进制搜索树
类设置为通用类：

class Node<T extends Comparable<T>> {
    private T value;
    private Node<T> left;
    private Node<T> right;

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

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public Node<T> getLeft() {
        return left;
    }

    public void setLeft(Node<T> left) {
        this.left = left;
    }

    public Node<T> getRight() {
        return right;
    }

    public void setRight(Node<T> right) {
        this.right = right;
    }
} 

类节点{
私人T值；
私有节点左；
私有节点权；
公共节点（T值）{
这个值=值；
}
公共T getValue（）{
返回值；
}
公共无效设置值（T值）{
这个值=值；
}
公共节点getLeft（）{
左转；
}
公共void setLeft（节点左侧）{
this.left=左；
}
公共节点getRight（）{
返还权；
}
公共无效设置权限（节点权限）{
这个。右=右；
}
} 

以及：

class BinarySearchTree<T extends Comparable<T>> {
    private Node<T> root;

    public BinarySearchTree(T value) {
        root = new Node<T>(value);
    }

    public void insert(T value) {
      Node<T> node = new Node<T>(value);
        // insert logic goes here to search and insert
    }
}

类二进制搜索树{
私有节点根；
公共二进制搜索树（T值）{
根=新节点（值）；
}
公共空白插入（T值）{
节点=新节点（值）；
//插入逻辑在这里进行搜索和插入
}
}

请注意
Comparable
扩展约束，稍后需要该约束来强制树中的节点排序。感谢zaske的建议。
请不要让您的代码无法编译

您在这里面临一些挑战-

A.将节点定义为通用-

public class Node<T> {
   private T value;
   //... here goes the rest of your code
}

公共类节点{
私人T值；
//…下面是您的其余代码
}

B.您的搜索类也应该是泛型的，并且签名应该是

public class BinarySearchTree <T extends Comparable<T>> {

   public BinarySearchTree(T value) {
      //Do your logic here
   }

   public void insert(T value)  {
        //Do your logic here
   }
}

公共类二进制搜索树{
公共二进制搜索树（T值）{
//你的逻辑在这里吗
}
公共空白插入（T值）{
//你的逻辑在这里吗
}
}

这是必需的，以便强制您只提供实现可比较的类型，以便您能够在树中执行搜索。
我找到了实现系统的SnapTreeMap


公共类二进制搜索树{
节根；
类节点{
T数据；
左淋巴结；
节点权；
公共节点（T数据）{
这个数据=数据；
}
}
公共布尔值为空（）{
返回root==null；
}
公共空白插入（T值）{
if（isEmpty（））
根=新节点（值）；
其他的
插入（根，值）；
}
专用空心插入（节点，T值）{
if（value.compareTo（node.data）<0）{
if（node.left==null）
node.left=新节点（值）；
其他的
插入（node.left，值）；
}
否则{
if（node.right==null）
node.right=新节点（值）；
其他的
插入（node.right，value）；
}
}
}
公共类TNode{
T数据；
公共TNode左；
公权；
公共TNode（T数据）{
这个数据=数据；
}
}
导入java.util.ArrayList；
导入java.util.List；
公共类二叉树{
私有根；
公共tnodegetroot（）{
返回这个.root；
}
公共无效添加（T数据）{
TNode newNode=新TNode（数据）；
if（root==null）{
根=新节点；
}否则{
TNode tempNode=根节点；
TNode prev=null；
while（tempNode！=null）{
prev=tempNode；
if（data.compareTo（tempNode.data）>0）{
tempNode=tempNode.right；
}否则{
tempNode=tempNode.left；
}
}
如果（数据比较到（上一数据）<0）{
prev.left=newNode；
}否则{
prev.right=newNode；
}
}
}
public void TraverseInNorder（TNode根目录，列表存储列表）{
if（root！=null）{
TraverseInNorder（root.left，storageList）；
storageList.add（root.data）；
TraverseInoder（root.right，storageList）；
}
}
公共void traversePreOrder（TNode根目录，列表存储列表）{
if（root！=null）{
storageList.add（root.data）；
traversePreOrder（root.left，storageList）；
traversePreOrder（root.right，storageList）；
}
}
公共void traversePostOrder（TNode根目录、列表存储列表）{
if（root！=null）{
traversePostOrder（root.left，storageList）；
traversePostOrder（root.right，storageList）；
storageList.add（root.data）；
}
}
公共作废打印列表（列表）{
对于（T项：列表）{
系统输出打印项次（项）；
}
}
公共静态void main（字符串参数[]）{
BinaryTree bTree=新的BinaryTree（）；
b.增加（50）；
b.增加（30）；
b.增加（60）；
b.增加（25）；
b.增加（40）；
b.增加（35）；
b.增加（70）；
b.增加（65）；
System.out.println（“##############”）；
List inOrderList=new ArrayList（）；
bTree.traverseInoder（bTree.getRoot（），inOrderList）；
b树打印列表（索引列表）；
System.out.println（“######预遍历####”）；
List preOrderList=new ArrayList（）；
bTree.traversePreOrder（bTree.getRoot（），preOrderList）；
b树打印列表（预订购列表）；
System.out.printl
Please find the BST using Generics, U can find more information on below link 

public class BinarySearchTree< T extends Comparable<T>> {
    Node root;
    class Node {
        T data;
        Node left;
        Node right;

        public Node(T data) {
            this.data = data;
        }
    }

    public boolean isEmpty() {
        return root == null;
    }

    public void insert(T value) {
        if(isEmpty())
            root = new Node(value);
        else
            insert(root, value);
    }

    private void insert(Node node, T value) {

        if(value.compareTo(node.data) < 0) {
            if(node.left == null)
                node.left = new Node(value);
            else
                insert(node.left, value);
        }
        else {
            if(node.right == null)
                node.right = new Node(value);
            else
                insert(node.right, value);
        }
    }

}

public class TNode<T extends Comparable<T>> {
    T data;
    public TNode<T> left;
    public TNode<T> right;

    public TNode(T data){
        this.data = data;
    }
}


import java.util.ArrayList;
import java.util.List;

public class BinaryTree<T extends Comparable<T>> {
private TNode root;

public TNode getRoot() {
    return this.root;
}

public void add(T data) {
    TNode<T> newNode = new TNode<T>(data);
    if (root == null) {
        root = newNode;
    } else {
        TNode<T> tempNode = root;
        TNode<T> prev = null;
        while (tempNode != null) {
            prev = tempNode;
            if (data.compareTo(tempNode.data) > 0) {
                tempNode = tempNode.right;
            } else {
                tempNode = tempNode.left;
            }
        }
        if (data.compareTo(prev.data) < 0) {
            prev.left = newNode;
        } else {
            prev.right = newNode;
        }

    }
}


public void traverseInOrder(TNode<T> root, List<T> storageList) {
    if (root != null) {
        traverseInOrder(root.left, storageList);
        storageList.add(root.data);
        traverseInOrder(root.right, storageList);
    }
}

public void traversePreOrder(TNode<T> root, List<T> storageList) {
    if (root != null) {
        storageList.add(root.data);
        traversePreOrder(root.left, storageList);
        traversePreOrder(root.right, storageList);
    }
}

public void traversePostOrder(TNode<T> root, List<T> storageList) {
    if (root != null) {
        traversePostOrder(root.left, storageList);
        traversePostOrder(root.right, storageList);
        storageList.add(root.data);
    }
}

public void printList(List<T> list) {
    for (T item : list) {
        System.out.println(item);
    }
}


public static void main(String args[]) {
    BinaryTree<Integer> bTree = new BinaryTree<>();
    bTree.add(50);
    bTree.add(30);
    bTree.add(60);
    bTree.add(25);
    bTree.add(40);
    bTree.add(35);
    bTree.add(70);
    bTree.add(65);

    System.out.println("#### Inorder Traversal ####");
    List<Integer> inOrderList = new ArrayList<>();
    bTree.traverseInOrder(bTree.getRoot(), inOrderList);
    bTree.printList(inOrderList);

    System.out.println("#### Pre Traversal ####");
    List<Integer> preOrderList = new ArrayList<>();
    bTree.traversePreOrder(bTree.getRoot(), preOrderList);
    bTree.printList(preOrderList);


    System.out.println("#### Post Traversal ####");
    List<Integer> postOrderList = new ArrayList<>();
    bTree.traversePostOrder(bTree.getRoot(), postOrderList);
    bTree.printList(postOrderList);


}