二叉树的遍历

二叉树的遍历

1.什么是二叉树 Binary Tree
二叉树是有限个节点的集合，这个集合可以是空集，也可以是一个根节点和至多两个子二叉树组成的集合，其中一颗树叫做根的左子树，另一棵叫做根的右子树。
**

接口

package thread_study02_thread02;
/**
 * 二叉树的接口
 * 可以有不同的实现类,每个类可以使用不同的存储结构,比如顺寻结构,或链式结构的
 * 
 * */
public interface BinaryTree {
	//是否是空树
	public boolean isEmpty();
	//获取二叉树的节点的数量
	public int size();
	//获取二叉树的高度
	public int getHight();
	//查询指定的节点
	public Note findKey(int value);
	//前序递归遍历
	public void preOrderTraverse();
	//中序递归遍历
	public void inOrderTraverse();
	//后序递归遍历
	public void postOrderTraverse();
	
	public  void postOrderTraverse(Note note); 
	/**
	 * 中序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public void inOrderByStack();
	/**
	 *   前序遍历非递归操作
	 *   1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 *   2）若左子树为空，栈顶节点出栈，将该节点的右子树置为current 
	 *   3) 重复1、2步操作，直到current为空且栈内节点为空。
	 */
	public  void preOrderByStack(); 
	/**
	 * 后序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public  void postOrderByStack(); 
	
	/**
	 * 按照层次遍历二叉树
	 */
	public void levelOrderByQueue();
	
}

实现类

package thread_study02_thread02;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

public class BinaryTreeImpl implements BinaryTree {
	private  Note root; //根节点
	
	public BinaryTreeImpl() {
		super();
	}

	public BinaryTreeImpl(Note root) {
		super();
		this.root = root;
	}

	//是否是空树
	public boolean isEmpty() {
		if(root==null) {
			return false;
		}
		return true;
	}

	//二叉树的节点数量
	public int size() {
		System.out.println("二叉树的节点数量");
		return size(root);
	}
	public int size(Note root) {
		if(root==null) {
			return 0;
		}else{
			//获取左子树的节点
			int sl = this.size(root.leftChild);
			//获取右子树的节点
			int sr = this.size(root.rightChild);
			//左子树的节点加右子树的节点+1 
			return sl+sr+1;
		}
	}

	@Override
	public int getHight() {
		System.out.println();
		System.out.println("二叉树的高度");
		return this.getHight(root);
	}
	public int getHight(Note root) {
		if(root == null) {
			return 0;
		}else {
			//获取左子树的高度
			int nl = this.getHight(root.leftChild);
			//获取右子树的高度
			int nr = this.getHight(root.rightChild);
			//返回左子树右子树较大高度并加1 
			return nl>nr ? nl+1 : nr+1;
		}
	}

	@Override
	public Note findKey(int value) {
		// TODO Auto-generated method stub
		return null;
	}

	//递归前序遍历
	public void preOrderTraverse() {
		//输出根节点的值
		if(root != null) {
			System.out.print(root.data+"\t");
			//对左子树进行先序遍历
			//创建左子树
			BinaryTree left = new BinaryTreeImpl(root.leftChild);
			left.preOrderTraverse();
			
			//对右子树进行先序遍历 
			//创建右子树
			BinaryTree right = new BinaryTreeImpl(root.rightChild);
			right.preOrderTraverse();
		}
	}

	//中旭遍历
	public void inOrderTraverse() {
		System.out.println();
		System.out.println("中序遍历");
		this.inOrderTraverse(root);
	}
	private void inOrderTraverse(Note root) {
		if(root != null) {
			//1.遍历左子树
			 this.inOrderTraverse(root.leftChild);
			
			//2.输出根的值
			System.out.print(root.data+"\t");
			
			//3.遍历右子树
			this.inOrderTraverse(root.rightChild);
		}
	}
	
	//后序遍历
	public void postOrderTraverse() {
		System.out.println();
		System.out.println("后序遍历");
		this.postOrderTraverse(root);
	}

	@Override
	public void postOrderTraverse(Note root) {
		if(root!=null) {
		//先遍历左子树
		this.postOrderTraverse(root.leftChild);
		//遍历右子树
		this.postOrderTraverse(root.rightChild);
		//输出根的值
		System.out.print(root.data+"\t");
		}
	}

	//非递归中旭遍历
	public void inOrderByStack() {
		System.out.println("中序非递归遍历:");
		// 创建栈
		Deque<Note> stack = new LinkedList<Note>();
		Note current = root;
		while (current != null || !stack.isEmpty()) {
			while (current != null) {
				stack.push(current);
				current = current.leftChild;
			}

			if (!stack.isEmpty()) {
				current = stack.pop();
				System.out.print(current.data + " ");
				current = current.rightChild;
			}
		}
		System.out.println();	
	}

	
	public void preOrderByStack() {
		
		
	}

	@Override
	public void postOrderByStack() {
		// TODO Auto-generated method stub
		
	}
	//按照层次遍历二叉树
	public void levelOrderByQueue() {
		if(root == null) return;
		Queue<Note> queue = new LinkedList<Note>();
		queue.add(root);
		while(queue.size() != 0) {
			int len = queue.size();
			for (int i = 0; i < len; i++) {
				Note temp = queue.poll();
				System.out.print(temp.data+"\t");
				if(temp.leftChild!=null) queue.add(temp.leftChild);
				if(temp.rightChild!=null) queue.add(temp.rightChild);
			}
			System.out.println();
		}
	}
}

测试类

package thread_study02_thread02;

public class Test {
	public static void main(String[] args) {
		//创建一个二叉树
		Note note5= new Note(5, null, null);
		Note note4= new Note(4, null, note5);
		Note note7= new Note(7, null, null);
		Note note6= new Note(6, null, note7);
		Note note3= new Note(3, null, null);	
		Note note2= new Note(2, note3, note6);
		Note note1= new Note(1, note4, note2);
		
		//判断二叉树是否为空
		BinaryTree btree = new BinaryTreeImpl(note1);
		System.out.println(btree.isEmpty());
		
		//先序遍历递归
		btree.preOrderTraverse();
		//中序遍历递归
		btree.inOrderTraverse();
		//后序遍历递归
		btree.postOrderTraverse();
		//二叉树的高度
		System.out.println(btree.getHight());
		//二叉树的节点数量
		System.out.println(btree.size());
		//非递归中序遍历
		btree.inOrderByStack();
		//层次遍历
		btree.levelOrderByQueue();
		
	}
}

输出结果

true
1	4	5	2	3	6	7	
中序遍历
4	5	1	3	2	6	7	
后序遍历
5	4	3	7	6	2	1	
二叉树的高度
4
二叉树的节点数量
7
中序非递归遍历:
4 5 1 3 2 6 7 
按照层次遍历二叉树
1	
4	2	
5	3	6	
7