使用遞歸和非遞歸算法實現二叉搜索樹的遍歷

【使用遞歸和非遞歸實現二叉搜索樹的遍歷】

---

 

　　                使用遞歸和非遞歸實現二叉搜索樹的遍歷

1.遍歷的基本概念：所謂遍歷(Traversal)，是指沿着某條搜索路線，依次對樹中每個結點均做一次且僅做一次訪問。訪問結點所做的操作依賴於具體的應用問題。 遍歷是二叉樹上最重要的運算之一，是二叉樹上進行其它運算之基礎。

2.使用遞歸算法分別執行先序，中序，后序遍歷:

 

public class BinaryTree {
    // 初始化二叉樹
    public Node init() {
        Node I = 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, I);
        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;
    }

    // 訪問節點
    public void printNode(Node node) {
        System.out.println(node.getData());
    }

    // 先序遍歷
    public void theFirstTraversal(Node root) {
        printNode(root);
        // 使用遞歸遍歷左孩子
        if (root.getLeftNode() != null) {
            theFirstTraversal(root.getLeftNode());
        }
        // 使用遞歸遍歷右孩子
        if (root.getRightNode() != null) {
            theFirstTraversal(root.getRightNode());
        }
    }

    // 中序遍歷
    public void theInOrderTraversal(Node root) {
        // 遞歸遍歷左孩子
        if (root.getLeftNode() != null) {
            theInOrderTraversal(root.getLeftNode());
        }
        printNode(root);
        // 遍歷右孩子
        if (root.getRightNode() != null) {
            theInOrderTraversal(root.getRightNode());
        }
    }

    // 后序遍歷
    public void thePostOrderTraveral(Node root) {
        // 遞歸遍歷左孩子
        if (root.getLeftNode() != null) {
            theInOrderTraversal(root.getLeftNode());
        }

        // 遍歷右孩子
        if (root.getRightNode() != null) {
            theInOrderTraversal(root.getRightNode());
        }
        printNode(root);

    }

    public static void main(String[] args) {
        BinaryTree t = new BinaryTree();
        Node node = t.init();
        System.out.println("先序遍歷:");
        t.theFirstTraversal(node);
        System.out.println("中序遍歷:");
        t.theInOrderTraversal(node);
        System.out.println("后序遍歷:");
        t.thePostOrderTraveral(node);

    }

}

 

2.使用非遞歸算法分別執行先序，中序，后序遍歷：

public class BinaryTree1 {
    // 初始化二叉樹
    public Node init() {
        Node I = 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, I);
        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;
    }

    public void printNode(Node node) {
        System.out.print(node.getData());
    }

    public void theFirstTraversal_Stack(Node root) { // 先序遍歷
    Stack<Node> stack = new Stack<Node>();
        Node node = root;
        while (node != null || stack.size() > 0) { // 將所有左孩子壓棧
            if (node != null) { // 壓棧之前先訪問
                printNode(node);
            
                stack.push(node);
                
                node = node.getLeftNode();
                
            } else {
                node = stack.pop();
                
                node = node.getRightNode();
                
            }
        }
    }

    public void theInOrderTraversal_Stack(Node root) { // 中序遍歷
        Stack<Node> stack = new Stack<Node>();
        Node node = root;
        while (node != null || stack.size() > 0) {
            if (node != null) {
                stack.push(node); // 直接壓棧
                node = node.getLeftNode();
            } else {
                node = stack.pop(); // 出棧並訪問
                printNode(node);
                node = node.getRightNode();
            }
        }
    }

    public void thePostOrderTraversal_Stack(Node root) { // 后序遍歷
        Stack<Node> stack = new Stack<Node>();
        Stack<Node> output = new Stack<Node>();// 構造一個中間棧來存儲逆后序遍歷的結果
        Node node = root;
        while (node != null || stack.size() > 0) {
            if (node != null) {
                output.push(node);
                
                stack.push(node);
                
                node = node.getRightNode();
                
            } else {
                node = stack.pop();
                node = node.getLeftNode();
            }
        }
        System.out.println(output.size());
        while (output.size() > 0) {

            printNode(output.pop());
        }
    }

    public static void main(String[] args) {
        BinaryTree1 tree = new BinaryTree1();
        Node root = tree.init();
        System.out.println("先序遍歷");
        tree.theFirstTraversal_Stack(root);
        System.out.println("");
        System.out.println("中序遍歷");
        tree.theInOrderTraversal_Stack(root);
        System.out.println("");
        System.out.println("后序遍歷");
        tree.thePostOrderTraversal_Stack(root);

    }
}