在Java中使用迭代方法实现DFS

Question

我已经看到了许多使用名为访问的布尔变量的DFS实现，我不想在我的代码中使用它。 在考虑一个场景时，我们有一个Node类，该类保留对与其子节点和数据（可以是任何Object）相对应的左右节点的引用，此方法可适用于Binary Trees计算dfs吗？ 我有一个没有邻接列表或矩阵的情况。

以下代码是否是DFS的良好实现？ 代码的时间复杂度是O（n）吗？

public void dfsForTree(BSTNode root) {
    Stack<BSTNode> s = new Stack<BSTNode>();
    BSTNode node;
    if (root == null) {
        return;
    }
    s.push(root);
    while (!s.isEmpty()) {
        node = s.pop();
        System.out.println(node.getData());
        if (node != null) {

            if (node.getRight() != null) {
                s.push(node.getRight);
            }
            if (node.getLeft != null) {
                s.push(node.getLeft);
            }

        }
    }
}

BSTNode类的实现：

public class BSTNode {

private BSTNode left;
private BSTNode right;
private int data;

/* Constructor */
public BSTNode(int n) {
    left = null;
    right = null;
    data = n;
}
/* Function to set left node */

public void setLeft(BSTNode n) {
    left = n;
}
/* Function to set right node */

public void setRight(BSTNode n) {
    right = n;
}
/* Function to get left node */

public BSTNode getLeft() {
    return left;
}
/* Function to get right node */

public BSTNode getRight() {
    return right;
}
/* Function to set data to node */

public void setData(int d) {
    data = d;
}
/* Function to get data from node */

public int getData() {
    return data;
}

Answer 1

可以肯定地说，迭代的树遍历是需要节点上的“向上”链接（或保存它们）才能回溯。 您只需要这样做-不保存“上”链接，而是直接保存下一个要在回溯后链接的链接。 另一方面，步骤之间没有相互依赖性。 请参见即使该函数自身未调用，它是否也是递归的？ 有关如何区分迭代和变相递归的信息。

另请参阅迭代树遍历以获取算法概述。

现在，由于计算复杂性。 该原理可以在Big O处找到， 您如何计算/近似它？ 。

你做：

• 处理每个节点
  • 恰好一次
• 从堆栈中推送和弹出节点
  • 每个节点也被推送和弹出一次

因此，确实是O（N） 。