STL排序算法

STL排序算法使用

<span style="font-size:18px;">//局部排序 与整体排序算法
/*
partical_sort(使用heap_sort)
partition(轴值采用三点中值)
stable_partition
stable_sort
nth_element(采用partation的思想)
*/</span>

<span style="font-size:18px;">
/*
sort(f,l,Com) 接收随机迭代器
数据量大时采用Quick_sort 分段递归排序 一旦分段的数据量小于某个门槛（16）
则使用Insert sort，如果递归深度过深 会在子区间使用partical_sort(heapsort)
Quick_sort 中的partition 的轴值 使用了三点中值 减小恶化几率
插入排序需要判断是否存在逆序对 和是否越界 但是STL的做了特殊处理 
将每次的尾部元素 与first比较 将最小的元素放在first位置作为哨兵
插入排序在数据量较少 接近有序时 表现良好(冒泡 需要交换 元素 移动过多)
下面是摘抄的源码 这是整个算法执行的核心 小的优化将会产生质的飞跃</span>

<span style="font-size:18px;">
template <class RandomAccessIterator, class T>
void unguarded_linear_insert(RandomAccessIterator last, T value) {
RandomAccessIterator next = last;
--next;
for (; value < *next; --next) {
*last = *next;
last = next;
}
*last = value;
}

// 将 last 处的元素插到[first, last)的有序区间

template <class RandomAccessIterator>
void linear_insert(RandomAccessIterator first, RandomAccessIterator last) {
	Type value = *last;
	if (value < *first) { // 若尾比头小，就将整个区间一次性向后移动一个位置  
		copy_backward(first, last, last + 1);
		*first = value;
	}
	else {
		unguarded_linear_insert(last, value);
	}
}

我单步跟踪 进入sort函数 发现 函数开始就会判断 使用 快排、heap还是insert sort
STL内部有一个_lg函数 返回 2^k<=n的最大k值 通过它来决定 递归层次 还有一个参数 
depath_limit 在快排递归过程中 如果该值 变为0  则改为partical_sort
SGI的sort 博大精深  比RW版本(完全使用快排)好很多 这也是它排序效率高的原因之一
*/
#include<iostream>
#include<string>
#include<iterator>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;

template<class T>
void Display(const vector<T>& vec)
{
	copy(vec.begin(), vec.end(), ostream_iterator<T>(cout, " "));
	puts("");
}

template<class T>
class Compare
{
public:
	//重载()时  函数会根据 需要使用的参数个数来选择调用哪一个函数
	bool operator()(const T& val1, const T& val2)
	{
		return vla1 < val2;
	}
	bool operator()(const T& val)
	{
		return 0 == val%m_val;
	}
	Compare(const T& val)
	{
		m_val = val;
	}
private:
	T m_val;
};

int Com(const void* a, const void* b)
{
	if (*(int*)a < *(int*)b)
	{
		//这样写 是递增顺序 
		return -1;
	}
		return 1;
}

int main(void)
{
	int a[] = {8,9,-7,12,4,36,120,5,1,2,3};
	int len = sizeof(a) / sizeof(a[0]);
	vector<int> vec(a,a+len);
	Display<int>(vec);
	partial_sort(vec.begin(),vec.begin()+7, vec.end()/*,greater<int>()*/);
	Display<int>(vec);
	//-7 1 2 3 4 5 8 120 36 12 9 
	//前7个数 为最小7个 （默认最小n个 递增）
	
	//以下函数将偶数放在奇数前边
	//partition(vec.begin(),vec.end(), Compare<int>(2));
	Display<int>(vec);
	//12 36 2 120 4 8 5 3 1 -7 9
	stable_partition(vec.begin(), vec.end(), Compare<int>(2));
	//2 4 8 120 36 12 -7 1 3 5 9
	Display<int>(vec);
	//sort(vec.begin(),vec.end());
	nth_element(vec.begin(), vec.begin() + 7,vec.end());
	//这个函数 很有意思 时间复杂度低 可以看一下源码
	//第7个元素的位置变为与排序后位置相同 
	Display<int>(vec);
	stable_sort(vec.begin(),vec.end());
	int array[] = {2,3,4,8,9,-7,54,1};
	qsort(array,sizeof(array)/sizeof(array[0]),sizeof(array[0]),Com);
	copy(array,array+sizeof(array)/sizeof(array[0]),ostream_iterator<int>(cout," "));
	//内部使用归并排序

	return 0;
}</span>