Question

我正在尝试在二叉搜索树类中编写一个函数，该类将返回树中public int greater (int n)形式的值大于n的节点数。我想可能更容易将所有值存储在列表中，然后迭代列表并在每次发现一个数字大于n时递增计数。我将如何实现这一目标？

到目前为止，这是我的班级：

public class BST
{ private BTNode<Integer> root;
    private int count = 0;
    List<Integer> arr = new ArrayList<>();
    private BST right = new BST();
    private BST left = new BST();

    public BST()
  { root = null;
  }

  public boolean find(Integer i)
  { BTNode<Integer> n = root;
    boolean found = false;

    while (n!=null && !found)
    { int comp = i.compareTo(n.data);
      if (comp==0)
        found = true;
      else if (comp<0)
        n = n.left;
      else
        n = n.right;
    }

    return found;
  }

  public boolean insert(Integer i)
  { BTNode<Integer> parent = root, child = root;
    boolean goneLeft = false;

    while (child!=null && i.compareTo(child.data)!=0)
    { parent = child;
      if (i.compareTo(child.data)<0)
      { child = child.left;
        goneLeft = true;
      }
      else
      { child = child.right;
        goneLeft = false;
      }
    }

    if (child!=null)
      return false;  // number already present
    else
    { BTNode<Integer> leaf = new BTNode<Integer>(i);
      if (parent==null) // tree was empty
        root = leaf;
      else if (goneLeft)
        parent.left = leaf;
      else
        parent.right = leaf;
      return true;
    }
  }

  public int greater(int n){ //TODO
      return 0;
  }
}

class BTNode<T>
{ T data;
  BTNode<T> left, right;

  BTNode(T o)
  { data = o; left = right = null;
  }
}

Answer 1

我不会将列表用作临时存储。

有一个名为Tree Traversal的概念，允许您访问树的每个节点。

这是一些伪代码：

preorder(node)
  if (node = null)
    return
  visit(node)
  preorder(node.left)
  preorder(node.right)

这里的visit函数在每个节点只执行一次。对于像您所描述的计数这样的专门遍历，您只需将visit替换为您想要的功能，例如：

if (node.data > n) {
    count += 1
}

如果你实现一个Preorder类，你可以扩展它以提供自定义访问功能，那就更好了。

如何将每个节点存储在列表中的二叉搜索树中？

1 个答案: