Java实现 数组转化为完全二叉树并进行前序、中序和后序遍历

数组转化成完全二叉树

/**由数组构建完全二叉树
    *一棵由数组构建的完全二叉树，下标为n的节点左右子树分别是2n+1和2n+2
    */
     public static TreeNode createBinaryTree(int[] nums,int index){
    
    
        int len=nums.length;
        TreeNode root=null;
        while(index<len){
    
    
            int val=nums[index];
            root=new TreeNode(val);
            root.left=createBinaryTree(nums,2*index+1);
            root.right=createBinaryTree(nums,2*index+2);
            return root;
        }
        return root;
    }

前序遍历

/**
     * 前序遍历 读取顺序为根-左-右
     * 递归版
     */
    public static void preorderTraverse(TreeNode root) {
    
    
        //节点不为空时继续递归
        if(root!=null){
    
    
            System.out.print(root.val+" ");
            preorderTraverse(root.left);
            preorderTraverse(root.right);
        }
    }

/**
	*非递归版本
	*/
public static void preorderTraverse1(TreeNode root){
    
    
        //使用一个栈保存节点进行回溯
        Stack<TreeNode> stack=new Stack<>();
        TreeNode node=root;
        while(node!=null||!stack.isEmpty()){
    
    
            //把所有的左子节点压入栈直至左子节点为空
            while(node!=null){
    
    
                System.out.print(node.val+" ");
                stack.push(node);
                node=node.left;
            }
            //当前节点没有右子树时，跳过上面的while循环而继续把栈顶的值赋给node
            //现在当前节点只有右子树 如果栈为空 就不用继续
            //node指向的节点已经打印 因此直接
            if(!stack.isEmpty()){
    
    
                node=stack.pop();
                node=node.right;
            }
        }
    }

中序遍历

/**
     * 中序遍历  读取顺序为左-根-右
     * 递归版
     */
    public static void inorderTraverse(TreeNode root){
    
    
        //节点不为空时继续递归
        if(root!=null){
    
    
            inorderTraverse(root.left);
            System.out.print(root.val+" ");
            inorderTraverse(root.right);
        }
    }

/**
     * 非递归版
     */
     public static void inorderTraverse1(TreeNode root){
    
    
        //使用一个栈保存节点进行回溯
        Stack<TreeNode> stack=new Stack<>();
        TreeNode node=root;
        while(node!=null||!stack.isEmpty()){
    
    
            //把所有的左子节点压入栈直至左子节点为空
            while(node!=null){
    
    
                stack.push(node);
                node=node.left;
            }
            //当前节点没有右子树时，跳过上面的while循环而继续把栈顶的值赋给node
            //现在当前节点只有右子树 如果栈为空 就不用继续
            //node指向的节点已经打印 因此直接
            if(!stack.isEmpty()){
    
    
                node=stack.pop();
                System.out.print(node.val+" ");
                node=node.right;
            }
        }
    }

后序遍历

/**
     * 后序遍历 读取顺序为左-右-根
     * 递归版
     */
    public static void postorderTraverse(TreeNode root){
    
    
        //节点不为空时继续递归
        if(root!=null){
    
    
            postorderTraverse(root.left);
            postorderTraverse(root.right);
            System.out.print(root.val+" ");
        }
    }

/**
     * 非递归版
     */
     public static void postorderTraverse1(TreeNode root) {
    
    
        //使用一个栈保存节点进行回溯
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        //由于后序遍历需要先输出左右节点再输出根节点
        //所以需要标记最后一个被访问的节点 访问根节点时，如果上一个访问的是其右子节点，再输出
        TreeNode visited=root;
        while (node != null || !stack.isEmpty()) {
    
    
            //把所有的左子节点压入栈直至左子节点为空
            while (node != null) {
    
    
                stack.push(node);
                node = node.left;
            }
            //查看当前栈顶元素
            node = stack.peek();
            //右子树为空或者右子节点已经被访问时，才输出
            if(node.right==null||node.right==visited){
    
    
                System.out.print(node.val+" ");
                stack.pop();
                visited=node;
                //把node设置为null防止重复入栈
                node=null;
            }else{
    
    
                //右子树还未访问 继续遍历右子树
                node=node.right;
            }
        }
    }

运行结果