【练习5】

1.查找总价格为目标值的两个商品

哈希表：

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
         //sort(price.begin(),price.end());
         vector<int> res(2,-1);
         unordered_map<int,int> mp;
         for(int i=0;i<price.size();i++){
            if(mp.count(target-price[i])){
                res[0]=price[i];
                res[1]=target-price[i];
                break;
            }
            else{
                mp[price[i]]=(target-price[i]);
            }
         }
         return res;
    }
};

左右指针：

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
         sort(price.begin(),price.end());
         vector<int> res(2,-1);
         int left,right,flag=1;
         left=0;
         right=price.size()-1;
         while(flag){
            if(price[left]+price[right]==target){
                flag=0;
                res[0]=price[left];
                res[1]=price[right];
                break;
            }
            else if(price[left]+price[right]>target){
                right--;
            }
            else{
                left++;
            }
         }
         return res;
    }
};

2.二叉树中和为目标值的路径

学习大佬的代码，每次都不由得感慨人家的脑子是真好使啊！

class Solution {
public:
    vector<vector<int>> pathTarget(TreeNode* root, int target) {
        find(root,target);
        return res;
    }
private:
    vector<vector<int>> res;
    vector<int> path;
    void find(TreeNode* ro,int tar){
       if(ro==nullptr)return;//已经找到了，并且到达了叶子节点的下一位(null)
       path.push_back(ro->val);
       tar=tar-ro->val;
       if(tar==0 && ro->left==nullptr && ro->right==nullptr)//已经访问到了叶子节点，并且满足路径上累加和为target
       {
          res.push_back(path);
       }
       find(ro->left,tar);
       find(ro->right,tar);
       path.pop_back();//回溯上一个节点，删去本节点
    }
};

3.把二叉搜索树转为累加树

和上一题的思路类似。

class Solution {
public:
    TreeNode* convertBST(TreeNode* root) {
        int summ=0;
        sumtree(root,summ);
        return root;
    }
private:
     void sumtree(TreeNode* rot,int& res){
        if(rot==nullptr)return;//已经到根节点的下一位了无需继续
        //二叉搜索树，右子树上的值均大于左子数上的值，只要累加右子树上的值即可
        sumtree(rot->right,res);//先访问右子树
        res=res+rot->val;//把右子树上的值累加起来
        rot->val=res;//更新该点的值
        sumtree(rot->left,res);//再访问左子树
     }
};

4.判断是否为平衡二叉树

官方题解，自觉写的没错，最后才发现是任意节点的左右子数的深度差而不是任意节点深度差，服了。。。

class Solution {
public:
     bool isBalanced(TreeNode* root) {
         if(root==NULL){
            return true;//已经访问到根节点了
         }
         else{
            return (abs(depth(root->left)-depth(root->right))<=1&&isBalanced(root->left)&&isBalanced(root->right));
         }
     }
     int depth(TreeNode* root){
        if(root==NULL)return 0;//根节点深度为0；
        else{
            return max(depth(root->left),depth(root->right))+1;
        }
     }
};

5.和为K的子数组

最开始没考虑到存在负数的情况，导致设置while循环条件时设置了>0，最终结果通过了但是耗时长。

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int res = 0;
        if ((nums.size() == 1 && nums[0] > k)||nums.size()==0) {
            return res;
        }
        for (int i = 0; i < nums.size(); i++) {
            int temp = k;
            int j = i;
            while (j < nums.size()) {
                temp -= nums[j];
                j++;
                if (temp == 0) {
                    res++;
                    continue;
                }
            }
        }
        return res;
    }
};