二叉樹 遍歷 先序 中序 後序 深度 廣度 MD

目錄

二叉樹遍歷

測試案例

遍歷結果：

先序遍歷：631254978
中序遍歷：123456789
後序遍歷：214538796
廣度優先：639157248
 

構造二叉樹

public static Node init() {
    //註意必須逆序建立，先建立子節點，再逆序往上建立，因為非葉子結點會使用到下面的節點 
    Node J = new Node(8, null, null);
    Node H = new Node(4, null, null);
    Node G = new Node(2, null, null);

    Node F = new Node(7, null, J);
    Node E = new Node(5, H, null);
    Node D = new Node(1, null, G);

    Node C = new Node(9, F, null);
    Node B = new Node(3, D, E);

    Node A = new Node(6, B, C);
    return A; //返回根節點  
}
 

結點定義

class Node {
    public int value;
    public Node left;
    public Node right;

    public Node(int value, Node left, Node right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

深度優先 Depth First Search

使用遞歸遍歷

其過程簡要來說是對每一個可能的分支路徑深入到不能再深入為止，而且每個節點只能訪問一次。

public static void preOrderTraversal(Node root) {
    if (root != null) {
        System.out.print(root.value); //先(根)序遍歷
        preOrderTraversal(root.left); //遞歸遍歷左孩子
        preOrderTraversal(root.right); //遞歸遍歷右孩子
    }
}

public static void inOrderTraversal(Node root) {
    if (root != null) {
        inOrderTraversal(root.left);
        System.out.print(root.value); //中(根)序遍歷
        inOrderTraversal(root.right);
    }
}

public static void postOrderTraversal(Node root) {
    if (root != null) {
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.value); //後(根)序遍歷
    }
}

使用棧遍歷

public static void preOrderTraversalStack(Node root) {
    Stack<Node> stack = new Stack<>();
    while (root != null || !stack.isEmpty()) {
        if (root != null) {
            System.out.print(root.value); //壓棧之前先訪問，先序遍歷
            stack.push(root); //壓棧
            root = root.left; //訪問左葉子節點
        } else { //沒有左(右)葉子節點
            root = stack.pop(); //返回最近壓入棧的結點【核心】
            root = root.right; //訪問右葉子節點
        }
    }
}

public static void preOrderTraversalStack2(Node root) {
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        Node node = stack.pop();
        System.out.print(node.value); //先序遍歷
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
    }
}

public static void inOrderTraversalStack(Node root) {
    Stack<Node> stack = new Stack<>();
    Node node = root;
    while (node != null || !stack.isEmpty()) {
        if (node != null) {
            stack.push(node);
            node = node.left;
        } else {
            node = stack.pop();
            System.out.print(node.value); //中序遍歷
            node = node.right;
        }
    }
}

public static void postOrderTraversalStack(Node root) {
    Stack<Node> stack = new Stack<>();
    Stack<Node> output = new Stack<>();//構造一個中間棧來存儲逆後序遍歷的結果
    Node node = root;
    while (node != null || !stack.isEmpty()) {
        if (node != null) {
            output.push(node);
            stack.push(node);
            node = node.right;
        } else {
            node = stack.pop();
            node = node.left;
        }
    }
    while (!output.isEmpty()) {
        System.out.print(output.pop().value); //後序遍歷
    }
}

廣度優先 Breadth First Search

又叫寬度優先搜索，或橫向優先搜索。
對每一層節點依次訪問，訪問完一層進入下一層，而且每個節點只能訪問一次

public static void levelTraversal(Node root) {
    LinkedList<Node> queue = new LinkedList<>(); //LinkedList是Java中最普通的一個隊列(Queue)實現
    queue.offer(root); //add、addLast
    while (!queue.isEmpty()) {
        Node node = queue.poll();//removeFirst
        System.out.print(node.value);
        if (node.left != null) {
            queue.offer(node.left);
        }
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
}

2018-12-8

二叉樹 遍歷 先序 中序 後序 深度 廣度 MD