Question

我正在阅读Introduction to algorithms我遇到了关于二阶搜索树的有序遍历而不使用堆栈或递归的问题。 Hint说假设测试指向相等的指针是合法的操作。我找不到解决这个问题的方法。请给我一些指示。我没有找代码。请给我正确的方向。

完全重复here

Answer 1

没有堆栈或递归意味着你必须使用指针。不给你代码也不给你确切的答案，因为你要求不要:)

考虑如何在不使用递归的情况下探索树：您需要做什么？你需要保留什么指针？树节点是否可以指向父节点？

希望它有所帮助。

Answer 2

我们需要一个线程二进制树来执行有序遍历而不需要递归/堆栈。 Wiki说'二进制树是通过制作所有正确的子指针来进行线程化的，这些指针通常是null指向节点的inorder后继者，并且通常为null的所有左子指针指向节点'的前导者

因此，您将获得一个普通的二叉树，将其转换为一个可以使用 Morris Traversal 完成的线程二叉树。您在Morris Traversal中要做的是将每个节点与其有序后继连接。因此，在访问节点时，搜索其有序的前任并让它成为Pred。然后制作Pred-＆gt; right =当前节点，我们也必须恢复更改。您可以更好地参考此http://www.geeksforgeeks.org/archives/6358获取一个很好的解释。

Answer 3

Hello Parminder我已经在java中实现了你的问题。请检查一次

class InorderWithoutRecursion {
    public static void morrisTraversal(TreeNode root) {

        TreeNode current,pre;

    if(root == null)
        return; 

    current = root;
    while(current != null){
        if(current.left == null){
            System.out.println(current.data);
            current = current.right;
        }
        else {
      /* Find the inorder predecessor of current */
            pre = current.left;
            while(pre.right != null && pre.right != current)
            pre = pre.right;

      /* Make current as right child of its inorder predecessor */
        if(pre.right == null){
            pre.right = current;
            current = current.left;
        }

      /* Revert the changes made in if part to restore the original
        tree i.e., fix the right child of predecssor */
        else {
            pre.right = null;
            System.out.println(current.data);
            current = current.right;
        }
      } 
  } 
}
 public static void main(String[] args) {
        int[] nodes_flattened = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        TreeNode root = TreeNode.createMinimalBST(nodes_flattened);
        morrisTraversal(root);
    }
}

对于TreeNode类，下面的代码可以帮助你..

public class TreeNode {
    public int data;      
    public TreeNode left;    
    public TreeNode right; 
    public TreeNode parent;

    public TreeNode(int d) {
        data = d;
    }

    public void setLeftChild(TreeNode left) {
        this.left = left;
        if (left != null) {
            left.parent = this;
        }
    }

    public void setRightChild(TreeNode right) {
        this.right = right;
        if (right != null) {
            right.parent = this;
        }
    }

    public void insertInOrder(int d) {
        if (d <= data) {
            if (left == null) {
                setLeftChild(new TreeNode(d));
            } else {
                left.insertInOrder(d);
            }
        } else {
            if (right == null) {
                setRightChild(new TreeNode(d));
            } else {
                right.insertInOrder(d);
            }
        }
    }

    public boolean isBST() {
        if (left != null) {
            if (data < left.data || !left.isBST()) {
                return false;
            }
        }

        if (right != null) {
            if (data >= right.data || !right.isBST()) {
                return false;
            }
        }       

        return true;
    }

    public int height() {
        int leftHeight = left != null ? left.height() : 0;
        int rightHeight = right != null ? right.height() : 0;
        return 1 + Math.max(leftHeight, rightHeight);
    }

    public TreeNode find(int d) {
        if (d == data) {
            return this;
        } else if (d <= data) {
            return left != null ? left.find(d) : null;
        } else if (d > data) {
            return right != null ? right.find(d) : null;
        }
        return null;
    }

    private static TreeNode createMinimalBST(int arr[], int start, int end){
        if (end < start) {
            return null;
        }
        int mid = (start + end) / 2;
        TreeNode n = new TreeNode(arr[mid]);
        n.setLeftChild(createMinimalBST(arr, start, mid - 1));
        n.setRightChild(createMinimalBST(arr, mid + 1, end));
        return n;
    }

    public static TreeNode createMinimalBST(int array[]) {
        return createMinimalBST(array, 0, array.length - 1);
    }
}

遍历二叉搜索树

3 个答案: