0

例如，在下面向 BST 添加节点的函数中，我只使用了隐式引用。我可以在函数开始时明确声明一个变量 TreenNode node = ..，并在适当的地方使用它。现在，我不知道它是否基于意见。真诚地使用 OPTION1 而不是 OPTION2 有任何优点或缺点

选项1： 

 public void add(int item) {
        if (root == null) {
            root = new TreeNode(null, item, null);
            return;
        }

        TreeNode node = root;
        while (true) {
            if (item < node.item) {
                if (node.left == null) {
                    node.left = new TreeNode(null, item, null);
                    break;
                }
                node = node.left;
            } else {
                if (node.right == null) {
                    node.right = new TreeNode(null, item, null);
                    break;
                }
                node = node.right;
            }
        }
    }

选项 2：

public void add(int item) {

            TreeNode nodeNew = new TreeNode(null, item, null); // explicit

            if (root == null) {
                root = nodeNew;
                return;
            }

            TreeNode node = root;
            while (true) {
                if (item < node.item) {
                    if (node.left == null) {
                        node.left = nodeNew;
                        break;
                    }
                    node = node.left;
                } else {
                    if (node.right == null) {
                        node.right = nodeNew;
                        break;
                    }
                    node = node.right;
                }
            }
        }
4

2 回答 2

1

选项 1 更优化，因为它涉及的步骤更少。选项 2 意味着您创建一个包含引用的变量，仅使用它来分配 - 它对某些人来说可能看起来更好。在选项 1 中，您跳过临时引用并直接进行分配和对象创建。

然而，归根结底，没有其他区别。

此外，在选项 2 中，最好将您的 nodeNew 声明移到返回下方。

如果您不使用它，为什么要初始化它。

            if (root == null) {
                root = node;
                return;
            }

TreeNode nodeNew = new TreeNode(null, item, null); // explicit
于 2013-09-29T21:38:50.230 回答
1

首先，我认为root = node;选项 2 中的行，您可能希望它是：root = nodeNew;，是吗？

我认为有一个潜在的好处，因为nodeNewoption2 中引用的任何地方都在条件范围内，因此它可能永远不会被使用。在这种情况下，option1 的优点是只TreeNode在需要时实例化一个新对象。但在这种特殊情况下，看起来每次调用这个add方法总是需要创建一个新的TreeNode——如果不是在初始条件下，那么在 while 循环的某个迭代中；所以在这种情况下，我在这方面看不到真正的效率优势。

可能值得考虑的一个方面（并与可能在您的代码上工作的其他人交谈）是它的可维护性。在这种情况下，我看到 option1 的潜在优势和潜在劣势。也许这些情况不适用于您给出的具体示例，但可能适用于该问题适用的其他人：

潜在优势：

如果这是一段很长的代码，那么在创建新 TreeNode 的所有点上总是很清楚，它实际上是一个正在创建的 TreeNode 对象（而不是某个派生对象），以及哪些参数是传递给它的构造函数。

潜在劣势：

如果它永远不会被子类化，并且此方法中的所有实例都将被赋予完全相同的参数，那么 option2 的好处是有一个需要进行更改的地方（例如更改其中一个参数）。

于 2013-09-29T22:00:01.207 回答