C++11标准模板(STL)- 算法(std::unique)

定义于头文件 <algorithm>

算法库提供大量用途的函数(例如查找、排序、计数、操作),它们在元素范围上操作。注意范围定义为 [first, last) ,其中 last 指代要查询或修改的最后元素的后一个元素。

移除范围内的连续重复元素

std::unique

template< class ForwardIt >
ForwardIt unique( ForwardIt first, ForwardIt last );

(1)(C++20 前)

template< class ForwardIt >
constexpr ForwardIt unique( ForwardIt first, ForwardIt last );

(C++20 起)

template< class ExecutionPolicy, class ForwardIt >
ForwardIt unique( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );

(2)(C++17 起)

template< class ForwardIt, class BinaryPredicate >
ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPredicate p );

(3)(C++20 前)

template< class ForwardIt, class BinaryPredicate >
constexpr ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPredicate p );

(C++20 起)

template< class ExecutionPolicy, class ForwardIt, class BinaryPredicate >
ForwardIt unique( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, BinaryPredicate p );

(4)(C++17 起)

从来自范围 [first, last) 的相继等价元素组消除首元素外的元素,并返回范围的新逻辑结尾的尾后迭代器。

通过用覆写要被擦除的元素的方式迁移范围中的元素进行移除。保持剩余元素的相对顺序,且不更改容器的物理大小。指向范围的新逻辑结尾和物理结尾之间元素的迭代器仍然可解引用,但元素自身拥有未指定值。调用 unique 典型地后随调用容器的 erase 方法,它擦除未指定值并减小容器的物理大小,以匹配其新的逻辑大小。

1) 用 operator== 比较元素。若它不是等价关系则行为未定义。

3) 用给定的谓词 p 比较元素。若它不是等价关系则行为未定义。

2,4) 同 (1,3) ,但按照 policy 执行。这些重载仅若 std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 为 true 才参与重载决议。

参数

first, last-要处理的元素范围
policy-所用的执行策略。细节见执行策略。
p-若元素应被当做相等则返回 ​true 的二元谓词。

谓词函数的签名应等价于如下:

 bool pred(const Type1 &a, const Type2 &b);

虽然签名不必有 const & ,函数也不能修改传递给它的对象,而且必须接受(可为 const 的)类型 Type1Type2 的值,无关乎值类别(从而不允许 Type1 & ,亦不允许 Type1 ,除非 Type1 的移动等价于复制 (C++11 起))。
类型 Type1 与 Type2 必须使得 ForwardIt 类型的对象能在解引用后隐式转换到这两个类型。 ​

类型要求
- ForwardIt 必须满足遗留向前迭代器 (LegacyForwardIterator) 的要求。
- 解引用 ForwardIt 结果的类型必须满足可移动赋值 (MoveAssignable) 的要求。

返回值

指向范围新结尾的向前迭代器。

复杂度

对于非空范围,准确应用 std::distance(first,last) -1 次对应的谓词。

异常

拥有名为 ExecutionPolicy 的模板形参的重载按下列方式报告错误:

  • 若作为算法一部分调用的函数的执行抛出异常,且 ExecutionPolicy 为标准策略之一,则调用 std::terminate 。对于任何其他 ExecutionPolicy ,行为是实现定义的。
  • 若算法无法分配内存,则抛出 std::bad_alloc 。

可能的实现

版本一

template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
 
    ForwardIt result = first;
    while (++first != last) {
        if (!(*result == *first) && ++result != first) {
            *result = std::move(*first);
        }
    }
    return ++result;
}

版本二

template<class ForwardIt, class BinaryPredicate>
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p)
{
    if (first == last)
        return last;
 
    ForwardIt result = first;
    while (++first != last) {
        if (!p(*result, *first) && ++result != first) {
            *result = std::move(*first);
        }
    }
    return ++result;
}

调用示例

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <iterator>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    bool operator ==(const Cell &cell)
    {
        return x == cell.x && y == cell.y;
    }

    bool operator <(const Cell &cell)
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.y;
        }
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

int main()
{
    auto func1 = [](Cell & cell, const Cell & t)
    {
        cell += t;
        return cell;
    };

    Cell cell{99, 100};
    Cell t{2, 3};
    auto func2 = std::bind(func1, cell, t);

    vector<Cell> cells(8);

    std::generate(cells.begin(), cells.begin() + cells.size() / 3, func2);
    std::generate(cells.begin() + cells.size() / 3, cells.end(), func2);
    std::sort(cells.begin(), cells.end());//排序
    std::cout << "original :            ";
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "unique :              ";
    auto last = std::unique(cells.begin(), cells.end());
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "erase :               ";
    cells.erase(last, cells.end());
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    auto func3 = [](const Cell & a, const Cell & b)
    {
        return a.x == b.x && a.y == b.y;
    };

    cells.resize(8);

    std::generate(cells.begin(), cells.begin() + cells.size() / 3, func2);
    std::generate(cells.begin() + cells.size() / 3, cells.end(), func2);
    std::sort(cells.begin(), cells.end());//排序
    std::cout << "func original :       ";
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "func unique :         ";
    last = std::unique(cells.begin(), cells.end(), func3);
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "func erase :          ";
    cells.erase(last, cells.end());
    std::copy(cells.begin(), cells.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

输出

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值