二叉树遍历-JAVA实现
二叉树遍历分为前序、中序、后序递归和非递归遍历、还有层序遍历。
package tree;
public class BinaryTreeNode {
private int data;
private BinaryTreeNode left;
private BinaryTreeNode right;
public BinaryTreeNode() {
}
public BinaryTreeNode(int data) {
super();
this.data = data;
this.left = null;
this.right = null;
}
public BinaryTreeNode(int data, BinaryTreeNode left, BinaryTreeNode right) {
super();
this.data = data;
this.left = left;
this.right = right;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryTreeNode getLeft() {
return left;
}
public void setLeft(BinaryTreeNode left) {
this.left = left;
}
public BinaryTreeNode getRight() {
return right;
}
public void setRight(BinaryTreeNode right) {
this.right = right;
}
public void insert(BinaryTreeNode root,int data){
if(data>root.data){ //如果插入的节点大于跟节点
if(root.right==null){ //如果右子树为空，就插入，如果不为空就再创建一个节点
root.right=new BinaryTreeNode(data); //就把插入的节点放在右边
}else{
this.insert(root.right, data);
}
}else{ //如果插入的节点小于根节点
if(root.left==null){ //如果左子树为空，就插入，如果不为空就再创建一个节点
root.left=new BinaryTreeNode(data); //就把插入的节点放在左边边
}else{
this.insert(root.left, data);
}
}
}
}前序递归遍历算法：访问根结点-->递归遍历根结点的左子树-->递归遍历根结点的右子树
中序递归遍历算法：递归遍历根结点的左子树-->访问根结点-->递归遍历根结点的右子树
后序递归遍历算法：递归遍历根结点的左子树-->递归遍历根结点的右子树-->访问根结点
package tree;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class QueryTree {
//前序遍历递归的方式
public void preOrder(BinaryTreeNode root){
if(null!=root){
System.out.print(root.getData()+"\t");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}
//前序遍历非递归的方式
public void preOrderNonRecursive(BinaryTreeNode root){
Stack<BinaryTreeNode> stack=new Stack<BinaryTreeNode>();
while(true){
while(root!=null){
System.out.print(root.getData()+"\t");
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty()) break;
root=stack.pop();
root=root.getRight();
}
}
//中序遍历采用递归的方式
public void inOrder(BinaryTreeNode root){
if(null!=root){
inOrder(root.getLeft());
System.out.print(root.getData()+"\t");
inOrder(root.getRight());
}
}
//中序遍历采用非递归的方式
public void inOrderNonRecursive(BinaryTreeNode root){
Stack<BinaryTreeNode> stack=new Stack<BinaryTreeNode>();
while(true){
while(root!=null){
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty())break;
root=stack.pop();
System.out.print(root.getData()+"\t");
root=root.getRight();
}
}
//后序遍历采用递归的方式
public void postOrder(BinaryTreeNode root){
if(root!=null){
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getData()+"\t");
}
}
//后序遍历采用非递归的方式
public void postOrderNonRecursive(BinaryTreeNode root){
Stack<BinaryTreeNode> stack=new Stack<BinaryTreeNode>();
while(true){
if(root!=null){
stack.push(root);
root=root.getLeft();
}else{
if(stack.isEmpty()) return;
if(null==stack.lastElement().getRight()){
root=stack.pop();
System.out.print(root.getData()+"\t");
while(root==stack.lastElement().getRight()){
System.out.print(stack.lastElement().getData()+"\t");
root=stack.pop();
if(stack.isEmpty()){
break;
}
}
}
if(!stack.isEmpty())
root=stack.lastElement().getRight();
else
root=null;
}
}
}
//层序遍历
public void levelOrder(BinaryTreeNode root){
BinaryTreeNode temp;
Queue<BinaryTreeNode> queue=new LinkedList<BinaryTreeNode>();
queue.offer(root);
while(!queue.isEmpty()){
temp=queue.poll();
System.out.print(temp.getData()+"\t");
if(null!=temp.getLeft())
queue.offer(temp.getLeft());
if(null!=temp.getRight()){
queue.offer(temp.getRight());
}
}
}
public static void main(String[] args) {
int[] array = {35,17,39,9,28,65,56,87};
BinaryTreeNode root = new BinaryTreeNode(array[0]); //创建二叉树
for(int i=1;i<array.length;i++){
root.insert(root, array[i]); //向二叉树中插入数据
}
QueryTree tree=new QueryTree();
//采用递归的方式进行遍历
System.out.println("-----前序遍历------");
tree.preOrder(root);
System.out.println();
//采用非递归的方式遍历
tree.preOrderNonRecursive(root);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----中序遍历------");
tree.inOrder(root);
System.out.println();
//采用非递归的方式遍历
tree.inOrderNonRecursive(root);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----后序遍历------");
tree.postOrder(root);
System.out.println();
//采用非递归的方式遍历
tree.postOrderNonRecursive(root);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----层序遍历------");
tree.levelOrder(root);
System.out.println();
}} 运行结果：
-----前序遍历------
35 17 9 28 39 65 56 87
35 17 9 28 39 65 56 87
-----中序遍历------
9 17 28 35 39 56 65 87
9 17 28 35 39 56 65 87
-----后序遍历------
9 28 17 56 87 65 39 35
9 28 17 56 87 65 39 35
-----层序遍历------
35 17 39 9 28 65 56 87