• 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();
        }
    }
  • 相关阅读:
    记录一下自己的洛谷的题解
    初学java 学生管理系统——v0002版本
    初学java 学生管理系统——v0001版本
    Redis守护进程作用+数据类型
    java实现发送短信验证码
    Kali入侵入门版笔记!!!
    2020实现ssh公网外联和外网远程穿透以及内网穿透防火墙
    监控键盘和鼠标记录内容和截屏,更新版本2.0,增加了Linux服务端!!!
    Git管理软件开发项目入门版
    2020年Windows下开机自动执行最强
  • 原文地址:https://www.cnblogs.com/creature-lurk/p/15255494.html
Copyright © 2020-2023  润新知