二叉树的遍历、查找与删除

为什么需要树这种数据结构？

（1）数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找检索速度。

缺点：如果要检索具体某个值，或者插入值（按一定顺序）会在整体移动，效率较低。

（2）链式存储方式的分析

优点：在一定程度上对数组存储方式有优化（比如：插入一个节点，只需要将插入节点链接到链表即可，删除效率也很好）

缺点：在进行检索时，效率仍然较低，比如（检索某个值，需要从头节点开始遍历）

（3）树存储方式的分析

能提高数据存储，读取的效率，比如利用二叉排序树，既可以保证数据的检索速度，同时也可以保证数据的插入、删除、修改的速度，同时也可以保证数据的插入、删除、修改的速度。

二叉树的前序、中序、后序遍历

前序遍历：先输出父节点，再遍历左子树和右子树

中序遍历：先遍历左子树，再输出父节点，再遍历右子树

后序遍历：先遍历左子树，再遍历右子树，最后输出父节点

小结：看输出父节点的顺序，就确定是前序，中序还是后序

//在节点类中
//编写前序遍历的方法
	public void preOrder() {
		System.out.println(this);//先输出父结点
		//递归向左子树前序遍历
		if(this.left!=null) {
			this.left.preOrder();
		}
		if(this.right!=null) {
			this.right.preOrder();
		}
	}
	
	//中序遍历
	public void midOrder() {
		//递归向左子树中序遍历
		if(this.left!=null) {
			this.left.midOrder();
		}
		System.out.println(this);//先输出父结点
		if(this.right!=null) {
			this.right.midOrder();
		}
	}
	
	//后序遍历
	public void postOrder() {
		if(this.left!=null) {
			this.left.postOrder();
		}
		if(this.right!=null) {
			this.right.postOrder();
		}
		System.out.println(this);//先输出父结点
	}

//在树类中
public void preOrder() {
		if(this.root!=null) {
			this.root.preOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	
	public void midOrder() {
		if(this.root!=null) {
			this.root.midOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	
	public void postOrder() {
		if(this.root!=null) {
			this.root.postOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}

二叉树-查找指定节点

//在节点类中
//前序查找
	public HeroNode preOrderSearch(int no) {
		if(root!=null) {
			return root.preOrdersearch(no);
		}else {
			return null;
		}
	}
	
	//中序遍历
	public HeroNode infixOrderSearch(int no) {
		if(root!=null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	
	//后续遍历
	public HeroNode postOrderSearch(int no) {
		if(root!=null) {
			return root.postOrderSearch(no);
		}else {
			return null;
		}
	}

//在树类中
//前序查找
	public HeroNode preOrderSearch(int no) {
		if(root!=null) {
			return root.preOrdersearch(no);
		}else {
			return null;
		}
	}
	
	//中序遍历
	public HeroNode infixOrderSearch(int no) {
		if(root!=null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	
	//后续遍历
	public HeroNode postOrderSearch(int no) {
		if(root!=null) {
			return root.postOrderSearch(no);
		}else {
			return null;
		}
	}

二叉树-删除节点

//在节点类中
	//递归删除节点
	//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 delNode(int no) {
		if(root!=null) {
			//如果只有一个root节点，这里立即判断root是不是就是要删除节点
			if(root.getNo()==no) {
				root=null;
			}else {
				//递归删除
				root.delNode(no);
			}
		}else {
			System.out.println("空树");
		}
	}

整体代码

package com.xxxx.tree;

public class BinaryTreeDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//先需要创建一颗二叉树
		BinaryTree binarytree=new BinaryTree();
		//创建需要的结点
		HeroNode root=new HeroNode(1,"宋江");
		HeroNode node2=new HeroNode(2,"吴用");
		HeroNode node3=new HeroNode(3,"卢俊义");
		HeroNode node4=new HeroNode(4,"林冲");
		HeroNode node5=new HeroNode(5,"关胜");
		
		//我们需要先手动创建二叉树
		root.setLeft(node2);
		root.setRight(node3);
		node3.setRight(node4);
		node3.setLeft(node5);
		binarytree.setRoot(root);
		
		
		//测试
		System.out.println("前序遍历");
		binarytree.preOrder();
		
		//测试
		System.out.println("中序遍历");
		binarytree.midOrder();
		
		//测试
		System.out.println("后序遍历");
		binarytree.postOrder();
		
		//测试
		System.out.println("前序查找");
		HeroNode heronode=binarytree.preOrderSearch(5);
		if(heronode!=null) {
			System.out.printf("id=%d,name=%s\n",heronode.getNo(),heronode.getName());
		}else {
			System.out.printf("没有找到no=%d的英雄",5);
		}
		
		//测试
		System.out.println("中序查找");
		heronode=binarytree.infixOrderSearch(5);
		if(heronode!=null) {
			System.out.printf("id=%d,name=%s\n",heronode.getNo(),heronode.getName());
		}else {
			System.out.printf("没有找到no=%d的英雄",5);
		}
		
		//测试
		System.out.println("后序查找");
		heronode=binarytree.postOrderSearch(5);
		if(heronode!=null) {
			System.out.printf("id=%d,name=%s",heronode.getNo(),heronode.getName());
		}else {
			System.out.printf("没有找到no=%d的英雄",5);
		}
		
		System.out.println("删除前，前序遍历");
		binarytree.preOrder();
		binarytree.delNode(3);	
		System.out.println("删除后，前序遍历");
		binarytree.preOrder();
		
		
	}

}

//定义BinaryTree二叉树
class BinaryTree{
	private HeroNode root;

	public void setRoot(HeroNode 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 midOrder() {
		if(this.root!=null) {
			this.root.midOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	
	public void postOrder() {
		if(this.root!=null) {
			this.root.postOrder();
		}else {
			System.out.println("二叉树为空，无法遍历");
		}
	}
	
	//前序查找
	public HeroNode preOrderSearch(int no) {
		if(root!=null) {
			return root.preOrdersearch(no);
		}else {
			return null;
		}
	}
	
	//中序遍历
	public HeroNode infixOrderSearch(int no) {
		if(root!=null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	
	//后续遍历
	public HeroNode postOrderSearch(int no) {
		if(root!=null) {
			return root.postOrderSearch(no);
		}else {
			return null;
		}
	}
	
}

//先创建HeroNode节点
class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	public HeroNode(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 HeroNode getLeft() {
		return left;
	}
	public void setLeft(HeroNode left) {
		this.left = left;
	}
	public HeroNode getRight() {
		return right;
	}
	public void setRight(HeroNode right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "HeroNode [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 midOrder() {
		//递归向左子树中序遍历
		if(this.left!=null) {
			this.left.midOrder();
		}
		System.out.println(this);//先输出父结点
		if(this.right!=null) {
			this.right.midOrder();
		}
	}
	
	//后序遍历
	public void postOrder() {
		if(this.left!=null) {
			this.left.postOrder();
		}
		if(this.right!=null) {
			this.right.postOrder();
		}
		System.out.println(this);//先输出父结点
	}
	
	//前序遍历查找
	public HeroNode preOrdersearch(int no) {
		//比较当前节点是不是
		if(this.no==no) {
			return this;
		}
		//1.则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
		//2.如果左递归前序查找，找到节点，则返回
		HeroNode 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 HeroNode infixOrderSearch(int no) {
		//判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
		HeroNode 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 HeroNode postOrderSearch(int no) {
		//判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
				HeroNode 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;
	}
	
	
}