java实现二叉树的创建及遍历

            java实现二叉树的创建及遍历

巩固一下二叉树基础知识

package Tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

/**
 * 
 * @author don
 *
 */
public class BinaryTree {
    private int[] array={1,2,3,4,5,6,7,8,9};
    private static List<Integer> resList=new ArrayList<Integer>();
    /**
     * 定义树节点
     * @author don
     *
     */
    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);
        }
        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();
        bt.levelTraverse(root);
    }
}