C++第12课 STL算法 （二）

1.排序算法

sort: 基本排序

stable_sort: 相对排序

merge: 归并排序

inplace_merge: 改变原容器的归并

nth_element: 关键字排序

partition： 分类处理，满足谓词，放在左边，不满足放在右边

stable_partition: 保持原容器的相对顺序做的分类处理

partial_sort: 局部排序

partial_sort_copy: 局部排序的结果，放到新容器中

random_shuffle: 乱序

reverse:反转

reverse_copy: 反转放到新容器中

rotate: 移动元素到末位
rotate_copy: 把元素放到新的新的容器中

**修改类算法**

copy: 拷贝

copy_ backward:逆向拷贝

remove: 删除

remove_copy: 删除后结果放到新容器中

remove_if: 条件删除

remove_copy_if: 条件删除后的结果存储到新容器

replace :替换

replace_copy: 替换的结果放到新容器

replace_if: 条件替换

replace_copy_if:条件替换后的结果放到新的容器

iter_wap: 迭代器交换

swap: 交换容器的值

swap_range: 区间交换

unique: 不影响原容器

unique_copy: 去重后的结果放到新容器

**算术类的算法**

accumulate: 求和算法

partial_sum: 逐步求和

iner_product: 求积运算(矩阵的乘法)

adjacent_difference: 求差运算

**关系类的算法**

equal: 相等

includes: 包含的关系

max: 两者最大值

max_elment: 容器最大值

min: 两者最小值

min_elment: 容器最小值

mismatch: 找两个容器中第一次不同的位置

**集合算法**

set_union: 求并集

set_intersection: 求交集

set_difference: 求差集

set_symmetric_difference: 求对称差集 并集减去交集

**堆算法**

make_heap:产生堆

sort_heap: 堆排序

push_heap: 入堆

pop_heap: 出堆: 把要出堆的元素放到元素后面， 真正出堆要自己手动删除尾部元素

template <class T>
void printData(T data) 
{
    for (auto v : data) 
    {
        cout << v << "	";
    }
    cout << endl;
}
//1.基本排序
void testSort() 
{
    //sort基本排序
    //1.1 排序算法
    int array[] = { 1,3,5,7,9,2,4,6,8,0 };
    vector<int> vec;
    sort(array, array + 10);
    vec.assign(array, array + 10);
    printData(vec);
    //1.2 排序准则
    sort(vec.begin(), vec.end(), less<int>());
    printData(vec);
    sort(vec.begin(), vec.end(), greater<int>());
    printData(vec);
    //1.3 list容器 要用内置的排序
    list<int> listData;
    listData.assign(vec.begin(), vec.end());
    listData.sort();
    printData(listData);
    listData.sort(greater<int>());
    printData(listData);
}
//2.相对排序
bool comp_as_int(double a, double b) 
{
    return int(a) < int(b);
}
void testStableSort() 
{
    //14个排序以及一些通用算法
    double num[] = { 3.14,1.41,2.72,4.60,4.7,1.3,1.6,2.5 };
    vector<double> dNum;
    dNum.assign(num, num + 8);
    stable_sort(dNum.begin(), dNum.end(), comp_as_int);
    printData(dNum);
}
void testSortAlogrithm()
{
    testSort();
    testStableSort();
    //3.归并排序
    int array[] = { 1,3,5,7,9,2,4,6,8,10 };
    vector<int> result(10);
    merge(array, array + 5, array + 5, array + 10, result.begin());
    printData(result);
    //4.改变容器归并
    inplace_merge(array, array + 5, array + 10);
    for (int i = 0; i < 10; i++)
    {
        cout << array[i] << "	";
    }
    cout << endl;
    //5.关键字排序
    vector<int> element = { 1,3,5,7,9,2,4,6,8,10 };
    nth_element(element.begin(), element.begin() + 5, element.end());
    printData(element);
    //6.分类
    vector<int> partitionData = { 1,3,5,7,9,2,4,6,8,10 };
    partition(partitionData.begin(), partitionData.end(), [](int data) {return data < 6; });
    printData(partitionData);
    //7.分类处理
    double num[] = { 3.14,1.41,2.72,4.60,4.7,1.3,1.6,2.5 };
    vector<double> dNum;
    dNum.assign(num, num + 8);
    stable_partition(dNum.begin(), dNum.end(), bind(comp_as_int, placeholders::_1, 2.0));
    printData(dNum);
    //8.局部排序:排序后的结果的3个元素
    vector<int> number = { 22,7,93,40,19,45,67,5,0,7 };
    partial_sort(number.begin(), number.begin() + 3, number.end());
    printData(number);
    //9.结果放到新容器中局部排序
    vector<int> result2(5);
    partial_sort_copy(number.begin(), number.begin() + 5, result2.begin(), result2.end());
    printData(result2);
    //10.乱序
    vector<int> mem = { 1,2,3,4,5,6,7,8,9,10 };
    random_shuffle(mem.begin(), mem.end());
    printData(mem);
    //11.反转
    reverse(mem.begin(), mem.end());
    printData(mem);
    //12.反转结果存储到新容器
    vector<int> result3(10);
    reverse_copy(mem.begin(), mem.end(), result3.begin());
    printData(result3);
    //13.移动元素到尾部
    rotate(result3.begin(), result3.begin() + 3, result3.end());
    printData(result3);
    //14.拷贝元素到尾部的结果存储到 。另一个容器
    vector<int> rotateData(result3.size());
    rotate_copy(result3.begin(), result3.begin() + 3, result3.end(),rotateData.begin());
    printData(rotateData);
}
void testHeapAlogrithm() 
{
    vector<int> data = { 12,3,55,33,67 };
    make_heap(data.begin(), data.end());   //默认大顶堆
    printData(data);
    make_heap(data.begin(), data.end(), less<int>());    //大顶堆
    printData(data);
    make_heap(data.begin(), data.end(), greater<int>());    //小顶堆
    printData(data);

    //堆排序要和当前堆 排序准则一致,默认的准则是less<int>()
    sort_heap(data.begin(), data.end(), greater<int>());
    printData(data);

    make_heap(data.begin(), data.end());
    printData(data);
    //入堆：
    data.push_back(100);
    push_heap(data.begin(), data.end()); //向上渗透
    printData(data);
    //出堆
    while (!data.empty()) 
    {
        pop_heap(data.begin(), data.end());    //向下渗透
        cout << data.back() << "	";
        data.pop_back();
    }
}