LeetCode OJ：Binary Tree Paths（二叉树路径）

Given a binary tree, return all root-to-leaf paths.

For example, given the following binary tree:

  1
 / 
2   3
 
  5

All root-to-leaf paths are:

["1->2->5", "1->3"]

简单的遍历查找路径问题，代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        ret.clear();
        string s = "";
        if(root == NULL) return ret;
        dfs(root, s);
        for(int i = 0; i < ret.size(); ++i){
            ret[i].erase(ret[i].begin(), ret[i].begin() + 2);
        }
        return ret;
    }

    void dfs(TreeNode * root, string s)
    {
        stringstream ss;
        ss << "->" << root->val;
        s += ss.str();
        if(root->left == NULL && root->right == NULL){
            ret.push_back(s);
            return;
        }
        if(root->left){
            dfs(root->left, s);
        }
        if(root->right){
            dfs(root->right, s);
        }
    }
private:
    vector<string> ret;
};

 java版本的如下所示，和c++的相比还是要简单很多的，因为处理字符串的函数用起来比较方便的原因，代码如下：

public class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ret = new ArrayList<String>();
        String str = new String();
        if(root == null)
            return ret;
        dfs(root, str, ret);
        return ret;
    }
    public void dfs(TreeNode root, String path, List<String> ret){
        if(root.left != null){
            path = path + "->" + root.val;
            dfs(root.left, path, ret);
            path = path.substring(0, path.lastIndexOf("->")); //引用其他的
        }                                        //还是要继续使用的，截断即可
        if(root.right != null){
            path = path + "->" + root.val;
            dfs(root.right, path, ret);
            path = path.substring(0, path.lastIndexOf("->"));
        }
        if(root.left == null && root.right == null){
            path = path + "->" + root.val;
            ret.add(path.substring(2));
            path = path.substring(0,path.lastIndexOf("->"));
            return;
        }
    }
}