二叉树路径上的和为某一值；第一个只出现一次的字符位置；二叉树的深度;判断一棵树是不是平衡二叉树

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void path(TreeNode* tree,int sum)
    {
        if(tree == nullptr)
            return;
        vec2.push_back(tree->val);
        if(tree->left == nullptr && tree->right == nullptr && sum == tree->val)
            vec1.push_back(vec2);
        else
        {
            if(tree->left)
                path(tree->left,sum - tree->val);
            if(tree->right)
                path(tree->right,sum - tree->val);
        }
        vec2.pop_back();   //数组压入二维数组之后，就会被一次一次的尾删在递归中回到双亲结点开始下一次的遍历
    }
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        path(root,expectNumber);
        return vec1;
    }
private:
    vector<vector<int>> vec1;
    vector<int> vec2;
};

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        int size = str.size();
        vector<int> vec;
        vec.resize(256); 
        for(int i = 0; i < size; ++i)
        {
            vec[str[i]]++;
        }
        for(int i = 0; i < size;++i)
        {
            if(vec[str[i]] == 1)
                return i;
        }
        return -1;
    }
};

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(pRoot == nullptr)
            return 0;
        int left = TreeDepth(pRoot->left);
        int right = TreeDepth(pRoot->right);
        return left > right ? left + 1 : right + 1;
    }
};

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

class Solution {
public:
    int func(TreeNode* tree)
    {
        if(tree == nullptr)
            return 0;
        int left = func(tree->left);
        if(left == -1)
            return -1;
        int right = func(tree->right);
        if(right == -1)
            return -1;
        return abs(left - right) > 1 ? -1 :( 1 + ((left > right) ? left : right));
    }
    
    
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(pRoot == nullptr)
            return true;
        return func(pRoot) != -1;
    }
};