【STL源码剖析读书笔记】【第6章】算法之rotate算法

1、  rorate函数将[first, middle)内的元素和[middle, last)内的元素互换，middle所指元素成为容器的第一个元素。rotate函数为了追求效率，根据迭代器的移动能力将其分三种情况进行讨论：分别为ForwardIterator,  BidirectionalIterator和RandomInterator。

2、  ForwardIterator版本

// rotate 的 forward iterator 版
template <class ForwardIterator, class Distance>
void __rotate(ForwardIterator first, ForwardIterator middle,
	ForwardIterator last, Distance*, forward_iterator_tag) {
	for (ForwardIterator i = middle;;) {
		iter_swap(first, i);	// 前后段元素一一交换
		++first;				// 双双前进1
		++i;
		// 以下判断是前段[first, middle)先结束还是后段[middle,last)先结束
		if (first == middle) {		// 前段先结束
			if (i == last) return; 	// 如果后段也结束了，整个就结束了
			middle = i;				// 否则进行调整，之后再进行迭代
		}
		else if (i == last)	     // 后段先结束
			i = middle;			// 调整，之后再进行迭代
	}
}

此版本是指针翻转法，下图说明了运算过程：

3、  BidirectionalIterator版本

 // 分派函数（dispatch function）
template <class BidirectionalIterator>
inline void reverse(BidirectionalIterator first, BidirectionalIterator last) {
	__reverse(first, last, iterator_category(first));
}
// reverse 的 bidirectional iterator 版
template <class BidirectionalIterator>
void __reverse(BidirectionalIterator first, BidirectionalIterator last,
	bidirectional_iterator_tag) {
	while (true)
		if (first == last || first == --last)   //剩余需交换元素个数小于2
			return;
		else
			iter_swap(first++, last);             //iter_swap()函数为交换迭代器所指元素的值
}
// rotate 的 bidirectional iterator 版
template <class BidirectionalIterator, class Distance>
void __rotate(BidirectionalIterator first, BidirectionalIterator middle,
	BidirectionalIterator last, Distance*,
	bidirectional_iterator_tag) {
	reverse(first, middle);
	reverse(middle, last);
	reverse(first, last);
}

此版本是三步翻转法，下图说明了运算过程：

4、  RandomInterator版本

 // 最大公因数，利用辗转相除法
// __gcd() 应用于 __rotate() 的 random access iterator 版
template <class EuclideanRingElement>
EuclideanRingElement __gcd(EuclideanRingElement m, EuclideanRingElement n)
{
	while (n != 0) {          
		EuclideanRingElement t = m % n;
		m = n;
		n = t;
	}
	return m;
}
template <class RandomAccessIterator, class Distance, class T>
void __rotate_cycle(RandomAccessIterator first, RandomAccessIterator last,
	RandomAccessIterator initial, Distance shift, T*) {
	T value = *initial;                 //记下链首元素的值，接下来链首元素“出列”留下一个“槽”
	RandomAccessIterator ptr1 = initial;
	RandomAccessIterator ptr2 = ptr1 + shift;//指向链中下一元素
	while (ptr2 != initial) {
		*ptr1 = *ptr2;
		ptr1 = ptr2;                  //ptr1指向“槽”的位置
		if (last - ptr2 > shift)   //还没有到达最后一个元素
			ptr2 += shift;
		else
			ptr2 = first + (shift - (last - ptr2));
	}
	*ptr1 = value;
}
// rotate 的 random access iterator 版
template <class RandomAccessIterator, class Distance>
void __rotate(RandomAccessIterator first, RandomAccessIterator middle,
	RandomAccessIterator last, Distance*,
	random_access_iterator_tag) {
	// 以下迭代器的相减操作只适用于RandomAccessIterator
	// 取全长和前段长度的最大公因数
	Distance n = __gcd(last - first, middle - first);
	// 链数为gcd（m,n） 。链中元素个数为n/gcd(m,n)。
	while (n--)  //为了书写方便，先从最后一条链开始循环                                               
		__rotate_cycle(first, last, first + n, middle - first,
		value_type(first));
}

此版本是循环移位法，此法利用了辗转相除法和数论中的一个定理：若有两个正整数m、n，且gcd(m,n)=d，那么序列{m%n,2m%n, 3m%n,..., nm%n}一定是{0, d, 2d,..., n-d}的某个排列并重复出现d次，其中%号代表求模操作。比如若m=6,n=8，d=gcd(m,n)=2，那么{6%8, 12%8,18%8,..., 48%8}即为{0，2，4，6}的某个排列并重复两次，事实上也正是{6，4，2，0, 6，4，2, 0}。特别地，若m、n互素，d=1，那么序列{m%n,2m%n,3m%n,...,(n-1)m%n}实际上就是{1, 2,3,..., n-1}的某个排列。

了解这个定理后，此版本也就容易看懂了。每一次__rotate_cycle只能将t/n的元素正确的左移，其中t为容器内元素个数，n为last-first和middle-first的最大公约数，而这些被移动的元素是以n为等间距的，所以循环n次，并分别以串的前n个元素为起点进行__rotate_cycle操作，就能保证将所有的元素都移动到正确的位置上。

参考：http://blog.csdn.net/v_JULY_v/article/details/6322882

           http://www.cnblogs.com/atyuwen/archive/2009/11/08/rotate.html