STL源码学习系列六: 算法(Algorithm)

算法(Algorithm)


前言

以有限的步骤,解决逻辑或数学上的问题,这一专门科目称为算法(Algorithm)。广而言之,我们所写的每一个程序都是一个算法,其中的每个函数也都是一个算法。当我们发现一个可以解决问题的算法时,下一个重要的步骤就是决定该算法所耗的资源,包括空间时间。

STL算法部分主要是由三个头文件承担: algorithm、numeric、functional

  1. algorithm:意思是算法,只要想使用STL库中的算法函数就得包含该头文件。
  2. numeric:包含了一系列用于计算数值序列的算法,其具有一定的灵活性,也能够适用于部分非数值序列的计算
  3. functional:定义了一些模板,可以用来声明函数对象。

算法,问题之解法。


STL算法分类

质变与非质变算法:

  1. 质变算法-会改变操作对象的值。所有的STL算法都作用在[first,last)所标示的区间上,在运算过程中改变区间元素值。例如:copy,swap,replace,fill,remove,permulation,partition,sort等。
  2. 非质变算法-不改变操作对象之值。例如:find,search,count,equal,max,min等。

STL库中的算法大致可以分为四类:

  1. 非可变序列算法:算法不修改容器元素的值或顺序。如:for_each,先行查找,子序列匹配,元素个数,元素比较,最大与最小值。
  2. 可变序列算法:算法要修改容器元素的值或顺序。例如:复制、填充、交换、替换、生成等
  3. 排序算法:包括排序、二分查找、归并排序、堆排序、有序查找等。
  4. 数值算法:包括向量运算、复数运算、求和、内积等。

泛型算法

STL算法的一般形式-泛型算法。所有泛型算法的前两个参数都是一对迭代器,通常称为first,last,以标示算法的操作区间,前闭后开。这个[first,last)区间的必要条件是,必须能够经由increment(累加)操作的反复运用,从first到last。编译器本生无法强求这一点,如果这个条件不成立,会导致未可预期的后果。

根据特性,迭代器分为5类。每一个STL算法的申明,都表现它所需的最低程度的迭代器类型。同时,将无效的迭代器传给某一个算法,虽然是一个错误,却不能保证在编译时就能被捕捉出来,因为所谓“迭代器类型”并不是真实的型别,他们只是function template的一种型别参数(type parameters)。

许多STL算法不只支持一个版本,这一类算法的某个版本采用缺省运算行为,另一个版本提供额外参数,接受外界传入一个仿函数,以便采用其他策略。


算法的泛化过程

如设计一个算法,使它适用于任何(大多数)数据结构?

将算法独立于其所处理的数据结构之外,不受数据结构的羁绊。关键在于:将操作对象的型别抽象化,把操作对象的标识符和区间目标的移动行为抽象化。整个算法也就在一个抽象的层面上了。整个过程称为泛型化(generalized),简称泛化。

让我们看看算法泛化的一个实例,以简单的循序查找为例。假设我们要写一个find()函数,在array中寻找特定值。面对array,我们的直觉反应是:

int* find(int *arrayHead,int arraySize,int value)
{
    int i;
    for(i=0;i<arraySize;i++)
    {    if(arrayHead[i]==value)
        break;
    }
    return &(arrayHead[i]);
}

该函数在某一个区间内查找,返回的是一个指针,指向符合标准的第一个元素。

为例让find()函数适用于所有类型的容器,其操作应当抽象化些,让find()接受两个指针作为参数,标示出一个操作区间,这就是很好的做法:

int* find(int* begin,int* end,int value)
{
    while(begin!=end&&*begin!=value)
        ++begin;
    return begin;
}

由于find()函数之内并无任何操作是针对特定的整数array而发的,所以我们将它改成一个template:

template<class T>
T* find(T* begin,T*end,const T& value)
{
    while(begin!=end&&*begin!=value)
        ++begin;
    return begin;
}

值的传递由pass-by-value改为pass-by-reference-to-const,因为如今所传递的value,其型别可以为任何任意,于是对象一大,传递成本就会增大,所以by-reference是可以避免这些成本。

C++有一个极大的优点,几乎所有的东西都可以改为程序员自定义的形式或行为,上述这些操作符和操作行为都可以被重载(overloaded),既是如此,何必将find局限于使用指针呢?从原生指针中的思想框架逃离出来。如果我们以一个原生指针指向某个list,则对该指针进行“++”操作并不能使它指向下一个串行节点,但如果我们设计class,拥有原生指针的行为,并使其“++”操作指向list的下一个节点,那么find()就可以施行于List容器身上了。这便是迭代器的观念。迭代其是一种行为类似指针的对象,换句话说,是一种smart pointers。现以迭代其重新写过:

template<class Iterator,class T>
Iterator* find(Iterator* begin,Iterator* end,const T& value)
{
    while(begin!=end&&*begin!=value)
        ++begin;
    return begin;
}

这便是一个完全泛化的find()函数,你可以在C++标准库的某一个头文件中看到它,长相几乎一模一样。


代码

部分算法实现:

#ifdef _ALGORITHM_H_
#define _ALGORITHM_H_

#include<cstring>
#include<utility>
#include"iterator.h"
#include"typetraits.h"

namespace EasySTL
{
    //*** fill O(n) ***
    template<class ForwardIterator,class T>
    void fill(ForWardIterator first,ForwardIterator last,const T& value)
    {
        for(:first!=last;first++)
            *first=value;
    }

    inline void fill(char *first,char *last,const char& value)
    {
        memset(first,static_cast<unsigned char>(value),last-first);
    }

    inline void fill(wchar_t first,wchar_t last,const wchar_t& value)
    {
        memset(first,static_cast<unsigned char>(value),sizeof(wchar_t)*(last-first));
    }

    //*** fill_n O(n) ***
    template<class OutputIterator,class Size,class T>
    OutputIterator fill_n(OutputIterator first,Size n,const T& value)
    {
        for(;n>0;--n,++first)
            *first=value;
        return first;
    }    

    template<class Size>
    char *fill_n(char *first, Size n, const char& value)
    {
        memset(first, static_cast<unsigned char>(value), n);
        return first + n;
    }

    template<class Size>
    wchar_t *fill_n(wchar_t *first, Size n, const wchar_t& value)
    {
        memset(first, static_cast<unsigned char>(value), n * sizeof(wchar_t));
        return first + n;
    }

    //*** push_heap ***
    template<class RandomAccessIterator,class Distance,class T>
    inline void _push_heap(RandomAccessIterator first,Distance holeIndex,Distance topIndex,
            T value)
    {
        Distance parent=(holeIndex-1)/2;  //父节点
        while(holeIndex>topIndex&&*(first+parent)<value)
        {
            *(first+holeIndex)=*(first+parent);
            holeIndex=parent;
            parent=(holeIndex-1)/2;
        }
        *(first+holeIndex)=value;
    }


    template<class RandomAccessIterator,class Distance,class T>
    inline void _push_heap_axu(RandomAccessIterator first,RandomAccessIterator last,
            Distance*,T*)
    {
        EasySTL::_push_heap(first,Distance(last-first)-1,Distance(0),T(*(last-1)));
    }

    template<class RandomAcceccIterator>
    inline void push_heap(RandomAccessIterator first,RandomAccessIterator last)
    {
        //新元素已位于容器最尾端
        EasySTL::_push_heap_aux(first,last,difference_type(first),value_type(first));
    }

    //*** pop_heap ***
    template<class RandomAccessIterator,class T,class Distance>
    void _adjust_heap(RandomAccessIterator first,Distance holeIndex,Distance len,T value)
    {
        Distance topIndex=holeIndex;
        Distance secondChild=2*heloIndex+2;
        while(secondChild<len)
        {
            if(*(first+secondChild)<*(first+(secondChild-1))) 
                secondChild--;
            *(first+holeIndex)=*(first+secondChild);
            holeIndex=secondIndex;
            secondIndex=2*(secondChild+1);
        }
        if(secondChild==len)  //没有右子节点,有左子节点
        {
            *(first+holeIndex)=*(first+(secondChild-1));
            heloIndex=secondChild-1;
        }
        EasySTL::_push_heap(first,heloIndex,topIndex,value);
    }

    template<class RandomAccessIterator,class T,class Distance>
    inline void _pop_heap(RandomAccessIterator first,RandomAccessIterator last,
            RandomAccessIterator result,T value,Distance*)
    {
        *result=*first;
        EasySTL::_adjust_heap(first,Distance(0),Distance(last-first),value); //value暂时保存
    }

    template<class RandomAccessIterator,class T>
    inline void _pop_heap_aux(RandomAccessIterator first,RandomAccessIterator last,T*)
    {
        EastSTL::_pop_heap(first,last-1,last-1,T(*(last-1)),difference_type(first));
    }

    template<class RandomAccessIterator>
    inline void pop_heap(RandomAccessIterator first,RandomAccessIterator last)
    {
        EasySTL::_pop_heap_aux(first,last,value_type(first));
    }

    //*** make_heap ***
    template<class RandomAccessIterator, class T, class Distance>
    void _make_heap(RandomAccessIterator first,RandomAccessIterator last, T*, Distance*)
    {
        if(last- first<2) return;
        Distance len = last - first;
        Distance parent = (len -2)/2;
        while(true) //调整整个树的所有父节点
        {
            EasySTL::_adjust_heap(first, parent, len, T(*(first + parent)));
            if (parent == 0) return;
            parent--;
        }
    }

    template<class RandomAccessIterator>
    inline void make_heap(RandomAccessIterator first, RandomAccessIterator last) 
    {
        EasySTL::_make_heap(first, last, value_type(first), difference_type(first));       
    }

    //*** copy ***
    template<class InputIterator, class OutputIterator>
    OutputIterator _copy(InputIterator first, InputIterator last, OutputIterator result,
            _true_type)
    {
        auto dist = distance(first, last);
        memcpy(result, first, sizeof(*first) * dist);
        advance(result, dist);
        return result;
    }

    template<class InputIterator, class OutputIterator>
    OutputIterator _copy(InputIterator first, InputIterator last, OutputIterator result,
            _false_type)
    {
        while (first != last)
        {
            *result = *first;
            ++result;
            ++first;
        }
            return result;
    }

     template<class InputIterator, class OutputIterator, class T>
     OutputIterator _copy(InputIterator first, InputIterator last, OutputIterator result, T*)
     {
         typedef typename _type_traits<T>::is_POD_type is_pod;                                          return__copy(first, last, result, is_pod());
     }

     template <class InputIterator, class OutputIterator>
     OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
     {
         return _copy(first, last, result, value_type(first));
     }

     template <class InputIterator, class OutputIterator>
     OutputIterator copy_backward(InputIterator first, InputIterator last, 
             OutputIterator result)
     {
         OutputIterator new_result = result - (last - first);
         return _copy(first, last, new_result, value_type(first));
     }

     template<>
     inline char *copy(char *first, char *last, char *result)
     {
         auto dist = last - first;
         memcpy(result, first, sizeof(*first) * dist);
         return result + dist;
     }

     template<>
     inline wchar_t *copy(wchar_t *first, wchar_t *last, wchar_t *result)
     {
         auto dist = last - first;
         memcpy(result, first, sizeof(*first) * dist);
         return result + dist;
     }

     template <class T1, class T2>
     T1 max(T1 a, T2 b)
     {
         return a > b ? a : b;
     }

     template <class T1, class T2>
     T1 min(T1 a, T2 b)
     {
         return a < b ? a : b;
     }

    //*** find ***    
    template <class InputIterator, class T>
    InputIterator find(InputIterator first, InputIterator last, const T& val)
    {
        for (; first != last; ++first)
        {
            if (*first == val)
                break;
        }
        return first;
    }

}

#endif

End

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页