import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
public class BinaryTree {
private int[] array={1,2,3,4,5,6,7,8,9};
private static List<Integer> resList=new ArrayList<Integer>();
/**
* 定義樹節點
*/
public static class TreeNode{
int val;
TreeNode leftchild;
TreeNode rightchild;
public TreeNode(int data){
this.val=data;
}
}
/**
* 創建二叉樹
* @return
*/
public TreeNode createBinaryTree(){
TreeNode root=null;
List<TreeNode> nodelist=new ArrayList<TreeNode>();
for(int i=0;i<array.length;i++){
nodelist.add(new TreeNode(array[i]));
}
for(int j=0;j<array.length/2-1;j++){
nodelist.get(j).leftchild=nodelist.get(2*j+1);
nodelist.get(j).rightchild=nodelist.get(2*j+2);
}
//爲了防止個數是偶數的時候可能會溢出比如當array.length=10 10/2-1=4; 2*4+2=10>array.length-1
int temp=array.length/2-1;
nodelist.get(temp).leftchild=nodelist.get(2*temp+1);
nodelist.get(temp).rightchild=nodelist.get(2*temp+2);
root=nodelist.get(0);
return root;
}
/**
* 先序遍歷(遞歸)
* @param root
* @return
*/
public List<Integer> preOrderTraverse(TreeNode root){
if(root!=null){
resList.add(root.val);
System.out.print(root.val+",");
preOrderTraverse(root.leftchild);
preOrderTraverse(root.rightchild);
}
return resList;
}
/**
* 先序遍歷(非遞歸)
* @param root
* @return
*/
public List<Integer> preOrderTraverseNR(TreeNode root){
Stack<TreeNode> nodestack=new Stack<TreeNode>();
TreeNode node=root;
while(node!=null || !nodestack.isEmpty()){
while(node!=null )
{
resList.add(node.val);
System.out.print(node.val+",");
nodestack.push(node);
node=node.leftchild;
}
node=nodestack.pop();
node=node.rightchild;
}
return resList;
}
/**
* 中序遍歷(非遞歸)
* @param root
* @return
*/
public List<Integer> InOrderTraverse(TreeNode root){
if(root!=null){
InOrderTraverse(root.leftchild);
resList.add(root.val);
System.out.print(root.val+",");
InOrderTraverse(root.rightchild);
}
return resList;
}
/**
* 中序遍歷(非遞歸)
* @param root
* @return
*/
public List<Integer> InOrderTraverseNR(TreeNode root){
Stack<TreeNode> nodestack=new Stack<TreeNode>();
TreeNode node=root;
while(node!=null || !nodestack.isEmpty()){
while(node!=null){
nodestack.push(node);
node=node.leftchild;
}
node=nodestack.pop();
resList.add(node.val);
System.out.print(node.val+",");
node=node.rightchild;
}
return resList;
}
/**
* 後序遍歷(遞歸)
* @param root
* @return
*/
public List<Integer> postOrderTraverse(TreeNode root){
if(root!=null){
postOrderTraverse(root.leftchild);
postOrderTraverse(root.rightchild);
resList.add(root.val);
System.out.print(root.val+",");
}
return resList;
}
/**
* 後序遍歷(非遞歸)
* @param root
* @return
*/
public List<Integer> postOrderTraverseNR(TreeNode root){
Stack<TreeNode> nodestack=new Stack<TreeNode>();
List<TreeNode> nodelist=new ArrayList<TreeNode>();
TreeNode node=root;
while(node!=null || !nodestack.isEmpty()){
while(node!=null && !nodelist.contains(node)){
nodestack.push(node);
node=node.leftchild;
}
if(!nodestack.isEmpty()){
node=nodestack.pop();
resList.add(node.val);
nodelist.add(node);
System.out.print(node.val+",");
if(!nodestack.isEmpty())
{
node=nodestack.peek();
node=node.rightchild;
}
}
}
return resList;
}
/**
* 層序遍歷
* @param root
* @return
*/
public static List<Integer> levelTraverse(TreeNode root){
Queue<TreeNode> nodequeue=new LinkedList<TreeNode>();
if(root!=null)nodequeue.offer(root);
while(root!=null ){
if(root.leftchild!=null){
nodequeue.offer(root.leftchild);
}
if(root.rightchild!=null){
nodequeue.offer(root.rightchild);
}
TreeNode temp=nodequeue.poll();
resList.add(temp.val);
System.out.print(temp.val+",");
if(!nodequeue.isEmpty())
root=nodequeue.peek();
else
root=null;
}
return resList;
}
public static void main(String[] args){
BinaryTree bt=new BinaryTree();
TreeNode root=bt.createBinaryTree();
System.out.println("層次遍歷二叉樹:");
bt.levelTraverse(root);
System.out.println("\n遞歸先序遍歷二叉樹:");
bt.preOrderTraverse(root);
System.out.println("\n非遞歸先序遍歷二叉樹:");
bt.preOrderTraverseNR(root);
System.out.println("\n遞歸中序遍歷二叉樹:");
bt.InOrderTraverse(root);
System.out.println("\n非遞歸中序遍歷二叉樹:");
bt.InOrderTraverseNR(root);
System.out.println("\n遞歸後序遍歷二叉樹:");
bt.postOrderTraverse(root);
System.out.println("\n非遞歸後序遍歷二叉樹:");
bt.postOrderTraverseNR(root);
}
}
構建二叉樹以及實現遍歷 Java
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.