这几者的关系:前序中序后序遍历是深度优先的三个实例,
层序遍历就是广度优先
import java.util.ArrayDeque;
import java.util.LinkedList;
import java.util.Stack;
public class BinaryTreeCopy {
static class TreeNode{
int value;
TreeNode left;
TreeNode right;
public TreeNode(int value){
this.value=value;
}
}
TreeNode root;
public BinaryTreeCopy(int[] array){
root=makeBinaryTreeByArray(array,1);
}
/**
* 采用递归的方式创建一颗二叉树
* 传入的是二叉树的数组表示法
* 构造后是二叉树的二叉链表表示法
*/
public static TreeNode makeBinaryTreeByArray(int[] array,int index){
if(index<array.length){
int value=array[index];
if(value!=0){
TreeNode t=new TreeNode(value);
array[index]=0;
t.left=makeBinaryTreeByArray(array,index*2);
t.right=makeBinaryTreeByArray(array,index*2+1);
return t;
}
}
return null;
}
/**
* 先序遍历
* 采用非递归实现
* 需要辅助数据结构:栈
*/
public void preOrderTraversal(){
Stack<TreeNode> stack = new Stack<>();
TreeNode pNode = root;
while(pNode != null || !stack.isEmpty()){
if(pNode != null){
System.out.print(pNode.value + " ");
stack.push(pNode);
pNode = pNode.left;
}else{
pNode = stack.pop();
pNode = pNode.right;
}
}
System.out.print("\n");
}
/**
* 中序遍历
* 采用非递归实现
* 需要辅助数据结构:栈
*/
public void inOrderTraversal(){
Stack<TreeNode> stack = new Stack<>();
TreeNode pNode = root;
while(pNode != null || !stack.isEmpty()){
if(pNode != null){
stack.push(pNode);
pNode = pNode.left;
}else{
pNode = stack.pop();
System.out.print(pNode.value + " ");
pNode = pNode.right;
}
}
System.out.print("\n");
}
/**
* 后序遍历
* 采用非递归实现
* 需要辅助数据结构:栈
*/
public void postOrderTraversal(){
Stack<TreeNode> stack =new Stack<>();
Stack<TreeNode> ostack =new Stack<>();
TreeNode pNode = root;
while(pNode != null || !stack.isEmpty()){
if(pNode != null){
ostack.push(pNode);
stack.push(pNode);
pNode = pNode.right;
}else{
pNode = stack.pop();
pNode = pNode.left;
}
}
while(ostack.size()>0){
System.out.print(ostack.pop().value + " ");
}
System.out.print("\n");
}
/**
* 深度优先遍历,相当于先根遍历
* 采用非递归实现
* 需要辅助数据结构:栈
*/
public void depthOrderTraversal(){
if(root == null){
return;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode pNode = stack.pop();
System.out.print(pNode.value+" ");
if(pNode.right != null){
stack.push(pNode.right);
}
if(pNode.left != null){
stack.push(pNode.left);
}
}
System.out.print("\n");
}
/**
* 13
* / \
* 65 5
* / \ \
* 97 25 37
* / /\ /
* 22 4 28 32
*/
/**
* 广度优先遍历
* 采用非递归实现
* 需要辅助数据结构:队列
*/
public void levelOrderTraversal(){
if(root == null){
return;
}
LinkedList<TreeNode> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode pNode = queue.remove();
System.out.print(pNode.value+" ");
if(pNode.left != null){
queue.add(pNode.left);
}
if(pNode.right !=null){
queue.add(pNode.right);
}
}
System.out.print("\n");
}
/**
* 13
* / \
* 65 5
* / \ \
* 97 25 37
* / /\ /
* 22 4 28 32
*/
public static void main(String[] args) {
int[] arr={0,13,65,5,97,25,0,37,22,0,4,28,0,0,32,0};
BinaryTreeCopy tree=new BinaryTreeCopy(arr);
tree.depthOrderTraversal();
tree.levelOrderTraversal();
tree.preOrderTraversal();
tree.inOrderTraversal();
tree.postOrderTraversal();
}
}