이진 트리 탐색 및 비 재귀, 재귀 / 통과 수준

이진 트리 탐색

주문 탐색, postorder 및 레벨 주사로 고전 이진 트리 탐색 네, 예약 주문 탐색.

상기 식에서, 전, 동안 및 인쇄 순서 통과 노드의 왼쪽과 오른쪽 서브 트리에 노드로 표시되는 순서 후에.

 

다음 트리의 노드,이 노드의 첫 번째 인쇄 및 것이 서브 트리를 왼쪽으로 인쇄하고, 마지막으로 오른쪽 서브 트리를 인쇄, 전순 주사 수단.

예약 주문 수단은 트리의 노드를 들면, 먼저 왼쪽 서브 트리를 인쇄 한 다음 스스로를 인쇄하고, 마지막으로 오른쪽 서브 트리를 인쇄 할 수 있습니다.

트리의 노드를 들면, 먼저 왼쪽 서브 트리를 인쇄 한 다음 그것을 바로 하위 트리를 인쇄하고, 마지막 노드 자체를 인쇄, Postorder 수단.

 

이후 전 DFS (깊이 우선 알고리즘)의 생각에

 

 

사실, 이진 트리 이전, 도중 및 주문 탐색 한 후 것은 순환 과정이다.

예약 주문 탐색, 사실, 재귀 왼쪽 서브 트리를 인쇄하고, 마지막으로 오른쪽 서브 트리를 재귀 적으로 인쇄, 루트 노드를 인쇄 처음이다. 

前序遍历的递推公式：
preOrder(r) = print r->preOrder(r.left)->preOrder(r.right)

中序遍历的递推公式：
inOrder(r) = inOrder(r.left)->print r->inOrder(r.right)

后序遍历的递推公式：
postOrder(r) = postOrder(r.left)->postOrder(r.right)->print r

 

재귀

    /**
     * 先序遍历
     */
    public static void preOrder(Node root) {
        if (root == null) {
            return;
        }
        System.out.print(root.value + " -> ");
        preOrder(root.left);
        preOrder(root.right);
    }

    /**
     * 中序遍历
     */
    public static void inOrder(Node root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.value + " -> ");
        inOrder(root.right);
    }

    /**
     * 后序遍历
     */
    public static void postOrder(Node root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value + " ->  ");
    }

비 재귀

스택 자체가 재귀 구현이와 함께, 비 재귀 구현은, 본질적으로 우리가 실제로 될 "수동 재귀"를 달성하기 위해 스택 필요

    /**
     * 前序遍历
     */

    public static void preOrder2(Node root) {
        if (root == null) {
            return;
        }
        Stack<Node> s = new Stack<>();
        s.push(root);
        Node curNode;
        while (!s.isEmpty()) {
            curNode = s.pop();
            System.out.print(curNode.data + "->");
            // 栈先进后出，所以先加入右侧节点，这样输出的时候，先输出左侧节点
            if (curNode.right != null) {
                s.push(curNode.right);
            }
            if (curNode.left != null) {
                s.push(curNode.left);
            }
        }
    }


    /**
     * 中序遍历
     */

    public static void inOrder2(Node root) {
        if (root == null) {
            return;
        }
        Stack<Node> s = new Stack<>();
        Node curNode = root;
        while (!s.isEmpty() || curNode != null) {
            // 入栈所有左节点并输出左节点
            while (curNode != null) {
                s.push(curNode);
                curNode = curNode.left;
            }

            // 弹出左节点
            curNode = s.pop();
            System.out.print(curNode.data + "->");
            // 弹出后，指向当前节点的右节点
            curNode = curNode.right;
        }
    }

     /**
     * 后序遍历
     */
    public static void postOrder2(Node root) {
        if (root == null) {
            return;
        }

        Stack<Node> s1 = new Stack<>();
        Stack<Node> s2 = new Stack<>();

        s1.push(root);

        Node curNode;
        while (!s1.isEmpty()) {

            curNode = s1.pop();
            // 中、右、左顺序压入栈中
            s2.push(curNode);

            // 压入s1为先左后右，保证中、右、左顺序压入s2中
            if (curNode.left != null) {
                s1.push(curNode.left);
            }
            if (curNode.right != null) {
                s1.push(curNode.right);
            }
        }
        while (!s2.isEmpty()) {
            System.out.print(s2.pop().data + "->");
        }

    }

수준을 트래버스

레벨 탐색 BFS (폭 우선 알고리즘) 생각.

일반적인 큐에 의해 달성 레벨 이진 트리 탐색.

 

수준 이송 단계는 다음과 같습니다

노드 1. 비어 있지 않은, 첫 번째 노드가 큐에 추가되고

팀 노드 중 2., 아이가 비어 있지 않은 경우 노드는, 아이들은 큐에 추가, 또는 아무것도 할 수 남았다. 마찬가지로 바로 아이

3. 상기 동작은 큐가 빌 때까지 반복되어, 최종 레벨을 횡단

 

    public static void LevelTraversal(Node root) {
        if (root == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<Node>();
        Node curNode = null;
        queue.offer(root);//将根节点入队
        while (!queue.isEmpty()) {
            curNode = queue.poll();//出队队头元素并访问
            System.out.print(curNode.data + "->");
            if (curNode.left != null)//如果当前节点的左节点不为空入队
            {
                queue.offer(curNode.left);
            }
            if (curNode.right != null)//如果当前节点的右节点不为空，把右节点入队
            {
                queue.offer(curNode.right);
            }
        }
    }