二元树中和为某一值的所有路径

 

package com.xiaoge;
import java.util.*;

class BinaryTree {  
     private BinaryTreeNode root;    // 根  
  
     public BinaryTreeNode getRoot() {  
         return root;  
     }  
  
     public void setRoot(BinaryTreeNode root) {  
         this.root = root;  
     }  
       
     /** 
      * 增加子节点 
      * @param 节点 
      */ 
     public synchronized void addNode(BinaryTreeNode node) {  
         if (null == this.root) {  
             this.root = node;  
             return;  
         }  
         BinaryTreeNode tempNode = this.root;  
         while (true) {  
             if (node.getM_nValue() > tempNode.getM_nValue()) {   // 大于父节点  
                 if (null == tempNode.getM_pRight()) {  
                     tempNode.setM_pRight(node);  
                     return;  
                 } else {  
                     tempNode = tempNode.getM_pRight();  
                     continue;  
                 }  
             } else if (node.getM_nValue() < tempNode.getM_nValue()) {    // 小于父节点  
                 if (null == tempNode.getM_pLeft()) {  
                     tempNode.setM_pLeft(node);  
                     return;  
                 } else {  
                     tempNode = tempNode.getM_pLeft();  
                     continue;  
                 }  
             } else {    // 等于父节点  
                 return;  
             }  
         }  
     }  
       
     /** 
      * 输出指定路径和大小的所有路径 
      * @param 路径的和 
      */ 
     public synchronized void printSumPath(int sumValue) {  
         printSumPath(this.root, new ArrayList<Integer>(), 0, sumValue);  
     }  
       
     /** 
      * @param 节点 
      * @param 路径存储集合 
      * @param 临时路径的和 
      * @param 路径的和 
      */ 
     private void printSumPath(BinaryTreeNode node, List<Integer> path, int tempSum, int sumValue) {  
         if (null == node) {  
             return;  
         }  
           
         tempSum += node.getM_nValue();  
         path.add(node.getM_nValue());  
           
         boolean isLeaf = (null == node.getM_pLeft() && null == node.getM_pRight()); // 是否为叶子  
           
         if (isLeaf && tempSum == sumValue) {    // 满足  
             System.out.print("sumPath(" + sumValue + "): ");  
             for (int i : path) {  
                 System.out.print(i + " ");  
             }  
             System.out.println();  
         }  
         printSumPath(node.getM_pLeft(), path, tempSum, sumValue);  
         printSumPath(node.getM_pRight(), path, tempSum, sumValue);  
           
         // 保证递归完成后返回父节点时路径是根结点到父节点的路径，之后遍历父节点的其他子节点，没有则返回到爷爷节点...  
         path.remove(path.size() - 1);   // 删除当前节点  
         // 最后补充一下，如果path不是指针而是基本类型的话，这句话就没用了（放在递归调用下面就没用了），算法也废了，比如在这里加入一句tempSum+=XXX;对结果没有任何影响，不会影响递归return时其他函数里的参数  
     }  
       
     /** 
      * 打印前序遍历 
      */ 
     public synchronized void print() {  
         if (null == this.root) {  
             System.out.print("HashCode: " + this.hashCode() +  "; 空树;");  
             return;  
         }  
         System.out.print("HashCode: " + this.hashCode() +  "; 树: ");  
         print(this.root);  
         System.out.println();  
     }  
       
     private void print(BinaryTreeNode node) {  
         if (null != node) {  
             System.out.print(node.getM_nValue() + " ");  
             print(node.getM_pLeft());  
             print(node.getM_pRight());  
         }  
     }  
 }  

class BinaryTreeNode {  
     private int m_nValue; // value of node  
     private BinaryTreeNode m_pLeft; // left child of node  
     private BinaryTreeNode m_pRight; // right child of node  
       
     BinaryTreeNode(int value) {  
         this.m_nValue = value;  
     }  
       
     public int getM_nValue() {  
         return m_nValue;  
     }  
     public void setM_nValue(int mNValue) {  
         m_nValue = mNValue;  
     }  
     public BinaryTreeNode getM_pLeft() {  
         return m_pLeft;  
     }  
     public void setM_pLeft(BinaryTreeNode mPLeft) {  
         m_pLeft = mPLeft;  
     }  
     public BinaryTreeNode getM_pRight() {  
         return m_pRight;  
     }  
     public void setM_pRight(BinaryTreeNode mPRight) {  
         m_pRight = mPRight;  
     }  
}

public class FindPath {  
     public static void main(String[] args) {  
      BinaryTree  tree = new BinaryTree ();  
         tree.addNode(new BinaryTreeNode(10));  
         tree.addNode(new BinaryTreeNode(5));  
         tree.addNode(new BinaryTreeNode(12));  
         tree.addNode(new BinaryTreeNode(4));  
         tree.addNode(new BinaryTreeNode(7));  
         tree.addNode(new BinaryTreeNode(9));  
         tree.addNode(new BinaryTreeNode(3));  
         tree.print();  
         tree.printSumPath(22);  
         tree.printSumPath(31);  
     }  
 }