STL之基础算法(四)

template <class ForwardIterator1, class ForwardIterator2>
inline ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
                               ForwardIterator2 first2, ForwardIterator2 last2)
{
  return __search(first1, last1, first2, last2, distance_type(first1),
                  distance_type(first2));
}

//没看源码之前，还以为会有什么复杂的算法，结果也只是遍历
//如果没有假设(比如有序什么的)，STL里的许多算法实现也是挺普通的做法
template <class ForwardIterator1, class ForwardIterator2, class Distance1,
          class Distance2>
ForwardIterator1 __search(ForwardIterator1 first1, ForwardIterator1 last1,
                          ForwardIterator2 first2, ForwardIterator2 last2,
                          Distance1*, Distance2*) {
  Distance1 d1 = 0;
  distance(first1, last1, d1);
  Distance2 d2 = 0;
  distance(first2, last2, d2);


  if (d1 < d2) return last1; //如果第二序列大于第一序列，不可能成为其子序列


  ForwardIterator1 current1 = first1;
  ForwardIterator2 current2 = first2;


  while (current2 != last2) // 我的第一感觉是遍历第一序列，结果人家是遍历第二序列。不过感觉代码写起来应该差不多
    if (*current1 == *current2) { // 如果这个元素相同，调整，以便比对下一个元素
      ++current1;
      ++current2;
    }
    else { //如果这个元素不同
      if (d1 == d2) //如果两序列一样长了，就不可能成功了
        return last1;
      else { //如果两序列不一样长，调整序列标兵
        current1 = ++first1;
        current2 = first2;
        --d1; //已经排序了序列一的一个元素，所以序列一的长度要减 1
      }
    }
  return first1;
}


示例： 
const char S1[] = "Hello, world!";
const char S2[] = "world";
const int N1 = sizeof(S1) - 1;
const int N2 = sizeof(S2) - 1;


const char* p = search(S1, S1 + N1, S2, S2 + N2);
printf("Found subsequence \"%s\" at character %d of sequence \"%s\".\n",
	 S2, p - S1, S1);	

描述：在序列一[first1, last1) 所涵盖的区间中，查找序列二[first2, last2) 的首次出现点。 
思路： 
1.遍历序列二 
2.如果两序列的当前元素一样，都前进 1 
3.否则序列二的迭代器重新指向开始元素，序列一前进 1 ，序列一的长度减 1 
复杂度： 
最坏情况是平方: 最多 (last1 - first1) * (last2 - first2) 次比较。 但最坏情况很少出现。 

平均情况下是线性复杂度 

template <class ForwardIterator, class Integer, class T>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                         Integer count, const T& value) {
  if (count <= 0)
    return first;
  else {
    first = find(first, last, value); // 首先找出 value 第一次出现点
    while (first != last) { // 这里的条件写成 last - first < n 是不是好些？
      Integer n = count - 1; // value 还应该出现 n 次
      ForwardIterator i = first;
      ++i;
      while (i != last && n != 0 && *i == value) {
        ++i;
        --n;
      }
      if (n == 0) // 找到了
        return first;
      else  // 没找到，重新从 i 开始找
        first = find(i, last, value);
    }
    return last;
  }
}