二叉树的遍历--用递归 和栈 实现 前序、中序、后序遍历

import java.util.HashMap;import java.util.Map;import java.util.Stack;/** * 作者：用递归 和栈 实现 前序、中序、后序遍历 * 功能说明： */public class BinarayTree {    Node<String> root;    /**     * 构造器     * @param data     */    public BinarayTree(String data) {        super();        root=new Node<String>(data, null, null);    }      /**     * 栈+循环  实现 后序遍历     * @param root     * 思路 后序遍历不同于先序和中序，它是要先处理完左右子树，然后再处理根(回溯)，所以需要一个记录哪些节点已经被访问的结构(可以在树结构里面加一个标记)，这里可以用map实现     */    public void postOrderTraverse2(Node root){        if(root==null)return;        Stack<Node<String>> stack=new Stack<>();        Map<Node<String>,Boolean> map=new HashMap<Node<String>,Boolean>();        stack.push(root);        while(!stack.isEmpty()){            Node temp=stack.peek(); //peek 返回栈顶的值，但不移出栈 （pop移出栈）            if(temp.leftChild!=null && !map.containsKey(temp.leftChild)){                temp=temp.leftChild;                while(temp!=null){                    if(map.containsKey(temp)){                        break;                    } else{                        stack.push(temp);                    }                    temp=temp.leftChild;                }                continue;            }            if(temp.rightChild!=null&&!map.containsKey(temp.rightChild)){                stack.push(temp.rightChild);                continue;            }            Node t=stack.pop();            map.put(t,true);            System.out.print(" : "+t.data);        }    }    /**     * 栈+循环  实现 前序遍历     * @param root     * 思路 只要栈里面有元素 就轮循     */    public void preOrderTraverse2(Node root){        if(root ==null){            return;        }        Stack<Node<String>> stack=new Stack<>();        stack.push(root);        while (!stack.isEmpty()) {            Node<String> curNode= stack.pop();//栈顶元素出站            System.out.print(" : "+curNode.data);//有坑 注意非空判断            if(curNode.rightChild!=null){                stack.push(curNode.rightChild);            }            if(curNode.leftChild!=null){                stack.push(curNode.leftChild);;            }        }    }    /**     * 栈+循环  实现 中序遍历     * @param root     * 思路 左子树都处理完直到null的时候出栈并访问。     */    public void mirOrderTraverse2(Node root){        if(root ==null){            return;        }        Stack<Node<String>> stack=new Stack<>();        while(root!=null || !stack.isEmpty()){            while(root!=null){                stack.push(root);//先访问再入栈                root=root.leftChild;            }            root=stack.pop(); //出栈            System.out.print(" : "+root.data);            root=root.rightChild;//如果是null，出栈并处理右子树        }    }    /**     * 递归算法 前序遍历     * @param root     */    public void preOrderTraverse1(Node root){        if(root ==null){            return;        }        System.out.print(" : "+root.data);        preOrderTraverse1(root.leftChild);        preOrderTraverse1(root.rightChild);    }    /**     * 递归算法 中序遍历     * @param root     */    public void mirOrderTraverse1(Node root){        if(root==null){            return;        }        mirOrderTraverse1(root.leftChild);        System.out.print (" : "+root.data);        mirOrderTraverse1(root.rightChild);    }    /**     * 递归算法 后序遍历     * @param root     */    public void postOrderTraverse1(Node root){        if(root==null){            return;        }        postOrderTraverse1(root.leftChild);        postOrderTraverse1(root.rightChild);        System.out.print(" : "+root.data);    }    /**     * 定义类     * @version 创建时间: 2017-11-14 下午10:26:07     * 类说明:     */    public class Node<T>{        T data;        Node leftChild;        Node rightChild;        public Node(T data, Node leftChild, Node rightChild) {            super();            this.data = data;            this.leftChild = leftChild;            this.rightChild = rightChild;        }    }

   /**     * 构建二叉树     *             A     *          B       C     *       D    E         F     */    public void createTree(){        Node<String> nodeB =new Node<String>("B", null, null);        Node<String> nodeC =new Node<String>("C", null, null);        Node<String> nodeD =new Node<String>("D", null, null);        Node<String> nodeE =new Node<String>("E", null, null);        Node<String> nodeF =new Node<String>("F", null, null);        root.leftChild=nodeB;        root.rightChild=nodeC;        nodeB.leftChild=nodeD;        nodeB.rightChild=nodeE;        nodeC.rightChild=nodeF;    }    public static void main(String[] args) {        BinarayTree tree=new BinarayTree("A");//传递的是根节点的值        tree.createTree();        System.out.println("递归 前序遍历：正确顺序值 A B D E C F");        tree.preOrderTraverse1(tree.root);        System.out.println();        System.out.println("栈+循环  前序遍历：正确顺序值 A B D E C F");        tree.preOrderTraverse2(tree.root);        System.out.println();        System.out.println("------------------------------");        System.out.println("递归 中序遍历：正确顺序值 D B E A C F");        tree.mirOrderTraverse1(tree.root);        System.out.println();        System.out.println("栈+循环  中序遍历：正确顺序值D E B F C A");        tree.mirOrderTraverse2(tree.root);        System.out.println();        System.out.println("------------------------------");        System.out.println("递归 后序遍历：正确顺序值 D E B F C A");        tree.postOrderTraverse1(tree.root);        System.out.println();        System.out.println("栈+循环  后序遍历：正确顺序值D E B F C A");        tree.postOrderTraverse2(tree.root);    }
}

运行结果如下：