java实现二叉树前序中序后序遍历查找以及删除节点

package course;

public class BinaryTreeDemo {
	public static void main(String[] args) {
		// 先需要创建一颗二叉树
		BinaryTree binaryTree = new BinaryTree();
		// 创建需要的节点
		HeroNodes root = new HeroNodes(1, "宋江");
		HeroNodes node2 = new HeroNodes(2, "吴用");
		HeroNodes node3 = new HeroNodes(3, "卢俊义");
		HeroNodes node4 = new HeroNodes(4, "林冲");
		HeroNodes node5 = new HeroNodes(5, "关胜");
		
		// 说明，我们先手动创建该二叉树，后面以递归的方式创建二叉树
		root.setLeft(node2);
		root.setRight(node3);
		node3.setRight(node4);
		node3.setLeft(node5);
		binaryTree.setRoot(root);
		
		/*
		// 测试
		System.out.println("前序遍历"); // 1, 2, 3, 5, 4
		binaryTree.preOrder();
		
		System.out.println("中序遍历"); // 2, 1, 5, 3, 4
		binaryTree.infixOrder();
		
		System.out.println("后序遍历"); // 2, 5, 4, 3, 1
		binaryTree.postOrder();
		
		// 前序查找
		// 前序比较的次数(4)
		System.out.println("前序查找");
		HeroNodes resNode = binaryTree.preOrderSearch(5);
		if (resNode != null) {
			System.out.println("找到了，信息为：" + resNode);
		} else {
			System.out.println("没有找到no = " + 5 + "的英雄");
		}
		
		// 中序查找
		// 中序比较的次数(3)
		System.out.println("中序查找");
		resNode = binaryTree.infixOrderSearch(5);
		if (resNode != null) {
			System.out.println("找到了，信息为：" + resNode);
		} else {
			System.out.println("没有找到no = " + 5 + "的英雄");
		}
		
		// 后序查找
		// 后序比较 的次数(2)
		System.out.println("后序查找");
		resNode = binaryTree.postOrderSearch(5);
		if (resNode != null) {
			System.out.println("找到了，信息为：" + resNode);
		} else {
			System.out.println("没有找到no = " + 5 + "的英雄");
		}
		*/
		
		// 测试-删除节点
		System.out.println("删除前，前序遍历");
		binaryTree.preOrder();
		//binaryTree.delNode(5);
		binaryTree.delNode(3);
		System.out.println("删除后，前序遍历");
		binaryTree.preOrder();
	}
}

// 定义BinaryTree二叉树
class BinaryTree {
	private HeroNodes root;
	
	public void setRoot(HeroNodes root) {
		this.root = root;
	}
	
	// 删除节点
	public void delNode(int no) {
		if (root != null) {
			 // 如果只有一个root系欸但，这里立即判断root是不是要删除的节点
			if (root.getNo() == no) {
				root = null;
			} else {
				// 递归删除
				root.delNode(no);
			}
		} else {
			System.out.println("空树不能删除");
		}
	}
	
	// 前序遍历
	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 HeroNodes preOrderSearch(int no) {
		if (root != null) {
			return root.preOrderSearch(no);
		} else {
			return null;
		}
	}
	
	// 中序查找
	public HeroNodes infixOrderSearch(int no) {
		if (root != null) {
			return root.infixOrderSearch(no);
		} else {
			return null;
		}
	}
	
	// 后序遍历
	public HeroNodes postOrderSearch(int no) {
		if (root != null) {
			return root.postOrderSearch(no);
		} else {
			return null;
		}
	}
}

// 先创建HeroNode节点
class HeroNodes {
	private int no;
	private String name;
	private HeroNodes left; // 默认null
	private HeroNodes right; // 默认null
	
	public HeroNodes(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 HeroNodes getLeft() {
		return left;
	}
	public void setLeft(HeroNodes left) {
		this.left = left;
	}
	public HeroNodes getRight() {
		return right;
	}
	public void setRight(HeroNodes right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "HeroNodes [no=" + no + ", name=" + name + "]";
	}
	
	// 递归删除节点
	// 1. 如果删除的节点是叶子节点，则删除该节点
	// 2. 如果删除的节点是非叶子节点，则删除该子树
	public void delNode(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.delNode(no);
		}
		// 右子树递归删除
		if (this.right != null) {
			this.right.delNode(no);
		}
	}
	
	
	// 编写前序遍历的方法
	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);
	}
	
	// 前序遍历查找
	/**
	 * @param no 查找no
	 * @return 如果找到就返回该Node，如果没有找到返回null
	 */
	public HeroNodes preOrderSearch(int no) {
		// 和当前节点比较，如果是则返回当前节点
		if (this.no == no) {
			return this;
		}
		// 1. 判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
		// 2. 如果左递归前序查找找到节点，则返回
		HeroNodes resNode = null;
		if (this.left != null) {
			resNode = this.left.preOrderSearch(no);
		}
		if (resNode != null) { // 说明左子树找到
			return resNode;
		}
		// 1. 判断当前节点的右子节点是否为空，如果不为空，则递归前序查找
		// 2. 如果右递归前序查找找到节点，则返回
		if (this.right != null) {
			resNode = this.right.preOrderSearch(no);
		}
		return resNode;
	}
	
	// 中序遍历查找
	public HeroNodes infixOrderSearch(int no) {
		// 判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
		HeroNodes resNode = null;
		if (this.left != null) {
			resNode = this.left.infixOrderSearch(no);
		}
		if (resNode != null) {
			return resNode;
		}
		// 和当前节点比较，如果是则返回当前节点
		if (this.no == no) {
			return this;
		}
		// 判断当前节点的右子节点是否为空，如果不为空，则递归前序查找
		if (this.right != null) {
			resNode = this.right.infixOrderSearch(no);
		}
		return resNode;
	} 
	
	// 后序遍历查找
	public HeroNodes postOrderSearch(int no) {
		// 判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
		HeroNodes resNode = null;
		if (this.left != null) {
			resNode = this.left.postOrderSearch(no);
		}
		if (resNode != null) {
			return resNode;
		}
		// 判断当前节点的右子节点是否为空，如果不为空，则递归前序查找
		if (this.right != null) {
			resNode = this.right.postOrderSearch(no);
		}
		if (resNode != null) {
			return resNode;
		}
		// 和当前节点比较，如果是则返回当前节点
		if (this.no == no) {
			return this;
		}
		return resNode;
	}
}