【数据结构学习】二叉树遍历的代码实现

二叉链表结点

首先对二叉链表的结点进行定义：

public class Node {

	Object value;   //结点值
	Node leftChild; //左子树的引用
	Node rightChild;//右子树的引用
	
	//构造方法
	public Node(Object value, Node leftChild, Node rightChild) {
		super();
		this.value = value;
		this.leftChild = leftChild;
		this.rightChild = rightChild;
	}

	public Node(Object value) { 
		super();
		this.value = value;
	}
	
	@Override
	public String toString() {
		return "Node [value=" + value + ", leftChild=" + leftChild + ", rightChild=" + rightChild + "]";
	}
}

接口

然后定义二叉树的接口，该接口可以有不同的实现类，每个类可以使用不同的存储结构，比如顺序结构或者链式结构。

public interface BinaryInterface {
	//是否是空树
	public boolean isEmpty();
	
	//树的结点的个数
	public int size();
	
	//获取输的高度
	public int getheight();
	
	//查询指定值的结点
	public Node findKey(int value);
	
	//前序遍历二叉树
	public void preOrderTraverse();	
	
	//中序遍历二叉树
	public void midOrderTraverse();
	
	//后序遍历二叉树
	public void postOrderTraverse();	
	
	//求二叉树中叶子结点的个数
	public void inOrderByStack();
	
	//中序遍历非递归
	public void preOrderByStack();
	
	//后序遍历非递归
	public void postOrderByStack();
	
	//按照层次遍历二叉树
	public void levelOrderByStack();
}

测试类

分别需要实现以下功能：

• 创建一个二叉树
• 判断二叉树是否为空
• 先序遍历递归
• 中序遍历递归
• 后序遍历递归
• 二叉树的高度
• 二叉树的结点数量

创建下面的二叉树，并对其进行遍历。

public class BinaryTest {

	public static void main(String[] args) {
		// 创建一个二叉树
		//创建顺序：从左往右，从下往上
		Node node5 = new Node(5,null,null); 
		Node node4 = new Node(4,null,node5);
		
		Node node7 = new Node(7,null,null);
		Node node6 = new Node(6,null,node7);
		Node node3 = new Node(3,null,null);
		Node node2 = new Node(2,node3,node6);
		
		Node node1 = new Node(1,node4,node2);
		
		BinaryInterface btree = new LinkBinaryTree(node1);
		
		//判断二叉树是否为空
		System.out.println(btree.isEmpty());
		
		//先序遍历递归
		System.out.println("先序遍历结果："); 
		btree.preOrderTraverse();
		System.out.println(); 
		
		//中序遍历递归
		btree.midOrderTraverse();
		System.out.println(); 
		
		//后序遍历递归
		btree.postOrderTraverse();
		
		//二叉树的高度
		System.out.println(btree.getheight());

		//二叉树的结点数量
		System.out.println(btree.size());
	}

}

接口的实现类

/**
 * 接口的实现类
 * @author liwenlong
 *
 */
public class LinkBinaryTree implements BinaryInterface{

	
	private Node root;//根结点
	
	public LinkBinaryTree(Node root) {  //带参数构造方法
		super();
		this.root = root;
	}

	public LinkBinaryTree() {   //无参构造方法
		super();
	}

	@Override
	public boolean isEmpty() {
		if(root == null) {
			return true;
		}
		else
			return false;
	}

	@Override
	public int size() {
		System.out.println("二叉树结点个数：");
		return this.getsize(root);
	}
	private int getsize(Node root) {
		if (root != null) {
			//1.获取左子树大小
			int m = this.getsize(root.leftChild);
			//2.获取右子树高度
			int n = this.getsize(root.rightChild);
			//3.取较大值加1
			return m+n+1;
		}else
		{
			return 0;
		}
	}

	@Override
	public int getheight() {
		System.out.println("二叉树的高度是：");
		return this.getheight(root);
	}
	
	private int getheight(Node root) {
		if (root != null) {
			//1.获取左子树高度
			int m = this.getheight(root.leftChild);
			//2.获取右子树高度
			int n = this.getheight(root.rightChild);
			//3.取较大值加1
			return m > n ? m+1:n+1;
		}else
		{
			return 0;
		}
	}
	
	@Override
	public void preOrderTraverse() {
		
		if(root != null) {
			//1.输出根节点的值
			System.out.print(root.value+" ");
			
			//2.对左子树进行先序遍历
			//构建一个二叉树，根是左子树的根 
			BinaryInterface leftTree = new LinkBinaryTree(root.leftChild);
			leftTree.preOrderTraverse();
			
			//3.对右子树进行先序遍历
			//构建一个子树，根是右子树的根 
			BinaryInterface rightTree = new LinkBinaryTree(root.rightChild);
			rightTree.preOrderTraverse();
			
		}

	}

	@Override
	public void midOrderTraverse() {
		System.out.println("中序遍历结果：");
		this.midOrderTraverse(root);
	}
	
	private void midOrderTraverse(Node root) {
		if(root !=null ) {
			//1.遍历左子树
			this.midOrderTraverse(root.leftChild);
			//2.输出根的值
			System.out.print(root.value+" ");
			//3.遍历右子树
			this.midOrderTraverse(root.rightChild);
		}
	}

	@Override
	public void postOrderTraverse() {
		System.out.println("后序遍历结果：");
		this.postOrderTraverse(root);
		System.out.println();
	}
	
	 private void postOrderTraverse(Node root) {
		if(root != null) {
			//1.遍历左子树
			this.postOrderTraverse(root.leftChild);
			//2.遍历右子树
			this.postOrderTraverse(root.rightChild);
			//3.输出根的值
			System.out.print(root.value+" ");
		}
	}

}