遍历方式:前序遍历、中序遍历、后序遍历和层次遍历
(递归、非递归)
代码:(递归方式)
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class BinaryTree {
public static class TreeNode{
String element;
TreeNode left;
TreeNode right;
public TreeNode(String val){
element=val;
left=null;
right=null;
}
}
//创建二叉树,按照前序遍历方式输入
public static TreeNode createBinaryTree(){
Scanner sc=new Scanner(System.in);
String element=sc.nextLine();
if(!"null".equals(element)){
TreeNode node=new TreeNode(element);
node.left=createBinaryTree();
node.right=createBinaryTree();
return node;
}else{
return null;
}
}
//前序遍历
public static void preOrderTraverse(TreeNode root){
if(root!=null){
System.out.print(root.element+" ");
preOrderTraverse(root.left);
preOrderTraverse(root.right);
}
}
//中序遍历
public static void inOrderTraverse(TreeNode root){
if(root!=null){
inOrderTraverse(root.left);
System.out.print(root.element+" ");
inOrderTraverse(root.right);
}
}
//后序遍历
public static void postOrderTraverse(TreeNode root){
if(root!=null){
postOrderTraverse(root.left);
postOrderTraverse(root.right);
System.out.print(root.element+" ");
}
}
private static Queue
queue=new LinkedList
();
//层次遍历
public static void levelTraverse(TreeNode root){
System.out.print(root.element+" ");
if(root.left!=null){
queue.offer(root.left);
}
if(root.right!=null){
queue.offer(root.right);
}
TreeNode node=queue.poll();
if(node!=null){
levelTraverse(node);
}
}
}
输入:
A
B
null
D
null
null
C
E
null
null
null
B
null
D
null
null
C
E
null
null
null
输出:
A B D C E
B D A E C
D B E C A
A B C D E
B D A E C
D B E C A
A B C D E
思路:(非递归方式)
前序遍历思路:从栈中弹出栈顶节点,访问输出该节点,如果当前节点有右孩子,则压入栈,如果有左孩子,继续压入栈,只要栈不为空,不断循环迭代
中序遍历思路:如果当前节点有左孩子,则将其左孩子输入,并将节点指向其左孩子,否则将当前节点出栈并输出,如果其有右孩子,则将右孩子入栈,并将当前节点指向右孩子,只要栈不为空,不断循环迭代
后序遍历思路:弹出栈顶节点,如果节点没有左孩子和右孩子,输出该节点,还有一种是该节点的前一输出节点不为空且是其左孩子或右孩子,同样输出该节点,否则的话,将该节点压回栈中,如果该节点有右孩子,压入栈,有左孩子,压入栈,只要栈不为空,不断循环迭代
层次遍历思路:使用一个队列记录要访问下一层的节点,从队列中输出当前节点,如果当前节点有左孩子,加入队列,有右孩子,加入队列,只要队列不为空,不断循环迭代
代码:
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class BinaryTree {
public static class TreeNode{
String element;
TreeNode left;
TreeNode right;
public TreeNode(String val){
element=val;
left=null;
right=null;
}
}
public static TreeNode createBinaryTree(){
Scanner sc=new Scanner(System.in);
String element=sc.nextLine();
if(!"null".equals(element)){
TreeNode node=new TreeNode(element);
node.left=createBinaryTree();
node.right=createBinaryTree();
return node;
}else{
return null;
}
}
public static void preOrderTraverse(TreeNode root){
Stack
stack=new Stack<>();
if(root!=null){
stack.push(root);
}
while(!stack.isEmpty()){
root=stack.pop();
System.out.print(root.element+" ");
if(root.right!=null){
stack.push(root.right);
}
if(root.left!=null){
stack.push(root.left);
}
}
}
public static void inOrderTraverse(TreeNode root){
Stack
stack=new Stack<>();
if(root!=null){
stack.push(root);
}
while(!stack.isEmpty()){
if(root.left!=null){
stack.push(root.left);
root=root.left;
}else{
root=stack.pop();
System.out.print(root.element+" ");
if(root.right!=null){
stack.push(root.right);
root=root.right;
}
}
}
}
public static void postOrderTraverse(TreeNode root){
Stack
stack=new Stack<>();
if(root!=null){
stack.push(root);
}
TreeNode preNode=null;
while(!stack.isEmpty()){
root=stack.pop();
if((root.left==null&&root.right==null)||
(preNode!=null&&(preNode==root.left||preNode==root.right))){
System.out.print(root.element+" ");
preNode=root;
}else{
stack.push(root);
if(root.right!=null){
stack.push(root.right);
}
if(root.left!=null){
stack.push(root.left);
}
}
}
}
public static void levelTraverse(TreeNode root){
Queue
queue=new LinkedList<>();
if(root!=null){
queue.offer(root);
}
TreeNode current=null;
while(!queue.isEmpty()){
current=queue.poll();
System.out.print(current.element+" ");
if(current.left!=null){
queue.offer(current.left);
}
if(current.right!=null){
queue.offer(current.right);
}
}
}
}
输入:
A
B
null
D
null
null
C
E
null
null
null
B
null
D
null
null
C
E
null
null
null
输出:
A B D C E
B D A E C
D B E C A
A B C D E
B D A E C
D B E C A
A B C D E