稳定排序
待排序的记录序列中可能存在两个或两个以上关键字相等的记录。排序前的序列中Ri领先于Rj（即i＜j）.若在排序后的序列中Ri仍然领先于Rj，则称所用的方法是稳定的。比如int数组[1,1,1,6,4]中a[0],a[1],a[2]的值相等，在排序时不改变其序列，则称所用的方法是稳定的。
例子：
int main() {vector<string> v1 = { "double","int","for","float","if", };vector<string> v2 = { "double","int","for","float","if", };//sort(v1.begin(), v1.end());stable_sort(v1.begin(), v1.end(), [](const string& s1, const string& s2)->bool {return s1.size() < s2.size();});//alg.sort(v2.begin(), v2.end());alg.stable_sort(v2.begin(), v2.end(), [](const string& s1, const string& s2)->bool {return s1.size() < s2.size();});_pn(v1);_pn(v2);return 0;
}输出：
实现代码：
/// <summary>
/// 稳定排序：
/// 在排序时不改变其序列
/// 待排序的记录序列中可能存在两个或两个以上关键字相等的记录。
/// 排序前的序列中Ri领先于Rj（即i＜j）.若在排序后的序列中Ri仍然领先于Rj，
/// 则称所用的方法是稳定的。比如int数组 [1, 1, 1, 6, 4] 中 a[0], a[1], a[2]的
/// 值相等，在排序时不改变其序列，则称所用的方法是稳定的。
///
/// stable_sort 是 C++ 标准库中的一个算法，用于对指定范围内的元素进行排序。
/// 与 std::sort 不同，stable_sort 保证了相等元素的相对顺序不变，即稳定排序。
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <typeparam name="ComparingFunctions"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <param name="f"></param>
/// 创建时间： 2024-10-11 最后一修改时间：2024-10-11（已测试）
template<typename IteratorClass, typename ComparingFunctions>
void stable_sort(IteratorClass itBegin, IteratorClass itEnd, ComparingFunctions f) {IteratorClass itSwap = itBegin;while (itBegin != itEnd) {auto itMin = Min(itBegin, itEnd, f);//判断下一个元素是否与itBegin相等，如果相等，则itBegin指向下一个元素auto itSwap = itBegin + 1;while (itBegin != itEnd && itBegin != itMin) { //itBegin和itswap相等if ( f(*itBegin, *itSwap) == false && f(*itSwap, *itBegin) == false){ itSwap++; }else {//abc1,abc2,abc3 c a (先保存a元素，然后 [abc1,abc3,abc3,c] 后移一位//a,abc1 abc2,abc3,c auto tValue = *itMin; //保存数据m.MoveBackIter(itBegin, itMin, 1);*itBegin = tValue;//itBegin = itSwap; 错误，不能用这句，还是在itBegin之前插入 //std::cout << "*itBegin=" << (*itBegin) << "\n";//std::cout << "*itBegin=" << (*(itBegin+1)) << "\n";break;} } itBegin++;}
}多规则排序
int main() {vector<string> v = {"for","a1","a2","a3","a5","a6","a4","int","a0","duble"};//先按长度排序，再按 string 对象内置 < 运算符排序alg.sort_two_rules(v.begin(), v.end(), [](const string& s1, const string& s2)->bool {return s1.size() < s2.size();});_pn(v);}输出结果
实现代码：
/// <summary>
///
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <typeparam name="ComparingFunctions"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <param name="f"></param>
/// 创建时间： 2024-10-12 最后一修改时间：2024-10-12（已测试）
template<typename IteratorClass, typename ComparingFunctions>
void sort_two_rules(IteratorClass itBegin, IteratorClass itEnd, ComparingFunctions f) {while (itBegin != itEnd) {Swap(itBegin, min_two_rules(itBegin, itEnd, f)); //与std::sort相同，从小到大itBegin++;}
}/// <summary>
/// 按两种规则查找最小值：
/// 先按规则 f 比较，如果f没有比较成功（实际上两个对象按f
/// 规则比较是等于），则按对象本身自带的运算符 < 来比较。
/// 例子：
///
/// vector<string> v = { "abc6","abc1","abc3","abc2" };
///
/// auto s1 = alg.Min(v.begin(), v.end(), [](const string& s1, const string& s2)->bool {
/// return s1.size() < s2.size();
/// });
///
///
/// _pn(*s1);
/// auto s2 = alg.min_two_rules(v.begin(), v.end(), [](const string& s1, const string& s2)->bool {
/// return s1.size() < s2.size();
/// });
///
/// _pn(*s2);
///
/// 输出：
/// s1 = abc6
/// s2 = "abc1"
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <typeparam name="ComparingFunctions"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <param name="f"></param>
/// <returns></returns>
/// 创建时间： 2024-10-11 最后一修改时间：2024-10-11
template<typename IteratorClass, typename ComparingFunctions>
IteratorClass min_two_rules(IteratorClass itBegin, IteratorClass itEnd, ComparingFunctions f) {assert(itBegin != itEnd);IteratorClass result = itBegin;itBegin++;while (itBegin != itEnd) {if (f(*itBegin, *result)) // 小于 if *itbegin < *resultresult = itBegin;else if (f(*result, *itBegin)) { //大小//什么都不做}else { //即不是大于，又不是小于，再按对象运算符规则if(*itBegin < *result)result = itBegin;}++itBegin;}return result;
}