非递归遍历二叉树

先序遍历：

/*
*                    A
*                /       \    *            B               C
*            / \           /   \    *           D    E        F    G
*         /   \       \    /
*          H I      J   P
*
*
*
*
*/
//先序遍历DLR(ABDEHI CFJGP)

public ArrayList<Node> preorderTraversal(Node node){//非递归先序遍历
        ArrayList<Node> list=new ArrayList<>();
        Stack<Node> stack=new Stack<>();
        while(!stack.isEmpty()||node!=null){
            while(node!=null){
                list.add(node);
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            node=node.right;
        }return list;
    }

中序遍历：

/*
*                    A
*                /       \    *            B               C
*            / \           /   \    *           D    E        F    G
*         /   \       \    /
*          H I      J   P
*
*
*
*
*/
//中序遍历二叉树LDR,所有的节点都是LDR (DBHEIA FJCPG)

public ArrayList<Node> inorderTraversal(Node node){//非递归中序遍历
        ArrayList<Node> list=new ArrayList<>();
        Stack<Node> stack=new Stack<>();
        while(!stack.isEmpty()||node!=null){
            while(node!=null){
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            list.add(node);
            node=node.right;
        }return list;

    }

后序遍历：

先按中右左遍历，再反转为左右中；

/*
*                    A
*                /       \    *            B               C
*            / \           /   \    *           D    E        F    G
*         /   \       \    /
*          H I      J   P
*
*
*
*
*/

//后序遍历二叉树LRD(DHIEB JFPGCA)

public ArrayList<Node> postorderTraversal(Node node){//非递归后序遍历
        ArrayList<Node> list=new ArrayList<>();
        Stack<Node> stack=new Stack<>();
        while (!stack.isEmpty()||node!=null){
            while(node!=null){
                list.add(0,node);//反转
                stack.push(node);
                node=node.right;
            }
            node=stack.pop();
            node=node.left;
        }return list;
    }

二叉树的先序、中序、后序遍历

先序、中序、后序遍历这三种遍历都是根据根节点而言的；

public ArrayList<Node> preIterator(Node node){//先序遍历
        ArrayList<Node> list=new ArrayList<>();
        list.add(node);
        if(node.left!=null){

            list.addAll(preIterator(node.left));
        }
        if(node.right!=null){

            list.addAll(preIterator(node.right));
        }return list;
    }
    public ArrayList<Node> inIterator(Node node){//中序遍历
        ArrayList<Node> list=new ArrayList<>();
        if(node.left!=null){
            list.addAll(inIterator(node.left));
        }
        list.add(node);
        if(node.right!=null){
            list.addAll(inIterator(node.right));
        }return list;
    }
    public ArrayList<Node> postIterator(Node node){//后序遍历
        ArrayList<Node> list=new ArrayList<>();
        if(node.left!=null){
            list.addAll(postIterator(node.left));
        }
        if(node.right!=null){
            list.addAll(postIterator(node.right));
        }
        list.add(node);
        return list;
    }

深度优先遍历和广度优先遍历

深度优先遍历：

将先访问到树中最深层次的节点；

public ArrayList<Node> depth(){//深度优先遍历
        if(root==null){
            throw new RuntimeException("空树！");
        }
        ArrayList<Node> list=new ArrayList<>();
        Stack<Node> stack=new Stack<>();
        stack.push(root);
        while (stack.isEmpty()==false){
            Node node=stack.pop();
            list.add(node);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }return list;
    }

广度优先遍历：

逐层访问每层的节点；

public ArrayList<Node> level(){//广度优先遍历
        ArrayList<Node> list=new ArrayList<>();
        if(root==null){
            throw new RuntimeException("空树！");
        }
        Queue<Node> queue=new ArrayDeque<>();
        queue.add(root);
        while(queue.isEmpty()==false){
            Node node=queue.remove();
            list.add(node);
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }return list;
    }

二叉树遍历