Java泛型类测试
我试图测试我编写的java泛型类，这是我的测试Java泛型类测试,java,generics,binary-search-tree,Java,Generics,Binary Search Tree,我试图测试我编写的java泛型类，这是我的测试 public class BSTTest { public void testInsert() { int height; BST<int> myTree = new BST<int>(); myTree.insert(1); } } 公共类测试 { 公共无效测试集（） { 内部高度； BST myTree=new BST（）； myTree.in
public class BSTTest
{
public void testInsert()
{
int height;
BST<int> myTree = new BST<int>();
myTree.insert(1);
}
}
公共类测试
{
公共无效测试集（）
{
内部高度；
BST myTree=new BST（）；
myTree.insert（1）；
}
}
public class BST<E extends Comparable<E>>
{
public Node<E> root;
public BST()
{
root = null;
}
//insert delete find height
public void find(E s, Node<E> n)
{
//empty tree, root is null
if(n == null)
{
System.out.println("Item not present.");
}
//n is the node where s is, return n
else if(n.getData().equals(s))
{
System.out.println("Item present");
}
//s is greater than n, look for s on the right subtree
else if(s.compareTo(n.getData()) > 0)
{
find(s, n.getRight());
}
//s is less than n, look for s on the left subtree
else
{
find(s, n.getLeft());
}
}
public int height()
{
int count;
return count = height(root);
}
private int height(Node<E> n)
{
int ct = 0;
if(n == null)
{
}
else
{
int left = height(n.getLeft());
int right = height(n.getRight());
ct = Math.max(left, right) + 1;
}
return ct;
}
public void insert(E s)
{
root = insert(s, root);
}
private Node<E> insert(E s, Node<E> T)
{
//easiest case, empty tree, create new tree
if(T == null)
{
T = new Node<E>(s,null,null);
}
//easiest case, found s
else if(s.compareTo(T.getData()) == 0)
{
System.out.println("Item already present.");
}
//s is greater than T, insert on right subtree
else if(s.compareTo(T.getData()) > 0)
{
T.setRight(insert(s, T.getRight()));
}
//s is less than T, insert on left subtree
else
{
T.setLeft(insert(s,T.getLeft()));
}
return T;
}
public void delete(E d)
{
}
}
公共类BST
{
公共节点根；
公共BST（）
{
root=null；
}
//插入删除查找高度
公共无效查找（ES，节点n）
{
//空树，根为空
如果（n==null）
{
System.out.println（“项目不存在”）；
}
//n是s所在的节点，返回n
else如果（n.getData（）.equals）
{
系统输出打印项次（“存在项”）；
}
//s大于n，请在右子树上查找s
如果（s.compareTo（n.getData（））>0）为else
{
查找（s，n.getRight（））；
}
//s小于n，在左子树上查找s
其他的
{
查找（s，n.getLeft（））；
}
}
公共整数高度（）
{
整数计数；
返回计数=高度（根）；
}
专用整数高度（节点n）
{
int-ct=0；
如果（n==null）
{
}
其他的
{
int left=高度（n.getLeft（））；
int right=高度（n.getRight（））；
ct=数学最大值（左、右）+1；
}
返回ct；
}
公共空白插入（E-s）
{
根=插入（s，根）；
}
专用节点插入（ES、节点T）
{
//最简单的情况，空树，创建新树
如果（T==null）
{
T=新节点（s，null，null）；
}
//最简单的情况，发现
else if（s.compareTo（T.getData（））==0）
{
System.out.println（“项目已存在”）；
}
//s大于T，在右子树上插入
如果（s.compareTo（T.getData（））>0），则为else
{
T.setRight（插入（s，T.getRight（））；
}
//s小于T，在左子树上插入
其他的
{
T.setLeft（插入（s，T.getLeft（））；
}
返回T；
}
公共作废删除（E-d）
{
}
}
public class Node<E>
{
private E data;
private Node<E> left;
private Node<E> right;
private Node<E> parent;
public Node(E d, Node<E> r, Node<E> l)
{
data = d;
left = l;
right = r;
}
public void setData(E d)
{
data = d;
}
public E getData()
{
return data;
}
public Node<E> getRight()
{
return right;
}
public void setRight(Node<E> nd)
{
right = nd;
}
public Node<E> getLeft()
{
return left;
}
public void setLeft(Node<E> nd)
{
left = nd;
}
public Node<E> getParent()
{
return parent;
}
public void setParent(Node<E> nd)
{
parent = nd;
}
}
公共类节点
{
私人电子数据；
私有节点左；
私有节点权；
私有节点父节点；
公共节点（ED、节点r、节点l）
{
数据=d；
左=l；
右=r；
}
公共无效设置数据（ED）
{
数据=d；
}
公共E getData（）
{
返回数据；
}
公共节点getRight（）
{
返还权；
}
公共无效设置权限（节点nd）
{
右=nd；
}
公共节点getLeft（）
{
左转；
}
公共void setLeft（节点nd）
{
左=右；
}
公共节点getParent（）
{
返回父母；
}
公共void setParent（节点nd）
{
父母=nd；
}
}
整数整数整数整数应该是
BST<Integer> myTree = new BST<Integer>();
BST myTree=new BST（）；
应该是
BST<Integer> myTree = new BST<Integer>();
BST myTree=new BST（）；
intBSTintBSTintIntegerintInteger