leetcode0912

1、二叉搜索树的最小绝对值差

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

输入：

   1
    \
     3
    /
   2

输出：
1

解释：
最小绝对差为 1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。

 int getMinimumDifference(TreeNode* root) {
    //二叉查找树中，中间节点的值一定是其左右节点的中间数，因此最小差应该在中间节点与左右节点之间
    //中序遍历二叉查找树，每次比较当前节点与前一节点差值的绝对值与目前resul中保存的最小值的大小，将较小的保存在result中
    int res=INT_MAX,last=INT_MAX;
    Execute(root,last,res);
    return res;
    }
    void Execute(TreeNode* root, int& last, int& res){
        if(root==nullptr){
            return;
        }
        Execute(root->left,last,res);
        res=min(res,abs(root->val-last));
        if(res==0)return;
        last=root->val;
        Execute(root->right,last,res);
    }

2、数组中的K-diff数对

给定一个整数数组和一个整数 k, 你需要在数组里找到不同的 k-diff 数对。这里将 k-diff 数对定义为一个整数对 (i, j), 其中 i 和 j 都是数组中的数字，且两数之差的绝对值是 k。

示例 1:

输入: [3, 1, 4, 1, 5], k = 2
输出: 2
解释: 数组中有两个 2-diff 数对, (1, 3) 和 (3, 5)。
尽管数组中有两个1，但我们只应返回不同的数对的数量。

 int findPairs(vector<int>& nums, int k) {
        int sum=0;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();++i){
            if((i!=0&&nums[i]!=nums[i-1])||(i==0)){
            for(int j=i+1;j<nums.size();++j){
                if((nums[j]-nums[i])>k)
                    break;
                else if((nums[j]-nums[i])==k){
                    ++sum;
                    break;
                }
              }
            }
        }
        return sum;
    }

3、把二叉搜索树累转换为累加树

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:
              5
            /   \
           2     13

输出: 转换为累加树:
             18
            /   \
          20     13

TreeNode* convertBST(TreeNode* root) {
        int num=0;
     Excute(root,num);
     return root;
    }
    void Excute(TreeNode* root,int& num){
        if(root!=nullptr){
            Excute(root->right,num);
            root->val=root->val+num;
            num=root->val;
            Excute(root->left,num);
        }
        
    }

4、反转字符串

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。

    如果剩余字符少于 k 个，则将剩余字符全部反转。
    如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

 

示例:

输入: s = "abcdefg", k = 2
输出: "bacdfeg"

string reverseStr(string s, int k) {
     int i=k;
     for(;i<s.size();i+=2*k){
         reverse(s.begin()+i-k,s.begin()+i);
     }
     reverse(s.begin()+(i-k),s.end());
     return s;
    }

5、二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5    

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

int dfs(TreeNode* root){
       if(!root){
           return 0;
       }
       int left=dfs(root->left);
       int right=dfs(root->right);
       ans=max(ans,left+right);
       return max(left,right)+1;

    }
    int diameterOfBinaryTree(TreeNode* root) {
        ans=0;
        dfs(root);
        return ans;
    }
    private:
    int ans;