葉子的路徑在二叉樹中有特定的總和

Question

我知道如何找到二叉樹是否具有給定總和的特定路徑（如果這不是最好的方式請告訴我）：

int pathSum(MyNode root, int sum)
{
    if(root == null)
        return -1;
    int temp = sum - root.value;
    return(pathSum(root.left,temp) || pathSum(root.right,temp));
}

我無法弄清楚的是如何打印特定的路徑。

我的Node類看起來像這樣：

class MyNode {
    int value;
    MyNode left;
    MyNode right;

    MyNode(int value)
    {
        this.value = value;
    }
}

Answer 1

試試這個，使用重載：

 public void pathToSum(int sum) {
    pathToSum(root, sum);
}

private boolean pathToSum(Node n, int sum) {
    if (null != n) {
        sum -= n.data;
        boolean found = pathToSum(n.left, sum);

        if (!found) {
            found = pathtoSum(n.right, sum);
        }
        if (found) {
            println(n.data);
                            return found;
        }
    }
    return 0 == sum ? true : false;
}

此代碼使用以下類進行測試：

import java.util.LinkedList;
import java.util.Queue;
public class BST {
Node root;
public BST(){
    root = null;
}

public void insert(int el){

    Node tmp = root, p=null;
    while(null!=tmp && el != tmp.data){
        p=tmp;
        if(el<tmp.data)
            tmp=tmp.left;
        else
            tmp=tmp.right;
    }
    if(tmp == null){
        if(null == p)
            root = new Node(el);
        else if(el <p.data)
            p.left= new Node(el);
        else
            p.right=new Node(el);
    }
}//

public void pathToSum(int sum) {
    pathToSum(root, sum);
}//

private boolean pathToSum(Node n, int sum) {
    if (null != n) {
        sum -= n.data;
        boolean found = pathToSum(n.left, sum);

        if (!found) {
            found = pathToSum(n.right, sum);
        }
        if (found) {
            System.out.println(n.data);
            return found;
        }
    }
    return 0 == sum ? true : false;
}

public static void main(String[] args){
    int[] input={50,25,75,10,35,60,100,5,20,30,45,55,70,90,102};
    BST bst = new BST();
    for(int i:input)
        bst.insert(i);
    bst.pathToSum(155);
}
}

class Node{
public int data;
public Node left;
public Node right;
public Node(int el){
    data = el;
}
}

結果：

45
35
25
50

Answer 2

我建議改變你的MyNode類以包含父節點：

MyNode left;
MyNode right;
MyNode parent;

MyNode(int value, MyNode parent)
{
    this.value = value;
    this.parent = parent;
}

然后當你用一個正確的總和命中一個節點時，你可以將該節點傳遞給另一個通過祖先的函數，直到它到達具有空父（根）的節點。

Answer 3

好難題，我喜歡它。 你幾乎擁有它，只是對int與boolean的混淆，並沒有檢查sum的結束條件為零。

public class NodeSums {

    static boolean pathSum(MyNode root, int sum) {
        boolean ret;
        if (root == null) {
            ret = sum == 0;
        } else {
            int remain = sum - root.value;
            ret = pathSum(root.left,remain) || pathSum(root.right, remain);
        }
        return ret;
    }

    static class MyNode {
        int value;
        MyNode left;
        MyNode right;

        MyNode(int value) {
            this.value = value;
        }
    }

    public static void main(String[] args) {

        /**
         * Valid sums will be 3, 8, and 9
         * 
         *    1 -- 2 
         *      --
         *      -- 3 -- 4
         *           --
         *           -- 5
         */
        MyNode root = new MyNode(1);
        root.left = new MyNode(2);
        root.right = new MyNode(3);
        root.right.left = new MyNode(4);
        root.right.right = new MyNode(5);

        for (int i = 1; i < 10; i++) {
            System.out.println("Path sum " + i + " " + pathSum(root, i));
        }
    }
}

產量

Path sum 1 false
Path sum 2 false
Path sum 3 true
Path sum 4 false
Path sum 5 false
Path sum 6 false
Path sum 7 false
Path sum 8 true
Path sum 9 true

Answer 4

如果將每個節點的父節點存儲在MyNode中，則可以通過將父節點置於循環中直到它為空來找到從根節點到任何節點的（反向）路徑。

另外，你的pathSum代碼似乎混合了布爾值和整數，你從不檢查sum的值。