java二叉树的遍历方式详解

 public List<Integer> preorderTraversal(Treenode root) {
       List <Integer>  list=new ArrayList<>();
       pre(root,list);
       return list;
    }
    public void pre(TreeNode root,List list){
        if(root==null){
            return ;
        }
        list.add(root.val);
        pre(root.left,list);
        pre(root.right,list);
    }

 public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<>();
        if(root==null) return list;
        Stack<TreeNode>  stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            list.add(node.val);
           if(node.right!=null) stack.push(node.right);
            if(node.left!=null) stack.push(node.left);
        }
        return list;
    }

 public List<Integer> inorderTraversal(TreeNode root) {
         List <Integer> list=new ArrayList<>();
         inorder(root,list);
         return list;
    }
    public void inorder(TreeNode root,List list){
        if(root==null){
            return ;
        }
        inorder(root.left,list);
        list.add(root.val);
        inorder(root.right,list);
    }

 public List<Integer> inorderTraversal(TreeNode root) {
        //迭代实现 
        List<Integer> list =new LinkedList<>();
        Stack <TreeNode> stack=new Stack<>();
        TreeNode cur=root;
        while(cur!=null||!stack.isEmpty()){
            //先找到左节点
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            TreeNode node=stack.pop();
            list.add(node.val);
            if(node.right!=null){
              cur=node.right;
            }
        }
        return list;
    }

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list=new ArrayList<>();
            postorder(root,list);
            return list;
    }
    public void postorder(TreeNode root,List list){
        if(root==null){
            return ;
        }
        postorder(root.left,list);
        postorder(root.right,list);
        list.add(root.val);
    }

 public List<Integer> postorderTraversal(TreeNode root) {
        //利用双栈实现后序遍历
        Stack <TreeNode> s1=new Stack<>();
        Stack <TreeNode> s2=new Stack<>();
        List<Integer> list=new LinkedList<>();
          if(root==null) return list;
        s1.push(root);
        while(!s1.isEmpty()){
            TreeNode node=s1.pop();
            s2.push(node);
            if(node.left!=null) s1.push(node.left);
            if(node.right!=null) s1.push(node.right);
        }
        while(!s2.isEmpty()){
            TreeNode cur=s2.pop();
            list.add(cur.val);
        }
        return list;
    }

public List<List<Integer>> levelOrder(TreeNode root) {
        //用队列实现层序遍历
        //第一层节点先进队列，出的节点带下一层的节点
        List <List<Integer>> list=new ArrayList<>();
         if(root==null) return list;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list1=new ArrayList<>();
            int size=queue.size();
            while(size!=0){
                TreeNode cur=queue.poll();
                list1.add(cur.val);
                if(cur.left!=null){
                    queue.offer(cur.left);
                }
                if(cur.right!=null){
                    queue.offer(cur.right);
                }
                size--;
            }
            list.add(list1);
        }
        return list;
    }