Question

我需要编写一个针对随机访问迭代器（RAI）高度优化的Rotate的C ++实现。输入迭代器的分布是未知的。

我之前看过两种常见的轮换算法：

只需反转范围。这导致每个元素2次写入

template<RAI>
RAI rotate(RAI _first, RAI _middle, RAI _last) {
  std::reverse(_first, _middle);
  std::reverse(_middle, _last);
  std::reverse(_first, last);
  return _first + _last - _middle;
}

让n=_last-_first和d=_middle-_first

template<RAI>
RAI rotate(_first, _middle, _last) { 
    int GCD= gcd(d, n); 
    for (int i = 0; i < GCD; i++) { 
        int temp = *(first+i); 
        int j = i; 
        for (;;) { 
            int k = j + d; 
            if (k >= n) 
                k = k - n; 
            if (k == i) 
                break; 
            *(first+j) = std::move(*(first+k)); 
            j = k; 
        } 
        *(first+j) = temp; 
    } 
}

奇怪的是，GCC implementation包含GCD的代码，甚至说它用于帮助旋转算法，但是实际的旋转算法甚至从不使用它。 GCC旋转算法如下：

template<typename _RandomAccessIterator>
_RandomAccessIterator
__rotate(_RandomAccessIterator __first,
     _RandomAccessIterator __middle,
     _RandomAccessIterator __last,
     random_access_iterator_tag)
{
  // concept requirements
  __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
              _RandomAccessIterator>)

  typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
  typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

  _Distance __n = __last   - __first;
  _Distance __k = __middle - __first;

  if (__k == __n - __k)
  {
    std::swap_ranges(__first, __middle, __middle);
    return __middle;
  }

  _RandomAccessIterator __p = __first;
  _RandomAccessIterator __ret = __first + (__last - __middle);

  for (;;)
  {
    if (__k < __n - __k)
    {
      if (__k == 1)
      {
        _ValueType __t = _GLIBCXX_MOVE(*__p);
        _GLIBCXX_MOVE3(__p + 1, __p + __n, __p);
        *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
        return __ret;
      }
    _RandomAccessIterator __q = __p + __k;
    for (_Distance __i = 0; __i < __n - __k; ++ __i)
    {
      std::iter_swap(__p, __q);
      ++__p;
      ++__q;
    }
    __n %= __k;
    if (__n == 0)
      return __ret;
    std::swap(__n, __k);
    __k = __n - __k;
  } else  {
      __k = __n - __k;
      if (__k == 1)
      {
        _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
        _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n);
        *__p = _GLIBCXX_MOVE(__t);
        return __ret;
      }
      _RandomAccessIterator __q = __p + __n;
      __p = __q - __k;
      for (_Distance __i = 0; __i < __n - __k; ++ __i)
      {
        --__p;
        --__q;
        std::iter_swap(__p, __q);
      }
      __n %= __k;
      if (__n == 0)
        return __ret;
      std::swap(__n, __k);
    }
  }
}

我不明白为什么这比我上面显示的前两个要快？考虑以下部分：

_RandomAccessIterator __q = __p + __k;
for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  std::iter_swap(__p, __q);
  ++__p;
  ++__q;
}

如果k小，那么在该循环中，几乎每个位置都将交换两次，并且仅在外部while循环中进行一次迭代。那么，与上面的算法（每个位置最多只能执行2个操作）相比，这种算法的速度如何？

Answer 1

子列表反转实现对每个元素进行一次交换。 GCC的实现最多每个元素进行一次交换，但由于它有多个提前终止条件，因此交换可能更少。

例如，在特定的循环中，您指向n-k进行交换，但是此后n被还原为k，因此在下一次迭代之前，它满足“至多每个元素一次交换”规则。但是，如果事实证明n被k整除，则该工作已经完成并且可以退出。

GCC轮换实施

1 个答案: