4在二元树中找出和为某一值的所有路径

转载请注明出处：http://www.cnblogs.com/wuzetiandaren/p/4249910.html

声明：现大部分文章为寻找问题时在网上相互转载，此博是为自己做个记录记录，方便自己也方便有类似问题的朋友，故原出处已不好查到，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。 

题目：输入一个整数和一棵二叉树。从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。打印出和与输入整数相等的所有路径。

　　例如 输入整数22和如下二叉树

 　　10 

　　 / \  

　　 5 12  

　　 /   \  

　　4     7

　　则打印出两条路径：10, 12和10, 5, 7。

　　

设计思路：

　　1. 输入一个整形数组和一个整数，根据数组创建二叉树

　　2.用一个将当前路径的节点列表path 和总路径列表pathlist分别保存到LinkedList里,用一个变量(currentSum)保存当前节点值之和

　　　　a).若树为空，则结束查找。

　　　　b).将当前节点的值累加到currentSum,将当前节点累加到path。

　　　　c).若当前节点已经是叶子节点并且currentSum等于你的期望值，则将path累加到pathlist。

　　　　d).如果当前节点不为叶子结点，则递归查找它的左右孩子结点。

　　　　e).将当前结点从当前路径里删除，currentSum返回累加之前的值  ，及恢复到当前节点的父节点状态。

 

注：我创建的是一颗二叉排序树，若想创建其他类型的树则可将创建树的过程稍作修改。

java 实现代码如下：

 

package com.interview;

import java.util.LinkedList;

/**
 * 在二元树中找出和为某一值的所有路径
 * 注：此处建立的是一颗排序二叉树
 * @author wjh
 *
 */

public class _4SearchPath {

    /**
     * @param args
     */
    public _4SearchPath() {
        super();
        // TODO Auto-generated constructor stub
    }

    public static void main(String[] args) {
        int[] first = {10,5,12,4,7};
        LinkedList<Node> path = new LinkedList<Node>(); //保存路径
        LinkedList<LinkedList<Node>> pathlist = new LinkedList<LinkedList<Node>>();  //保存路径列表
        Node root = null;
        root = createTree( root, first);   //1)建树
        searchPath(root, 22, 0,  path,pathlist);//2)查找路径
        System.out.println("这是所有的路径：");
        printPath(pathlist);    //3)打印路径
    }
    
    //在二元树中找出和为某一值的所有路径
    private static void searchPath(Node root, int yourSum, int  currentSum, LinkedList<Node> path, 
            LinkedList<LinkedList<Node>> pathlist){
        if( root==null )
             return;
        currentSum += root.data;  //将当前结点值累加至当前和变量中
        path.add(root);      //结点加入到路径里
        /**
         * 如果当前的结点为叶子结点，且和为你输入的值，则将路径 加入到李静列表里
         * 若无需保存路径列表，在在此直接打印path，不用添加到pathlist里
         */
        if(root.left==null && root.right==null && currentSum == yourSum){
            LinkedList<Node> temppath = new LinkedList<Node>();  
            for(Node node: path){
                temppath.add(node);
            }
            pathlist.add(temppath);  //没有直接add(path) 是因为path在之后的过程中会被改变
        }
        /**如果当前节点不为叶子结点，则递归查找它的左右孩子结点*/
        if(root.left!=null)
            searchPath(root.left, yourSum, currentSum, path, pathlist);
        if(root.right!=null)
            searchPath(root.right, yourSum, currentSum, path, pathlist);
        /**当前结点从当前路径里删除，currentSum返回累加之前的值  ，及恢复到当前节点的父节点状态*/
        currentSum -= root.data;
        path.removeLast();
    }
    
    //打印所有路径
    private static void printPath(LinkedList<LinkedList<Node>> pathlist){
        for(LinkedList<Node> path: pathlist){
            int n = path.size();
            for(int i=0;i<n;i++){
                if(i<n-1)
                    System.out.print(path.get(i).data+"-->");
                else 
                    System.out.print(path.get(i).data);
            }
            System.out.println();
        }
    }
        
    //创建二叉排序树
    public static Node  createTree(Node root, int[] r){
        int n = r.length;
        System.out.println("建树过程(a<--b表示在a左边插入b;a-->b表示在a右边插入b):");
        for(int i=0;i<n;i++){
            Node child = new Node(r[i],null,null);
            root = insert(root, child);
        }
        return root;
    }
        
    //二叉排序树的插入算法
    public static Node insert(Node root, Node child){
        //寻找插入位置
        if(root==null){
            root = child;
            System.out.println(root.data);
        }
        else 
            if(root.data>child.data){
                System.out.print(root.data+"<--");//在root左边插入
                root.left = insert(root.left, child);
            }
            else{
                System.out.print(root.data+"-->"); //在root右边插入
                root.right = insert(root.right,child);
            }    
        return root;
    }
    
    //节点的数据结构
    private static class Node {
        public int data;
        public Node left;   //指向左子树
        public Node right;  //指向右子树
        public Node() {
            super();
            // TODO Auto-generated constructor stub
        }
        public Node(int data, Node left, Node right) {
            super();
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }

}

 

运行结果：

 建树过程(a<--b表示在a左边插入b;a-->b表示在a右边插入b):
10
10<--5
10-->12
10<--5<--4
10<--5-->7
这是所有的路径：
10-->5-->7
10-->12