① 先根次序遍历查找首个关键字为key
BinaryNode<T> search(T key)
② 返回key结点所在的层次
int level(T key)
三、实验方法与步骤（需求分析、算法设计思路、流程图等）
实验一： 先根次序遍历查找首个关键字为key
分析： 首先要构造空二叉树，先根次序遍历二叉树。返回先根次序遍历二叉树所有结点的描述字符串，包含空子树标记。在以p为根的子树中查找并返回先根次序遍历中首次出现的关键字为key的结点，左右子树分别查找，若未找到，返回值null。
实验二返回key结点所在的层次
分析：返回key结点所在的层次，若空树或者未找到key,则返回-1.令根节点等于1。分别从左右子树查找，直到找出key所在的层次。
四、实验原始纪录（源程序、数据结构等）
public class BinaryNode<T>
{
public T data; //数据域，存储数据元素
public BinaryNode<T> left, right;//链域，分别指向左、右孩子结点
//构造结点，data指定元素，left、right分别指向左孩子和右孩子结点
public BinaryNode(T data, BinaryNode<T> left, BinaryNode<T> right)
{
this.data = data;
this.left = left;
this.right = right;
}
public BinaryNode(T data) //构造元素为data的叶子结点
{
this(data, null, null);
}
public String toString() //返回结点数据域的描述字符串
{
return this.data.toString();
}
public boolean isLeaf() //判断是否叶子结点
{
return this.left==null && this.right==null;
}
}
public class BinaryTree<T> //二叉树类，二叉链表存储，T指定结点的元素类型
{
public BinaryNode<T> root; //根结点，二叉链表结点结构
private Object value;
public BinaryTree() //构造空二叉树
{
this.root=null;
}
public boolean isEmpty() //判断是否空二叉树
{
return this.root==null;
}
public void preorder() //输出先根次序遍历序列
{
preorder(this.root);
System.out.println();
}
private void preorder(BinaryNode<T> p)
{
if(p!=null);
{
System.out.println(p.data.toString()+"");
preorder(p.left);
preorder(p.right);
}
}
public String toString() //返回先根次序遍历二叉树所有结点的描述字符串，包含空子树标记
{
return toString(this.root);
}
private String toString(BinaryNode<T> p)
{
if(p==null)
return"^";
return p.data.toString()+""+toString(p.left)+toString(p.right); 递归调用
}
public void inorder() //中根遍历
{
inorder(this.root);
System.out.println();
}
private void inorder(BinaryNode<T>p)
{
if(p!=null)
{
inorder(p.left);
System.out.print(p.data.toString()+"");
inorder(p.right);
}
}
public void postorder() //后根遍历
{
postorder(this.root);
System.out.println();
}
private void postorder(BinaryNode<T>p)
{
if(p!=null)
{
postorder(p.left);
postorder(p.right);
System.out.print(p.data.toString()+"");
}
}
//查找并返回先根次序遍历首次出现的关键字为key结点
public BinaryNode<T> search(T key)
{
return search(root, key);
}
// 方法一：在以p为根的子树中查找并返回首次出现的关键字为key元素结点，若未找到返回null，先根次序遍历
private BinaryNode<T> search(BinaryNode<T> p, T key)
{
if (p==null || key==null)
return null;
if (p.data.equals(key))
return p; //查找成功，返回找到结点
BinaryNode<T> find=search(p.left, key); //在左子树中查找，递归调用
if (find==null) //若在左子树中未找到
find=search(p.right, key); //则继续在右子树中查找，递归调用
return find; //返回查找结果
}
public boolean contains(T key) //判断是否包含关键字为key元素
{
return this.search(key)!=null; //
}
public BinaryTree(T[] prelist) //以先根和中根次序遍历序列构造二叉树
{
this.root = create(prelist);
}
private int i=0;
private BinaryNode<T> create(T[] prelist)
{
BinaryNode<T>p=null;
if(i<prelist.length)
{
T elem=prelist[i];
i++;
if (elem!=null)
{
p=new BinaryNode<T>(elem);
p.left=create(prelist);
p.right=create(prelist);
}
}
return p;
}
//方法二： 返回x结点所在的层次，若空树或未查找到x返回-1
public int getLevel(T x)
{
return getLevel(root, 1, x); //令根结点的层次为1
}
private int getLevel(BinaryNode<T> p, int i, T x)
{
if (p==null)
return -1;
if (p.data.equals(x))
return i; //查找成功
int level = getLevel(p.left, i+1, x); //在左子树查找
if (level==-1)
level = getLevel(p.right, i+1, x); //继续在右子树中查找
return level;
}
public static void main(String args[])
{
String[] prelist= {"A","B","D",null,"G",null,null,"C","E",null,null,"F","H"};
BinaryTree<String> bitree= new BinaryTree<String>(prelist);
System.out.println("二叉树的先根次序遍历序列： "+bitree.toString()); //标明空子树
System.out.println("二叉树的中根次序遍历序列： "); bitree.inorder();
System.out.println("二叉树的后根次序遍历序列： "); bitree.postorder();
System.out.println("先根次序遍历查找首个关键字为： "+bitree.search("B"));
bitree.getLevel("E");
System.out.println("查找的关键字所在层数为： " +bitree.getLevel("E"));
}
}
五、实验结果及分析（计算过程与结果、数据曲线、图表等）
实验结果：
