stl源码剖析 详细学习笔记 算法(2)

//---------------------------15/03/29----------------------------

    

    //****************************set相关算法*****************************

    /*

        1>set相关算法一共有4种：并集(union)，交集(intersection)，差集(difference)，

        对称差集(symmetric difference)。

        2>set相关算法只接受set/multiset。

        3>每个算法都是根据 “<”(可以自行定义) 来确定大小 以及是否相等。

        4>这四个算法都是稳定算法，执行后元素的相对顺序不会改变

                                                                            */

    

    //set_union

    //并集就是除了一样的不加 其它的通通塞到Output迭代器中去，所以比较大小，把

    //小的都塞进去，碰到相等的，塞一个进去。最后可能两个迭代器中有一个还有剩余，

    //就把剩余的都拷贝到 输出区间

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator set_union(InputIterator first1, InputIterator last1,

                            InputIterator first2, InputIterator last2,

                            OutputIterator result)

    {

        while (first1 != last1 && first2 != last)

        {

            if (*first1 < *first2) //自定义版本是这样的： if(comp(*first1, *first2))

            {

                *result = *first1;

                ++first1;

            }

            else if(*first2 < *first1)//自定义版本：  if(comp(*first2, *first1))

            {

                *result = *first2;

                ++first2;

            }

            else

            {

                *result = *first1;

                ++first1;

                ++first2;

            }

            ++result;

        }

        return copy(first2, last2, copy(first1, last1, result));

    }

    

    //set_intersection

    //交集么只要取相等的元素，遇到不相等情况的，只要把小的那自加即可。最后就算那个区间有多也可以不管了。

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator set_intersection(InputIterator first1, InputIterator last1,

                                    InputIterator first2, InputIterator last2,

                                    OutputIterator result)

    {

        while (first1 != last1 && first2 != last2)

        {

            if(*first1 < *first2)

                ++first1;

            else if(*first2 < *first1)

                ++first2;

            else

            {

                *result = *first1;

                ++first1;

                ++first2;

                ++result;

            }

        }

        return result;

    }

    //set_difference

    //差集则只要考虑区间1中有的，区间2中没有的，1中小于2的元素可以输出，碰到相等的就让

    //两个区间的都自加，2中小于1的并没有意义，只需让2自加即可，最后1中有剩余的输出，不用考虑2剩余的情况

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator set_difference(InputIterator first1, InputIterator last1,

                             InputIterator first2, InputIterator last2,

                             OutputIterator result)

    {

        while (first1 != last1 && first2 != last2)

        {

            if(*first1 < *first2)

            {

                *result = *first;

                ++first1;

                ++result;

            }

            else if(*first2 < *first1)

                ++first2;

            else

            {

                ++first1;

                ++first2;

            }

        }

        return copy(first, last1, result);

    }

    

    //set_symmetric_difference

    //对称差集，只有相等的情况不输出，所以碰到相等的 两个区间都自加，剩下情况的都输出。

    //最后会有一个区间有多，也要都输出

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator set_difference(InputIterator first1, InputIterator last1,

                                  InputIterator first2, InputIterator last2,

                                  OutputIterator result)

    {

        while (first1 != last1 && first2 != last2)

        {

            if(*first1 < *first2)

            {

                *result = *first1;

                ++first1;

                ++result;

            }

            else if(*first2 < *first1)

            {

                *result = *first2

                ++first2;

                ++result;

            }

            else

            {

                ++first1;

                ++first2;

            }

        }

        return copy(first2, last2, copy(first1, last1, result));

    }

    

    //****************************set相关算法*****************************

    

    //****************************其它算法*****************************

    

    //adjacent_find

    //找到第一组 满足条件(默认是 ==)的 相邻元素

    template<class ForwardIterator>

    ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)

    {

        if (first == last)

            return last;

        ForwardIterator next = first;

        while (++next != last)

        {

            if(*first == *next)     //自己定义版本 if(binary_pred(*first, *next))

                return first;

            first = next;

        }

        return last;

    }

    

    //count

    //找到与传入的value相等的元素的个数

    template<class InputIterator, class T>

    typename iterator_traits<InputIterator>::difference_type

    count(InputIterator first, InputIterator last, const T& value)

    {

        typename iterator_traits<InputIterator>::difference_type n =0;

        for(; first != last; ++first)

            if(*first == value)     //count_if版本 if( pred(*first))

                ++n;

        return n;

    }

    

    //find

    //找到第一个符合条件的元素

    template<class InputIterator, class T>

    InputIterator find(InputIterator first, InputIterator last,

                       const T& value)

    {

        //find_if版本 while(first != last && !pred(*first))

        while(first != last && *first != value)

            ++first;

        return first;

    }

    

    //find_end

    //找到区间1中最后一组 和区间2 相同的元素

    //如果可以从队尾开始搜索可以快很多，所以分两种情况，可以后退的迭代器，不能后退的迭代器

    template<class ForwardIterator1, class ForwardIterator2>

    inline ForwardIterator1

    find_end(ForwardIterator1 first1, ForwardIterator1 last1,

             ForwardIterator2 first2, ForwardIterator2 last2)

    {

        typedef typename iterator_traits<ForwardIterator1>::iterator_category

            category1;

        typedef typename iterator_traits<ForwardIterator2>::iterator_category

            category2;

        return __find_end(first1, last1, first2, last2, category1(), category2());

    }

    

    template<class ForwardIterator1, class ForwardIterator2>

    ForwardIterator1 __find_end(ForwardIterator1 first1, ForwardIterator1 last1,

                                ForwardIterator2 first2, ForwardIterator2 last2,

                                forward_iterator_tag, forward_iterator_tag)

    {

        if(first2 == last2)

            return last1;

        else

        {

            ForwardIterator1 result = last1;

            while (1)

            {

                //先搜索下一组，再把下一组赋给result  就和单链表删除节点一样，要删除下一个节点，

                //我们要预留上一个节点，这里是要先找到 下一个不符合的情况 我们才知道这是最后一个

                ForwardIterator1 new_result = search(first1, last1, first2, last2);

                if(new_result == last1)

                    return result;

                else

                {

                    result = new_result;

                    first1 = new_result;

                    ++first;

                }

            }

        }

    }

    

    //双向迭代器走这边

    template<class BidirectionalIterator1, class BidirectionalIterator2>

    BidirectionalIterator1

    __find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1,

               BidirectionalIterator2 first2, BidirectionalIterator2 last2,

               bidirectional_iterator_tag, bidirectional_iterator_tag)

    {

        typedef reverse_iterator<BidirectionalIterator1> reviter1;

        typedef reverse_iterator<BidirectionalIterator2> reviter2;

        

        //先确定end位置

        reviter1 rlast1(first1);

        reviter2 rlast2(first2);

        

        //找到第一组就可以了

        reviter1 rresult = search(reviter1(last1), rlast1,

                                  reviter2(last2), rlast2);

        

        if(rresult == rlast1)

            return last1;       //没找到

        else

        {

            //修改位置， base()成员函数可以取得真实位置，因为反向迭代器有两个位置，

            //一个是真实位置，一个是他 “下一个”位置 他的”下一个“其实是正向迭代器的上一个

            //1 2 3 此时反向迭代器指向3 operator*() 取到的是2 base()取到的是 3

            //下面的操作是为了使result == end

            BidirectionalIterator1 result = rresult.base();

            //减去距离，就可以使result变成first

            advance(result, -distance(first2, last2));

            return result;

        }

    }

    

    //find_first_of

    //在区间1中找到 第一个 与区间2中 任意元素匹配 的位置

    template<class InputIterator, class ForwardIterator>

    InputIterator find_first_of(InputIterator first1, InputIterator last1,

                                ForwardIterator first2, ForwardIterator last2)

    {

        for(; first1 != last1; ++first1)

            for(ForwardIterator iter = first2; iter != last2; ++iter)

                if(*first1 == *iter)        //自定义版本 if(comp(*first, *last))

                    return first;

        return last1;

    }

    

    //for_each

    //对每个元素调用仿函数f

    template<class InputIterator, class Function>

    Function for_each(InputIterator first, InputIterator last, Function f)

    {

        for(; first != last; ++first)

            f(*first);

        return f;

    }

    

    //generate

    //把仿函数的返回值填充区间。相当于:  auto rel=gen(); fill(first, last, rel);

    template<class ForwardIterator, class Generator>

    void generate(ForwardIterator first, ForwardIterator last, Generator gen)

    {

        for(; first != last; ++first)

            *first = gen();

    }

    

    //填充n个 gen()

    template<class OutputIterator,class Size, class Generator>

    OutputIterator generate_n(OutputIterator first, Size n, Generator gen)

    {

        for(; n > 0; --n, ++first)

            *first = gen();

        return first;

    }

    

    //includes 应用于有序的区间

    //依次找，只要区间1的元素 小于等于 区间二就继续下去 一旦区间2中的元素小于区间1的

    //说明这个数 在区间1中 就找不到和他相等的数了，就可以返回false了

    template<class InputIterator1, class InputIterator2>

    bool includes(InputIterator1 first1, InputIterator1 last1,

                  InputIterator2 first2, InputIterator2 last2)

    {

        while (first1 != last1 && first2 != last2)

        {

            if(*first2 < *first1)   //自定义版本：if(comp(*first2, *first1))

                return false;

            else if(*first1 < *first2) //自定义版本：if(comp(*first1, *first2))

                ++first1;

            else

                ++first1, ++first2;

        }

        return first2 == last2;

    }

    

    //max_element

    template<class ForwardIterator>

    ForwardIterator max_element(ForwardIterator first, ForwardIterator last)

    {

        if(first == last)

            return first;

        ForwardIterator result = first;

        while(++first != last)

            if(*result < *first)        //自定义版本： if(comp(*result, *first))

                result = first;

        return result;

    }

    

    //merge 要求有序

    template<class InputIterator1, class InputIterator2, class OutputIterator>

    OutputIterator merge(InputIterator1 first1, InputIterator1 last1,

                         InputIterator2 first2, InputIterator2 last2,

                         OutputIterator result)

    {

        while (first1 != last1 && first2 != last2)

        {

            if(*first2 < *first1)   //自定义版本： if(comp(*first2, *first1))

            {

                *result = *first2;

                ++first2;

            }

            else

            {

                *result = *first1;

                ++first1;

            }

            ++result;

        }

        return copy(first2, last2, copy(first1, last1, result));

        

    }