【C++】面经101,合并区间,合并两个有序的数,判断是否为回文字符串,最小覆盖子串,反转字符串

本文链接：https://blog.csdn.net/weixin_71138261/article/details/129779847

1.合并区间

之前讲过一个C版本，但是很不爽，这次的思路还是和原来一样，首先按照区间的起始元素排序

然后比较前一个区间的最后一个元素是不是比后一个区间的起始元素大，即[1,3] [2,3] 2<3

这时候需要合并区间

否则，说明当前区间和后一个区间不构成覆盖，直接写到ans

不要忘了写排序的比较方式

 static bool comp(const Interval& a,const Interval& b)
     {
        return a.start<b.start;
     }
    vector<Interval> merge(vector<Interval> &intervals) {
        sort(intervals.begin(),intervals.end(),comp);
        vector<Interval> ans;
        if(intervals.empty()) return ans;
        Interval tmp=intervals[0];
        for(int i=1;i<intervals.size();i++)
        {
            Interval a=intervals[i];
            if(tmp.end>=a.start)
            //需要合并
            tmp.end=max(tmp.end,a.end);
            else
             {
                ans.push_back(tmp);
                tmp=a;
             }            
        }  
        ans.push_back(tmp);
        return ans;
    }

2. 合并两个有序的数组

从后往前判断，把较大的元素放到A的末尾，然后把对应数组下标往前挪一个，如果有一个区间遍历结束，但是另一个还有元素，直接把剩余元素倒过去

  void merge(int A[], int m, int B[], int n) {
        int newsize = m + n - 1;
        while (m && n) {
            if (A[m - 1] > B[n - 1]) {
                A[newsize] = A[m - 1];
                m--;
                newsize--;
            } else {
                A[newsize] = B[n - 1];
                n--;
                newsize--;
            }
        }
        while (m) {
            //说明只有A还有元素
            A[newsize] = A[m - 1];
            m--;
            newsize--;
        }
        while (n) {

            A[newsize] = B[n - 1];
            n--;
            newsize--;
        }
    }

3.判断是否为回文字符串

双指针，从前往后和从后往前，只要有一个字符不一样就是false

 bool judge(string str) {
        // write code here
        if(str.empty()) return true;
        int begin=0,end=str.size()-1;
        while(begin<=end)
        {
            if(str[begin] != str[end])
            return false;
            begin++;end--;
        }
        return true;
    }

4.最小覆盖子串

要找到最小的覆盖子串，需要两个map，hs和ht

遍历S字符串，假设窗口[i,j] 那么hs记录当前字符在窗口中出现的次数

ht记录T字符串中每个字符出现的次数

首先肯定是把ht建立好（只需要遍历T）

然后建立hs

设置cnt表示[i,j]窗口中有效字符的个数（窗口内的字符也出现在T）

开始遍历S

string minWindow(string s, string t) {
    unordered_map<char, int> hs, ht;
    for (auto c : t) ht[c] ++;
    string res;
    int cnt = 0;
    //区间[i,j]
    for (int i = 0, j = 0; i < s.size(); i++) {
        hs[s[i]] ++; //(当前字符在窗口中的次数++）
     
        if (hs[s[i]] <= ht[s[i]]) cnt++;   // 如果当前字符是有效字符，那么窗口内有效字符个数 + 1

        
        while (hs[s[j]] > ht[s[j]]) hs[s[j++]] --; //扩大窗口，找到一个j，使得窗口中恰好有T
      
        if (cnt == t.size()) {  // 如果当前有效窗口个数等于 t 中的字符个数，尝试更新答案
            if (res.empty() || i - j + 1 < res.size()) //如果答案是空或者[i,j]区间的长度<答案的长度（说明找到更小的子串）
                res = s.substr(j, i - j + 1); //把这个窗口写道res
        }
    }
    return res;
}

5.反转字符串

直接对半分开，挨个旋转

    string solve(string str) {
        // write code here
       for(int i=0;i<str.size()/2;i++)
       swap(str[i],str[str.size()-i-1]);

       return str;
    }