二叉树常见题目-1

1.二叉树结构定义

节点类

//二叉树节点类
    class TreeNode{
        char value;
        TreeNode left;
        TreeNode right;

        public TreeNode(char value){
            //引用类型不需要初始化
            this.value=value;
        }
    }

1.二叉树前序遍历

二叉树的前序就是先遍历根节点，再遍历左子树最后才是右子树。遍历分为递归和非递归方式
递归方式

/**
    * @name: binaryTreePrevOrder
    * @description: 前序遍历
    * @param root
    * @return: void
    *
   */
   public void binaryTreePrevOrder(TreeNode root){
        //递归终止条件
        if(root==null)
            return;

        System.out.print(root.value+" ");
        binaryTreePrevOrder(root.left);
        binaryTreePrevOrder(root.right);

    }

非递归方式：非递归遍历就得用到栈进行节点的存储。

/**
     * @name: binaryTreePrevOrderNonR
     * @description: 二叉树前序遍历非递归
     * @param root
     * @return: void
     *
    */
    void binaryTreePrevOrderNonR(TreeNode root){
       if(root==null)
           return;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode cur=root;
        TreeNode top=root;

        //此时的cur已经走top.right需要重新判断，而加的!stack.empty()是为了在cur为null时重新获取栈顶元素
        while(cur!=null||!stack.empty()){
            //先遍历根的左子树
            while(cur!=null){
                stack.push(cur);
                System.out.print(cur.value+" ");
                cur=cur.left;
            }
            top=stack.pop();
            cur=top.right;
        }
    }

2.中序遍历

中序遍历是按照着：左子树、根节点、右子树的顺序进行遍历的。
递归方式

/**
     * @name: binaryTreeInOrder
     * @description: 中序遍历
     * @param root
     * @return: void
     *
     */
    public void binaryTreeInOrder(TreeNode root){
        //递归终止条件
        if(root==null)
            return;

        binaryTreeInOrder(root.left);
        System.out.print(root.value+" ");
        binaryTreeInOrder(root.right);
    }

非递归方式

/**
     * @name: binaryTreeInorderNonR
     * @description: 中序遍历非递归
     * @param root
     * @return: void
     *
    */
    void binaryTreeInorderNonR(TreeNode root){
       Stack<TreeNode> stack=new Stack<TreeNode>();
       TreeNode cur=root;
       TreeNode top=null;

       while(cur!=null || !stack.empty()) {

           while (cur != null) {
               stack.push(cur);
               cur=cur.left;
           }
           top = stack.pop();
           System.out.print(top.value+" ");
           cur = top.right;
       }
    }

3.后序遍历

后序遍历的顺序按照：左子树、右子树、根节点。
递归方式

/**
     * @name: binaryTreePostOrder
     * @description: 后序遍历
     * @param root
     * @return: void
     *
     */
    public void binaryTreePostOrder(TreeNode root){
        //递归终止条件
        if(root==null)
            return;

        binaryTreePostOrder(root.left);
        binaryTreePostOrder(root.right);
        System.out.print(root.value+" ");
    }

非递归方式：后序遍历的非递归方式的是最有难度的一个操作，在经过根节点是时候是否打印根节点的数据我们必须得判断右子树是否已经被打印过。

/**
     * @name: binaryTreePostOrderNonR
     * @description: 后序遍历非递归
     * @param root
     * @return: void
     *
    */
    void binaryTreePostOrderNonR(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode cur=root;
        TreeNode prev=null;

        while(cur!=null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }

            //此时根节点不能出栈
            cur=stack.peek();
            //cur.right==prev说明右子树已经被打印过,prev记录的是是否已经被打印过
            if(cur.right==null||cur.right==prev) {
                stack.pop();
                System.out.print(cur.value+" ");
                //右子树不为空，则应将右子树入栈
                prev=cur;
                //防止cur重复入栈
                cur=null;
            } else{
                cur=cur.right;
            }
        }
    }