java - 二叉搜索树遍历，将 InOrder、PreOrder、PostOrder、RevInOrder 组合在一个方法中

Question

我有一个二叉搜索树，必须编写一个 inOrder、preOrder、postOrder 和 reverseInOrder 方法，这是我基于此的实现（不包括 inOrder）：

public String reverseInOrder() {

            String retString = "";

            // 1. Traverse the right subtree by recursively calling the pre-order function.
            if (this.bigger != null) retString += this.bigger.reverseInOrder() + ", ";

            // 2. Access the data part of the current node.
            retString += this.content;

            // 3. Traverse the left subtree by recursively calling the pre-order function.
            if (this.smaller != null) retString += ", " + this.smaller.reverseInOrder();

            return retString;
        }

        public String postOrder() {

            String retString = "";

            // 1. Traverse the left subtree by recursively calling the pre-order function.
            if (this.smaller != null) retString += this.smaller.preOrder() + ", ";

            // 2. Traverse the right subtree by recursively calling the pre-order function.
            if (this.bigger != null) retString += this.bigger.preOrder() + ", ";

            // 3. Access the data part of the current node.
            retString += this.content;

            return retString;
        }

        public String preOrder() {

            String retString = "";

            // 1. Access the data part of the current node.
            retString += this.content;

            // 2. Traverse the left subtree by recursively calling the pre-order function.
            if (this.smaller != null) retString += ", " + this.smaller.preOrder();

            // 3. Traverse the right subtree by recursively calling the pre-order function.
            if (this.bigger != null) retString += ", " + this.bigger.preOrder();

            return retString;
        }

如您所见，我总是做同样的三件事：

• 访问更小的子树
• 访问当前内容
• 访问更大的子树

只有我做它们的顺序会改变（为了可读性而忽略逗号的插入）。
因此，我想将此方法的所有类型简化为一种，您可以在其中选择顺序，这是我的实现：

    /**
     * ops:
     * 0 := smaller/left
     * 1 := this content
     * 2 := smaller/right
     */
    public String someOrder(int firstOp, int secondOp) {
        List<String> retParts = new ArrayList<String>();

        int thirdOp = 3 - firstOp - secondOp;
        for (int el : new int[]{firstOp, secondOp, thirdOp}) {
            switch (el) {
                case 0:
                    if (this.smaller != null) retParts.add(this.smaller.someOrder(firstOp, secondOp));
                    break;

                case 1:
                    retParts.add(this.content.toString());
                    break;

                case 2:
                    if (this.bigger != null) retParts.add(this.bigger.someOrder(firstOp, secondOp));
                    break;

                default:
                    // shouldn't happen
                    break;
            }
        }

        return String.join(", ", retParts);
    }

简短的解释：

您通过将第一个和第二个操作传递给该方法来告诉该方法操作的顺序（例如，如果您首先要进入较小的子树，则为 fistOp = 0），该方法会推断出最后一个操作。按照操作的顺序，我执行操作所代表的操作。最后，我将操作结果作为连接的字符串返回

不过，这对我来说似乎不是一个优雅的解决方案，所以我愿意就如何解决这个问题提出建议（一般来说，如何组合在 Java 中操作顺序不同的多种方法）

标签： javabinary-search-treetraversal