バイナリツリーの行きがけ、inorderを、後順の再帰と非再帰的な階層トラバーサル

プレオーダーバイナリツリーは、配列に、トラバース後DFS（深さ優先探索）を考え、階層トラバーサルBFS（BFS）と思いました。BFSキューで実装、DFSは、一般的に、再帰的またはスタックを使用して実装されています。

    private static List<Node> nodeList=null;
    //定义二叉树
    private static class Node{
        private Node leftChild,rightChild;
        private int data;
        public Node(int newData){
            leftChild=null;
            rightChild=null;
            data=newData;
        }
    }

    //构建二叉树
    public static void createBinaryTree(int[] objs){
        nodeList=new ArrayList<Node>();
        for(int o:objs){
            nodeList.add(new Node(o));
        }
        for(int i=0;i<objs.length/2;i++){
            nodeList.get(i).leftChild=nodeList.get(i*2+1);
            if(i*2+2<nodeList.size()) {
                nodeList.get(i).rightChild = nodeList.get(i * 2 + 2);
            }
        }
    }

予約限定：ルート - >左のサブツリー - >右部分木

    //先序遍历 递归实现
    public static void pre(Node node){
        if(node!=null){
            System.out.print(node.data+" ");
            pre(node.leftChild);
            pre(node.rightChild);
        }
    }
    //先序遍历 非递归实现
    public static void pre2(Node node){
        Stack<Node> stack=new Stack<Node>();
        while(node!=null || !stack.empty()){
            if(node!=null){
                System.out.print(node.data+" ");
                stack.push(node);
                node=node.leftChild;
            }else{
                Node tmpNode=stack.pop();
                node=tmpNode.rightChild;
            }
        }
    }

予約限定：左のサブツリー - >ルート - >右部分木

    //中序遍历 递归实现
    public static void mid(Node node){
        if(node!=null){
            mid(node.leftChild);
            System.out.print(node.data+" ");
            mid(node.rightChild);
        }
    }
    //中序遍历 非递归实现
    public static void mid2(Node node){
        Stack<Node> stack=new Stack<Node>();
        while(node!=null || !stack.empty()){
            if(node!=null){
                stack.push(node);
                node=node.leftChild;
            }else{
                Node tmpNode=stack.pop();
                System.out.print(tmpNode.data+" ");
                node=tmpNode.rightChild;
            }
        }
    }

後順：左のサブツリー - >右部分木 - >ルート

    //后序遍历 递归实现
    public static void post(Node node){
        if(node!=null){
            post(node.leftChild);
            post(node.rightChild);
            System.out.print(node.data+" ");
        }
    }
    //后序遍历 非递归实现
    public static void post2(Node node){
        Stack<Node> stack=new Stack<Node>();
        Node p=node;
        while(node!=null || !stack.empty()){
            if(node!=null){
                stack.push(node);
                node=node.leftChild;
            }else{//node==null && !stack.empty()
                Node tmpNode=stack.peek().rightChild;
                if(tmpNode==null || tmpNode==p){
                    node=stack.pop();
                    System.out.print(node.data+" ");
                    p=node;
                    node=null;
                }else{
                    node=tmpNode;
                }
            }
        }
    }

レベルをトラバース

Javaのキューは、一般的にLinkedListのは、両方のListインタフェースを実現する、LinkedListのに使用されている、それはリストの操作を行うことができます。ときキューのDequeと実装インタフェースは、それを使用することが可能です。リストとして使用する場合、一般的にプッシュする方法を取得/アドオンを使用/オブジェクトを取得します。唯一のオファー/世論調査を使用して、キューとして使用する場合、/のように取ります。

    //层次遍历
    public static void levalOrder(Node node){
        if(node==null) return;
        Queue<Node> q=new LinkedList<Node>();
        q.offer(node);
        Node temp=null;
        while(!q.isEmpty()){
            temp=q.poll();
            System.out.print(temp.data+" ");
            if(temp.leftChild!=null){
                q.offer(temp.leftChild);
            }
            if(temp.rightChild!=null){
                q.offer(temp.rightChild);
            }
        }
    }

テスト

 public static void main(String[] args) {
        int[] node=new int[]{1,2,3,4,5,6};
        //创建二叉树
        //          1
        //         /  \
        //        2    3
        //       / \   /
        //      4   5  6
        createBinaryTree(node);
        //根节点
        Node root=nodeList.get(0);
        //先序遍历（根节点->左子树->右子数）：1 2 4 5 3 6
        System.out.println("先序遍历");
        pre2(root);
        //中序遍历（左子树->根节点->右子数）：4 2 5 1 6 3
        System.out.println("\n中序遍历");
        mid2(root);
        //后序遍历（左子树->右子树->根节点）：4 5 2 6 3 1
        System.out.println("\n后序遍历");
        post2(root);
        //层次遍历：1 2 3 4 5 6
        System.out.println("\n层次遍历");
        levalOrder(root);
    }