二叉树

暂时先写了这八个方法

1. 二叉树增加成员方法
   BinaryTree二叉树类增加以下成员方法，public权限。
   （1）成员方法，递归算法
   6-1 BinaryTree(T prelist[], T inlist[]) //以先根和中根序列构造二叉树
   6-2 BinaryTree create(T inlist[], T postlist[]) //以中根和后根次序遍历序列构造二叉树
   6-3 int level(T key) //返回key结点所在的层次
   6-4 BinaryNode search(T key) //先根次序遍历查找首个关键字为key结点
   6-5 BinaryNode parent(BinaryNode node) //返回node的父母结点
   6-6 boolean equals(Object obj) //比较两棵二叉树是否相等
   6-7 BinaryNode search(BinaryTree pattern) //先根次序遍历查找首个与pattern匹配的子树
   6-8 void removeAll(BinaryTree pattern) //删除所有与pattern匹配的子树

贴上代码吧

首先下面的是一个节点类，我对data，左孩子，右孩子都加了封装，对于以后的操作比较操蛋，大家可以改为public，其中内容也就（data，左孩子，右孩子，构造方法，返回data、左孩子、右孩子，设置。。。。。。）等一些操作

package Tree;

public class BinaryTreeNode<T> {
	private T data;
	private BinaryTreeNode<T> right;
	private BinaryTreeNode<T> left;
	public T getdata()
	{
		return this.data;
	}
	public BinaryTreeNode<T> getright()
	{
		return this.right;
	}
	public BinaryTreeNode<T> getleft()
	{
		return this.left;
	}//return value
	public void set(T data,BinaryTreeNode<T> left,BinaryTreeNode<T> right)
	{
		this.data = data;
		this.left = left;
		this.right = right;
	}
	public void set(T data)
	{
		this.set(data, null, null);
	}//add value
	public BinaryTreeNode(T data,BinaryTreeNode<T> left,BinaryTreeNode<T> right)
	{
		this.data = data;
		this.right = right;
		this.left = left;
	}//构造函数
	public String toString()
	{
		return this.data.toString();
	}
	public boolean isLeaf() 
	{
		return this.right==null ||this.left==null;
	}
	public boolean equals(BinaryTreeNode<T> parent)
	{
		return equals(parent,this);
	}
	private boolean equals(BinaryTreeNode<T> parent,BinaryTreeNode<T> this_)
	{
		if(parent==null&&this_==null)
			return true;
		if(parent==null||this_==null)
			return false;
			
		if(parent.getdata()==this_.getdata())
			return equals(parent.left,this_.left)&&equals(parent.right,this_.right);
		
		return false;
		
	}//比较两节点是否相等
	

}

下面就是由结点构成的二叉树了，除了包括一些必要的方法，当然还要写一些题目，1-8条规定必须要用递归，断断续续写了两个星期终于写好了。这几道题有了一些算法难度，希望大家多多研讨叶奶奶的书。以后有时间，再给大家写写解析吧。。

package Tree;

public class BinaryTree<T> {
	BinaryTreeNode<T> root;

	public BinaryTree(T data) {
		this.root = new BinaryTreeNode<T>(data, null, null);
	}

	public BinaryTree() {
		this.root = new BinaryTreeNode<T>(null, null, null);
	}

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

	public int size() {
		BinaryTreeNode parent = this.root;
		return preorder_size(parent);

	}
	public BinaryTree<T> copy()
	{
		BinaryTree<T> t = new BinaryTree<>();
		t.root = this.copy(this.root);
		return t;
	}
	public BinaryTreeNode<T> copy(BinaryTreeNode<T> temp1)
	{
		
		if(temp1==null)
			return null;
		//BinaryTreeNode<T> parent= new BinaryTreeNode(temp1.getdata(), null, null);
		if(temp1.getleft()==null&&temp1.getright()==null)
			return new BinaryTreeNode(temp1.getdata(), null, null);
		
		else
			return new BinaryTreeNode<T>(temp1.getdata(),copy(temp1.getleft()), temp1.getright());
		
	}
	//深拷贝

	private int preorder_size(BinaryTreeNode<T> parent) {
		if (parent == null)
			return 0;
		else {
			return preorder_size(parent.getleft()) + 1 + preorder_size(parent.getright()) + 1;
		}
	}// 以上两个方法，使用先序遍历，查找出size

	public int height() {
		return preorder_height(this.root);
	}

	public int preorder_height(BinaryTreeNode<T> parent) {
		int m, n;
		if (parent == null)
			return 0;
		m = preorder_height(parent.getleft()) + 1;
		n = preorder_height(parent.getright()) + 1;
		return m > n ? m : n;
	}// 与求size算法相同，且算法更简单

	public String toString() {
		return this.toString(this.root);
	}

	private String toString(BinaryTreeNode<T> parent) {
		if (parent == null) {
			return "^";
		}
		return parent.getdata().toString() + " " + toString(parent.getleft()) + " " + toString(parent.getright());
	}

	// 前序遍历返回字符串
	/*
	 * 6-1 BinaryTree(T prelist[], T inlist[]) 以先根和中根序列构造二叉树
	 */
	public BinaryTree(T prelist[], T inlist[]) {
		this.root = jianshu(prelist, inlist, 0, prelist.length - 1, 0, inlist.length - 1);
	}// 构造函数

	public BinaryTreeNode<T> jianshu(T prelist[], T inlist[], int start1, int end1, int start2, int end2) {
		if (end1 < start1 || end2 < start2)
			return null;
		BinaryTreeNode<T> parent = new BinaryTreeNode(null, null, null);

		T value = prelist[start1]; //
		if (start1 == end1) {
			parent = new BinaryTreeNode<>(value, null, null);

			// System.out.println("这个结点"+"null"+value+"null");
			return parent;
		}
		int j = start2;
		for (; j <= end2; j++) {
			if (value.equals(inlist[j])) {
				break;
			}
		}
		if (j == start2) {
			parent.set(value, null, jianshu(prelist, inlist, start1 + 1, end1, start2 + 1, end2));
			// System.out.println("左孩子为空"+value+"右孩子");
			return parent;
		}

		if (start2 == end2) {
			parent.set(value, null, null);
			return parent;
		}
		if (j == end2) {
			parent.set(value, jianshu(prelist, inlist, start1 + 1, end1, start2, end2 - 1), null);

			// System.out.println("j==end2");
			// System.out.println("这个节点是"+"null" + value+"null");
		}
		if (start1 > end1) {
			return null;
		}

		parent.set(value, jianshu(prelist, inlist, start1 + 1, start1 + j - start2, start2, j - 1),
				jianshu(prelist, inlist, start1 + j - start2 + 1, end1, j + 1, end2));
		return parent;

	}

	// 6-2 BinaryTree<T> create(T inlist[], T postlist[])
	// 以中根和后根次序遍历序列构造二叉树
	public BinaryTree<T> create(T inlist[], T postlist[]) {
		BinaryTree<T> tree = new BinaryTree<>();
		tree.root = jianshu1(inlist, postlist, 0, inlist.length - 1, 0, inlist.length - 1);
		return tree;
	}

	private BinaryTreeNode<T> jianshu1(T inlist[], T postlist[], int start1, int end1, int start2, int end2) {
		if (start1 > end1 || start2 > end2)
			return null;
		BinaryTreeNode<T> parent;// 作为返回的
		int j = start1;
		T value = postlist[end2];
		for (; j <= end1; j++) {
			if (inlist[j].equals(postlist[end2]))
				break;
		}

		if (j == start1) {
			parent = new BinaryTreeNode<T>(value, null, jianshu1(inlist, postlist, j + 1, end1, start2, end2 - 1));
			return parent;
		}
		if (j == end1) {
			parent = new BinaryTreeNode<T>(value, jianshu1(inlist, postlist, start1, end1 - 1, start2, end2 - 1), null);
		}
		parent = new BinaryTreeNode(value, jianshu1(inlist, postlist, start1, j - 1, start2, start2 + j - start1 - 1),
				jianshu1(inlist, postlist, j + 1, end1, start2 + j - start1, end2 - 1));
		return parent;

	}

	// 6-3 int level(T key)
	// 返回key结点所在的层次
	public int level(T key) {
         return(level(key,this.root));
	}

	private int level(T key,BinaryTreeNode<T> node)
	{   int l1,r1;
	if(node==null) return 0;	
	if(node.getdata().equals(key))//当找到相同的，终止
			return 1;
		else
		{
			l1 = level(key,node.getleft());
			r1 = level(key,node.getright());
			if(l1!=0)
				return l1+1;
			else if(r1!=0)
				return r1+1;
			else return 0;
			
					
		}
			
	}

	// 6-4
	// BinaryNode<T> search(T key)
	// 先根次序遍历查找首个关键字为key结点

	private static BinaryTreeNode temp;
	private static int flag=0;// 一个标记

	private boolean search(T key,BinaryTreeNode<T> node)
	{  
		if(node==null)//如果为空，终止
		return false;
		if(key.equals(node.getdata()))
			{temp = node;
			flag=1;//标记是否找到
			return true;
			
			}
		else
		{
			search(key,node.getleft());
			search(key,node.getright());
		}
		if(flag==1)
			return true;
		else
			return false;//通过标记确认是否找到
}

	public BinaryTreeNode<T> search(T key) {
		flag = 0; // 标记还原
		if (search(key, this.root))
			return temp;
		else {
			System.out.println("查找不到");
			return null;
		}
	}
//	6-5  BinaryNode<T> parent(BinaryNode<T> node)      	
//	返回node的父母结点
        public BinaryTreeNode<T> parent(BinaryTreeNode<T> node)
        {   
        	if(node.equals(this.root))
        		return null;
        	return parent(node,this.root);     	
        }
        private BinaryTreeNode<T> parent(BinaryTreeNode<T> node1,BinaryTreeNode<T> node2)
        {
        	if(node2==null)
        		return null;
        	if(node1.equals(node2.getleft())||node1.equals(node2.getright()))
        	{
        		return node2;
        	}
        	else
        	{
        		BinaryTreeNode<T> l =parent(node1,node2.getleft());
        		if(l!=null) return l;
        		BinaryTreeNode<T> r = parent(node1,node2.getright());
        		
        		if(r!=null) return r;
        	}
        		
        	return null;
        		
        }
        //6-7
        //BinaryNode<T> search(BinaryTree<T> pattern)     
        //先根次序遍历查找首个与pattern匹配的子树
        public BinaryTreeNode<T> search(BinaryTree<T> pattern)
        {
        	return search(pattern.root,this.root);
        }
        private BinaryTreeNode<T> search(BinaryTreeNode<T> pattern,BinaryTreeNode<T> parent)
        {
        	if(parent==null)
        		return null;
        	if(parent.equals(pattern))
        		return parent;
        	else
        	{
        		BinaryTreeNode<T> l = search(pattern,parent.getleft());
        		if(l!=null)
        			return l;
        		BinaryTreeNode<T> r =search(pattern,parent.getright());
        		if(r!=null)
        			return r;
        	}
        	return null;
        }
        //6-8
        //void removeAll(BinaryTree<T> pattern)          	
        //删除所有与pattern匹配的子树

        public void removeAll(BinaryTree<T> pattern)
        {
        	BinaryTreeNode<T> parent1 = parent(pattern.root);
        	if(parent1!=null)
        	{
        		if(parent1.getleft().getdata().equals(pattern.root.getdata()))
        			parent1.set(parent1.getdata(),null,parent1.getright());
        		else
        		parent1.set(parent1.getdata(),parent1.getleft(),null);
        		removeAll(pattern);
        	}
        }
       
	
}

在下就是测试了。。。

package Tree;

public class Test <T>{
public static void main(String[] args) {
	
	Integer a[] = {1,34,56,325,675,87,45,67,34,1,23,4,3,22};
	
			
	Integer b[] = {1,34,56};
	Integer c[] = {1,34,56,325,10,87,45,67,34,1};
	Integer f1[] = {8,8,8};
	String d[] = {"fjdskf"};
	Character a1[] = {'A','B','D','G','C','E','F','H'};
	Character a2[] = {'D','G','B','A','E','C','H','F'};
//先序和中序
	BinaryTree<Character> test_use = new BinaryTree<Character>(a1, a2);
    System.out.println("__________________"); 
    System.out.println(test_use.toString());
  //中序和后序
    Character a3[] = {'G','D','B','E','H','F','C','A'};
    System.out.println("根据中序和后序");
    BinaryTree<Character> test_use1 = test_use.create(a2, a3);
    System.out.println(test_use1.toString());
    //查找key
    System.out.println(test_use.search('H').toString());
    返回key结点所在的层次
    System.out.println("F在第"+test_use.level('F')+"层");
    //拷贝
    BinaryTree<Character> test_use2 = test_use1.copy();
    System.out.print("拷贝后的");
    System.out.println(test_use2.toString());
    //返回父亲结点
    BinaryTreeNode<Character> test_node = test_use1.root.getright().getright();
    System.out.println(test_use.parent(test_node).toString());
    //先根次序遍历查找首个与pattern匹配的子树
    BinaryTree<Character> test_use3= new BinaryTree<>(); 
    BinaryTree<Character> test_use4= new BinaryTree<>();
    test_use3.root = test_node;
    test_use4.root = test_use.search(test_use3);
    System.out.println(test_use.toString()+"查找"+test_use3.toString()+"的结果为"+test_use4.toString());
    System.out.println(test_node.toString());
    System.out.println(test_use3.toString());
    //6-8  //删除所有与pattern匹配的子树
 
    test_use.removeAll(test_use3);
   System.out.println(test_use.toString());

}
}