Data structures 二叉树中的最长连续序列

我试图实现“二叉树中最长连续序列”的逻辑。我在方法{longestconsutivepath}中实现的逻辑没有按照树结构的预期工作。它给我的lognest路径长度为5。 输出： 长度：5

    BSTNode node = new BSTNode(1);
    node.setRight(new BSTNode(2));
    node.getRight().setRight(new BSTNode(3));
    node.getRight().getRight().setRight(new BSTNode(4));
    node.getRight().getRight().getRight().setRight(new BSTNode(5));

    node.getRight().setLeft(new BSTNode(7));
    node.getRight().getLeft().setLeft(new BSTNode(8));
    node.getRight().getLeft().getLeft().setLeft(new BSTNode(9));
    node.getRight().getLeft().getLeft().getLeft().setLeft(new BSTNode(10));
    node.getRight().getLeft().getLeft().getLeft().getLeft().setLeft(new BSTNode(11));
    node.getRight().getLeft().getLeft().getLeft().getLeft().getLeft().setLeft(new BSTNode(12));

实现最长连续序列逻辑的类：

public class LongestConsecutivePath {

static BSTNode root = null;

public LongestConsecutivePath() {
    root = createBinaryTree();
    System.out.println("Before finding the longest consecutive path:");
    inorder();
}

public void inorder() {
    if (null == root) {
        return;
    }
    inorder(root);
}

private void inorder(BSTNode node) {
    if (null != node) {
        inorder(node.getLeft());
        System.out.print(node.getData() + " ");
        inorder(node.getRight());
    }
}

public BSTNode createBinaryTree() {
    BSTNode node = new BSTNode(1);
    node.setRight(new BSTNode(2));
    node.getRight().setRight(new BSTNode(3));
    node.getRight().getRight().setRight(new BSTNode(4));
    node.getRight().getRight().getRight().setRight(new BSTNode(5));

    node.getRight().setLeft(new BSTNode(7));
    node.getRight().getLeft().setLeft(new BSTNode(8));
    node.getRight().getLeft().getLeft().setLeft(new BSTNode(9));
    node.getRight().getLeft().getLeft().getLeft().setLeft(new BSTNode(10));
    node.getRight().getLeft().getLeft().getLeft().getLeft().setLeft(new BSTNode(11));
    node.getRight().getLeft().getLeft().getLeft().getLeft().getLeft().setLeft(new BSTNode(12));

    return node;
}

public int longestConsecutivePath() {
    if (null == root) {
        return 0;
    }

    return longestConsecutivePath(root, 0, root.getData() + 1);
}

public int longestConsecutivePath(BSTNode node, int curLength,
        int targetLength) {
    if (null == node) {
        return curLength;
    }

    if (node.getData() == targetLength) {
        System.out.println("\nnode data value: "+node.getData());
        curLength += 1;
        longestPath = curLength;
    } else {
        curLength = 1;
    }

    longestLeft = longestConsecutivePath(node.getLeft(), curLength,
            node.getData() + 1);
    longestRight = longestConsecutivePath(node.getRight(), curLength,
            node.getData() + 1);

    return Math.max(curLength, Math.max(longestLeft, longestRight));
}

public static void main(String[] args) {
    LongestConsecutivePath consecutivePath = new LongestConsecutivePath();
    int curLength = consecutivePath.longestConsecutivePath();
    System.out.println("\ncurLength : " + curLength);
  }
}

BSTNode.java

public class BSTNode {

BSTNode left, right;
int data;

/* Default constructor */
public BSTNode() {
    left = null;
    right = null;
    data = 0;
}

/* Constructor */
public BSTNode(int data) {
    left = null;
    right = null;
    this.data = data;
}

public BSTNode getLeft() {
    return left;
}

public void setLeft(BSTNode left) {
    this.left = left;
}

public BSTNode getRight() {
    return right;
}

public void setRight(BSTNode right) {
    this.right = right;
}

public int getData() {
    return data;
}

public void setData(int data) {
    this.data = data;
  }
}

---

我运行了你的代码，得到了正确的结果。逻辑看起来不错。它检查每一条可能的路径。你确定你在使用这个精确的测试用例吗？Hi@JaysonBoubin-根据当前的代码和树结构，我应该以6的形式接收输出（节点分别是7、8、9、10、11、12）。然而，我得到的输出是5。所以它实际上是从树结构中考虑这些节点（1，2，3，4，5）。你有没有修改过树的结构？你能告诉我你的产量是多少吗？