二叉树

写了一个二叉树，可以完成增删查的功能，但不够完善，后续会进行改进。特别注意如果要对查找操作计数，注意计数的代码所在位置。另外有地方可以进行优化：例如在进行删除操作的时候，即便在对树的左结点遍历时完成了删除操作该代码仍然将右结点进行了遍历。

class BinaryTreeDemo {
	public static void main(String[] args) {
		BinaryTree bi=new BinaryTree();
		Book root=new Book(1,"Joker");
		Book book2=new Book(2,"No face man");
		Book book3=new Book(3,"Traveler");
		Book book4=new Book(4,"Immortal");
		Book book5=new Book(5,"Red sacrifices");
		Book book6=new Book(6,"Light trap");
		Book book7=new Book(7,"Handed man");
		
		//手动创建二叉树
		root.setLeft(book2);
		root.setRight(book3);
		book3.setRight(book4);
		book3.setLeft(book5);
		bi.setRoot(root);
		
		System.out.println("前序遍历");
		bi.preOrder();
		System.out.println("中序遍历");
		bi.infixOrder();
		System.out.println("后序遍历");
		bi.postOrder();
		
		System.out.println("前序遍历查找");
		Book resbook=bi.preOrderSearch(5);
		if(resbook!=null) {
			System.out.println(resbook);
		}else {
			System.out.println("没有找到编号为"+5+"的书");
		}
		System.out.println("后序遍历查找");
		Book resbook1=bi.postOrderSearch(5);
		if(resbook1!=null) {
			System.out.println(resbook1);
		}else {
			System.out.println("没有找到编号为"+5+"的书");
		}
		
		System.out.println("删除节点");
		bi.del(5);
		bi.preOrder();
	}
}
class BinaryTree {
	private Book root;
	public void setRoot(Book root) {
		this.root=root;
	}
	//前序遍历
	public void preOrder() {
		if(this.root!=null) {
			this.root.preOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	//中序遍历
	public void infixOrder() {
		if(this.root!=null) {
			this.root.infixOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.root!=null) {
			this.root.postOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	
	//三种查找方式
	public Book preOrderSearch(int no) {
		if(root!=null) {
			return root.preOrderSearch(no);
		}else {
			return null;
		}
	}
	public Book infixOrderSearch(int no) {
		if(root!=null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	public Book postOrderSearch(int no) {
		if(root!=null) {
			return root.postOrderSearch(no);
		}else {
			return null;
		}
	}
	
	//删除
	public void del(int no) {
		if(root!=null) {
			if(root.getNo()==no) {
				root=null;
			}else {
				root.del(no);
			}
		}else {
			System.out.println("空树无法删除");
		}
	}
}
class Book {
	private int no;
	private String name;
	private Book left;
	private Book right;
	public Book(int no,String name) {
		this.no=no;
		this.name=name;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Book getLeft() {
		return left;
	}
	public void setLeft(Book left) {
		this.left = left;
	}
	public Book getRight() {
		return right;
	}
	public void setRight(Book right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "Book [no=" + no + ", name=" + name + "]";
	}
	//编写前序遍历的方法
	public void preOrder() {
		System.out.println(this);//先输出父节点
		//递归向左子树遍历
		if(this.left!=null) {
			this.left.preOrder();
		}
		//递归向右子树遍历
		if(this.right!=null) {
			this.right.preOrder();
		}
	}
	//中序遍历
	public void infixOrder() {
		//递归向左子树遍历
		if(this.left!=null) {
			this.left.infixOrder();
		}
		//输出父节点
		System.out.println(this);
		//递归向右子树中序遍历
		if(this.right!=null) {
			this.right.infixOrder();
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.left!=null) {
			this.left.postOrder();
		}
		if(this.right!=null) {
			this.right.postOrder();
		}
		System.out.println(this);
	}
	
	// 前序遍历查找
	public Book preOrderSearch(int no) {
		//当前节点是不是空
		if (this.no == no) {
			return this;
		}
		//1、判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
		//2、如果左递归前序查找，找到节点，则返回
		Book resbook=null;
		if (this.left != null) {
			resbook=this.left.preOrderSearch(no);
		}
		if(resbook!=null) {//说明我们左子树找到
			return resbook;
		}
		//1、左递归前序查找，找到节点，则返回，否继续判断
		//2、当前节点的右子节点是否为空，如果不为空，则继续右递归前序查找
		if(this.right!=null) {
			resbook=this.right.preOrderSearch(no);
		}
		return resbook;
	}
	
	//中序遍历查找
	public Book infixOrderSearch(int no) {
		Book resbook=null;
		if(this.left!=null) {
			 resbook=this.left.infixOrderSearch(no);
		}
		if(resbook!=null) {
			return resbook;
		}
		if(this.no==no) {
			return this;
		}
		if(this.right!=null) {
			resbook=this.right.infixOrderSearch(no);
		}
		return resbook;
	}
	
	//后序遍历查找
	public Book postOrderSearch(int no) {
		Book resbook=null;
		if(this.left!=null) {
			resbook=this.left.postOrderSearch(no);
		}
		if(resbook!=null) {//说明在左子树找到
			return resbook;
		}
		//如果左子树没有找到则向右递归进行后序遍历查找
		if(this.right!=null) {
			resbook=this.right.postOrderSearch(no);
		}
		if(resbook!=null) {
			return resbook;
		}
		//如果左右子树都没有找到
		System.out.println("进行了一次查找");//注意计数是在比较之前
		if(this.no==no) {
			return this;
		}else {
			return resbook;
		}
	}
	
	//递归删除结点
	public void del(int no) {
		//如果当前节点的左子节点不为空，并且左子节点就是要删除的节点就将
		//左子节点置为空并返回
		if(this.left!=null&&this.left.no==no) {
			this.left=null;
			return;
		}
		if(this.right!=null&&this.right.no==no) {
			this.right=null;
			return;
		}
		if(this.left!=null) {
			this.left.del(no);
		}
		if(this.right!=null) {
			this.right.del(no);
		}
	}
}