遍历二叉树中的数据(深度优先[先序,中序,后续])(广度优先:借助队列的特点)

package com.bjsxt.demo.binarytree;

/**

• 二叉树
• @author SupperMan

*/
public class BinaryTree {
private TreeNode root;

// 向书中添加数据的方法
public void addDate(int value) {
	// 先将传入数据分装为节点对象
	TreeNode tNode = new TreeNode(value);
	// 判断树是否为空
	if (this.root == null) {
		this.root = tNode;
	} else {
		// 树不为空的情况
		// 创建一个零食节点
		TreeNode tTemp = new TreeNode();
		tTemp = this.root;
		// 判断将这个节点放在左子树还是右子树
		while (true) {
			if (value < tTemp.getData()) {
				// 左子树
				if (tTemp.getLeft() == null) {
					// 找到要插入的位置
					tTemp.setLeft(tNode);
					break;
				} else {
					tTemp = tTemp.getLeft();
				}
			} else {
				// 右子树
				if (tTemp.getRight() == null) {
					tTemp.setRight(tNode);
					break;
				} else {
					tTemp = tTemp.getRight();
				}
			}
		}
	}
}

// 先序,中序,后序的三种遍历方法
// 先序
public void firstOrder() {
	// 如果树为空
	if (this.root == null) {
		System.out.println("树中数据为空:");
		return;
	} else {
		System.out.println("先序遍历树中的元素为:");
		firstOrder(this.root);
	}
}

// 中序
public void middleOrder() {
	// 如果树为空
	if (this.root == null) {
		System.out.println("树中没有数据:");
		return;
	} else {
		System.out.println("中序遍历树中的元素为:");
		middleOrder(this.root);
	}
}
//后序
public void lastOrder() {
	if(this.root==null) {
		System.out.println("树中没有数据");
	}else {
		System.out.println("后序输出树中的数据");
		lastOrder(this.root);
	}
}

private void lastOrder(TreeNode tNode) {
	// 左子树
	if (tNode.getLeft() != null) {
		middleOrder(tNode.getLeft());
	}
	//右子树
	if (tNode.getRight() != null) {
		middleOrder(tNode.getRight());
	}	
	//根
	System.out.print(tNode.getData()+"\t");
}

//广度优先遍历:借助队列,先入先出,按层级分
public void levelTraversal() {
	if(this.root==null) {
		System.out.println("树中没有数据!");
	}else {
		System.out.println("广度优先遍历树中数据");
		//创建队列
		
		Queue q=new Queue();
		q.add(this.root);
		TreeNode tTemp;
		while(!q.isEmpty()) {
			//出队
			tTemp=q.dequeue();
			//打印
			System.out.print(tTemp.getData()+"\t");
			//左子树入队
			if(tTemp.getLeft()!=null) {
				q.add(tTemp.getLeft());
			}
			//右子树入队
			if(tTemp.getRight()!=null) {
				q.add(tTemp.getRight());
			}
		}
	}
}

private void middleOrder(TreeNode tNode) {
	// 左子树
	if (tNode.getLeft() != null) {
		middleOrder(tNode.getLeft());
	}
	// 根
	System.out.print(tNode.getData()+"\t");

	// 右子树
	if (tNode.getRight() != null) {
		middleOrder(tNode.getRight());
	}
}

/**
 * 先序(递归思想)
 * 
 * @param tNode
 */
private void firstOrder(TreeNode tNode) {
	// 先根
	System.out.print(tNode.getData()+"\t");
	// 左子树
	if (tNode.getLeft() != null) {
		firstOrder(tNode.getLeft());
	}
	// 右子树
	if (tNode.getRight() != null) {
		firstOrder(tNode.getRight());
	}
}

/**
 * 二叉树的节点,应该具有的属性有:数据节点,左分支,右分支
 * 
 * @author SupperMan:向阳的小白
 *
 */

}
class TreeNode {
private int data;
private TreeNode left;
private TreeNode right;

public TreeNode() {
}

public TreeNode(int data) {
	super();
	this.data = data;
}

public int getData() {
	return data;
}

public void setData(int data) {
	this.data = data;
}

public TreeNode getLeft() {
	return left;
}

public void setLeft(TreeNode left) {
	this.left = left;
}

public TreeNode getRight() {
	return right;
}

public void setRight(TreeNode right) {
	this.right = right;
}

}
//队列
class Queue{
//属性 head
private QueueNode head;

public QueueNode getHead() {
	return head;
}

public void setHead(QueueNode head) {
	this.head = head;
}
//入队
public void add(TreeNode tNode) {
	//将数据封装为节点对象
	QueueNode qNode=new QueueNode(tNode);
	//判断队列是否为空
	if(this.head==null) {
		this.head=qNode;
	}else {
		QueueNode qTemp=new QueueNode();
		qTemp=this.head;
		while(qTemp.getNext()!=null) {
			qTemp=qTemp.getNext();
		}
		//找到入队位置
		qTemp.setNext(qNode);
	}
}
//出队方法
public TreeNode dequeue() {
	if(this.head==null) {
		System.out.println("队中没有数据");
		return null;
	}else {
		QueueNode qTemp=this.head;
		TreeNode tNode=qTemp.getData();
		this.head=this.head.getNext();
		return tNode;
	}
}
//判断队空
public boolean isEmpty() {
	return this.head==null;
}

}
/**

• 队节点
• @author SupperMan

*/
class QueueNode{
private TreeNode data;
private QueueNode next;
public QueueNode() {
}
public QueueNode(TreeNode data) {
super();
this.data = data;
}
public TreeNode getData() {
return data;
}
public void setData(TreeNode data) {
this.data = data;
}
public QueueNode getNext() {
return next;
}
public void setNext(QueueNode next) {
this.next = next;
}

}
//测试类
package com.bjsxt.demo.binarytree;

public class BinaryTreeTest {
public static void main(String[] args) {
BinaryTree tree=new BinaryTree();
int[] array = { 23, 1, 34, -9, -45, 30, 7, 3, 11, 8, 22, 9, 50, 15, 6, -7, 44, 99 };
for (int i : array) {
tree.addDate(i);
}
tree.middleOrder();
System.out.println();
tree.firstOrder();
System.out.println();
tree.lastOrder();
System.out.println();
tree.levelTraversal();
}
}
//运行结果
中序遍历树中的元素为:
-45 -9 -7 1 3 6 7 8 9 11 15 22 23 30 34 44 50 99
先序遍历树中的元素为:
23 1 -9 -45 -7 7 3 6 11 8 9 22 15 34 30 50 44 99
后序输出树中的数据
-45 -9 -7 1 3 6 7 8 9 11 15 22 30 34 44 50 99 23
广度优先遍历树中数据
23 1 34 -9 7 30 50 -45 -7 3 11 44 99 6 8 22 9 15