数据结构与stl

数据结构与STL

数据结构与STL的对应关系。（G++的STL）

根据机械工业出版社 张小莉等编著的《数据结构与算法》的结构书写。

注:本人不讨论内存配置alloc，所以对其中const allocator_type& __a = allocator_type()参数全部选择默认值。

 

 

一些通用函数：

       swap(type x, type y)交换相同类型的元素。

第一章：序言。

第二章：线性表

线性表表示一种线性结构。线性结构的特点是数据元素之间是线性关系，数据元素“一个接一个的排列”。其中数据元素的类型是一致的。

线性表基本操作：初始化；求线性表长度；取表元；按值查找；插入到指定位置前；删除指定位置。

对应于STL部分：

1．  顺序表。<vector><stl_vector.h>

注意vector改变数组大小的方法是为新的申请而撤销旧的内存空间。故频繁resize不明智。为此，STL出现了deque,他解决了空间的申请单其他运算很复杂。

构造函数：

                     vector();

                     vector(size_type n,const value_type& value);

                     vector(size_type n);

                     vector(const vector &x);

                     vector(interator start,interator rear);

有关属性的基本方法：

iterator begin();             //rbegin

iterator end();                //rend

reference front();

reference back();

//-------------------------------------------------------

size_type size();

bool empty();

              应用的基本方法：

                     整体运算：(<,<=,>,>=,==,=)

                            void reverse();

                     增加元素：

                            void push_back(const value_type &x);

                            //以下三个函数不推荐频繁使用

                            iterator insert(iterator __position, const value_type& __x);

                            void insert(iterator __position, size_type __n, const value_type& __x);

                            void insert(iterator __position, _InputIterator __first, _InputIterator __last);

                     删除元素：

                            void pop_back();

void Clear();

//以下两个函数不推荐频繁使用

                            iterator erase(iterator position);

                     iterator erase(iterator __first, iterator __last);

                     元素访问：

                            op[];

                            oid assign(size_type __n, const value_type& __val);

                            void assign(_InputIterator __first, _InputIterator __last);

reference at(size_type __n);

const_reference at(size_type __n) const;

              迭代器：未找到迭代器的类型

                     vector<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

              内存相关：

                     size_type max_size() const；//可能分配的最大内存

                     size_type capacity() const； //所剩的已分配内存

                     void reserve(size_type __n); //预留内存

                     void resize(size_type new_size);

                     void resize(size_type new size,const value_type& x);

              小结：

2．  链表。<list><stl_list.h>

实现的是双向循环链表

构造函数：

                     list();

                     list(size_type n,const value_type& value);

                     list(size_type n);

list(const list &x);

                     list(interator start,interator rear);

有关属性的基本方法：

iterator begin();       //rbegin

iterator end();            //rend

reference front();

reference back();

//-------------------------------------------------------

size_type size();

bool empty();

              应用的基本方法：

                     整体运算：(<,<=,>,>=,==，=)

                            void reverse();

                     增加元素：

                            void push_front(const value_type &x);

                            void push_back(const value_type &x);

                            iterator insert(iterator __position, const value_type& __x);

                            void insert(iterator __position, size_type __n, const value_type& __x);

                            void insert(iterator __position, _InputIterator __first, _InputIterator __last);

                     删除元素：

                            void pop_front();

                            void pop_back();

void Clear();

void unique();

 

void remove(const value_type& __val);

template <class _Predicate>

  void remove_if(_Predicate __pred);

 

                            iterator erase(iterator position);

iterator erase(iterator __first, iterator __last);

 

                     元素访问：

                            void assign(size_type __n, const value_type& __val);

                            void assign(_InputIterator __first, _InputIterator __last);

                            //结合，源变空

                            void splice(iterator __position, list& __x);

                            void splice(iterator __position, list&, iterator __i);

                            void splice(iterator __position, list&, iterator __first, iterator __last);

                     排序：

                           

              内存相关：

                     size_type max_size() const；//可能分配的最大内存

void resize(size_type new_size);

                     void resize(size_type new_size, const value_type& x);

              迭代器：

                     typedef bidirectional_iterator_tag    iterator_category;

                     list<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

              小结：

1．  erase删除指定位置的数据，remove删除指定值的数据，clear全删除。

3．<slist>单向链表

构造函数：

                     slist();

                     slist(size_type n,const value_type& value);

                     slist(size_type n);

slist(const slist &x);

                     slist(interator start,interator rear);

有关属性的基本方法：

iterator begin();

const_iterator begin() const;      

iterator end(); 

const_iterator end() const       

reference front();

const_reference front() const;

reference back();

//-------------------------------------------------------

size_type size();

bool empty();

              应用的基本方法：

                     整体运算：(<,<=,>,>=,==，=)

                            void reverse();

                     增加元素：

                            void push_front();

void push_front(const value_type &x);

                            void push_back(const value_type &x);

 

                            iterator insert_after(iterator __pos, const value_type& __x);

                            iterator insert_after(iterator __pos);

                            void insert_after(iterator __pos, size_type __n, const value_type& __x);

                            template <class _InIterator>

                                  void insert_after(iterator __pos, _InIterator __first, _InIterator __last);

 

                            iterator insert(iterator __position, const value_type& __x);

                            void insert(iterator __position, size_type __n, const value_type& __x);

                            void insert(iterator __position, _InputIterator __first, _InputIterator __last);

                     删除元素：

                            void pop_front();

                            void pop_back();

void Clear();

void unique();

 

void remove(const _Tp& __val);

template <class _Predicate>

  void remove_if(_Predicate __pred);

 

iterator erase_after(iterator __pos);

iterator erase_after(iterator __before_first, iterator __last);

 

                            iterator erase(iterator position);

iterator erase(iterator __first, iterator __last);

                     元素访问：

                            iterator previous(const_iterator __pos);

                            const_iterator previous(const_iterator __pos) const;

 

                            void assign(size_type __n, const value_type& __val);

                            void assign(_InputIterator __first, _InputIterator __last);

                            //结合，源变空

                            void splice_after(iterator __pos, iterator __prev);

                            void splice_after(iterator __pos, slist& __x);

                            void splice_after(iterator __pos, iterator __before_first, iterator __before_last)

 

                            void splice(iterator __position, list& __x);

                            void splice(iterator __position, list&, iterator __i);

                            void splice(iterator __position, list&, iterator __first, iterator __last);

              排序：

                     void merge(slist& __x);

                     template<typename _StrictWeakOrdering>

                      void merge(list&, _StrictWeakOrdering);

                    void sort();

                     template<typename _StrictWeakOrdering>

                      void sort(_StrictWeakOrdering);

              内存相关：

                     size_type max_size() const；//可能分配的最大内存

void resize(size_type new_size);

                     void resize(size_type new_size, const value_type& x);

              迭代器：

                     typedef bidirectional_iterator_tag    iterator_category;

                     list<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

4．<deque><stl_deque.h>

deque是vector的一个补充版本，其中补充的是vector的双向扩展。

       构造方法：

              deque();

              deque(size_type __n, const value_type& __value);

                     explicit deque(size_type __n);

deque(const deque &x);

              deque(interator start,interator rear);

有关属性的基本方法：

iterator begin();       //rbegin

iterator end();            //rend

reference front();

reference back();

//-------------------------------------------------------

size_type size();

bool empty();

              应用的基本方法：

                     整体运算：(<,<=,>,>=,==,=)

                             

                            void reverse();

                     增加元素：

                            void push_front(const value_type &x);

                            void push_back(const value_type &x);

//以下三个函数低效

                            iterator insert(iterator __position, const value_type& __x);

                            void insert(iterator __position, size_type __n, const value_type& __x);

                            void insert(iterator __position, _InputIterator __first, _InputIterator __last);

                     删除元素：

                            void pop_front();

                            void pop_back();

                            iterator erase(iterator position);

                            iterator erase(iterator __first, iterator __last);

                            void Clear();

                     元素访问：

                            void assign(size_type __n, const value_type& __val);

void assign(_InputIterator __first, _InputIterator __last);                  reference at(size_type __n);

const_reference at(size_type __n) const;

              内存相关：

                     size_type max_size() const；

                     void resize(size_type new_size);

                     void resize(size_type new_size, const value_type& x); //可能分配的最大内存

迭代器：

       typedef random_access_iterator_tag iterator_category;

                     list<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

第三章：栈和队列

1．  栈FILO。<stack><stl_stack.h>

template<typename _Tp, typename _Sequence = deque<_Tp> >class stack;由此可见栈的默认容器是deque双向顺序表，当然list也是可以的。由于禁止遍历所以没有迭代器。

构造方法：

              explicit stack(const _Sequence& __c = _Sequence());

有关属性的基本方法： 

size_type size();

bool empty();

              应用的基本方法：

                     常规运算：(<,<=,>,>=,==,!=)

                     增加元素：

                            void push(const value_type& __x);

                     删除元素：

                            void pop();

                     元素访问：

       reference top();

const_reference top() const;

2．  队列FIFO。<queue><stl_queue.h>

template<typename _Tp, typename _Sequence = deque<_Tp> > class queue; 由此可见队列的默认容器也是deque双向顺序表，当然list也是可以的。由于禁止遍历所以没有迭代器。

构造方法：

              explicit queue(const _Sequence& __c = _Sequence());

有关属性的基本方法： 

size_type size();

bool empty();

reference front();

const_reference front() const;

reference back();

const_reference back() const;

              应用的基本方法：

                     常规运算：(<,<=,>,>=,==,!=)

                     增加元素：

                            void push(const value_type& __x);

                     删除元素：

                            void pop();

3．  heap<stl_heap.h>

heap的作用是完成优先队列的算法，可以说他就是由几个函数组成。注：STL实现的是大顶锥。所以数据类型必须实现operator >和随机访问迭代器。

1) push_heap注意push_heap只是将已经插入到__last的元素加入到大顶锥去

template<typename _RandomAccessIterator>

inline void

push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);

template<typename _RandomAccessIterator, typename _Compare>

inline void

push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

2) pop_heap注意pop_heap也是只完成将大顶锥的顶移到__last

template<typename _RandomAccessIterator>

    inline void

    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);

template<typename _RandomAccessIterator, typename _Compare>

    inline void

pop_heap(_RandomAccessIterator __first,_RandomAccessIterator __last, _Compare __comp);

3) sort_heap将heap转化为递增的序列。注意sort_heap对非大顶锥的操作不可预期。

template<typename _RandomAccessIterator>

    void

    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);

template<typename _RandomAccessIterator, typename _Compare>

    void

    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,

             _Compare __comp);

4) make_heap将一个无序的数列转化为heap。

              template<typename _RandomAccessIterator>

                  void

                  make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);

template<typename _RandomAccessIterator, typename _Compare>

                  inline void

           make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,

             _Compare __comp)

       4．Priority_queue

构造方法：

explicit priority_queue(const _Compare& __x = _Compare(), const _Sequence& __s = _Sequence());

template<typename _InputIterator>

priority_queue(_InputIterator __first, _InputIterator __last, const _Compare& __x = _Compare(), const _Sequence& __s = _Sequence());

有关属性的基本方法： 

size_type size();

bool empty();

              应用的基本方法：

                     常规运算：()

                     增加元素：

                            void push(const value_type& __x);

                     删除元素：

               void pop();

        访问元素：

               const_reference top() const

第四章：串

第五章：数组、特殊矩阵和广义表

1．  数组

2．  特殊矩阵

3．  广义表

关联式容器:：所谓关联式容器就是说每个数据都有一个键值(key)和一个实值(value)。其底层实现有两种方式，一是用树实现(STL标准)，另一种是哈西表实现(SGI STL)。

第六章：树型结构(注意树系的由于需要调整所以示不允许直接通过迭代器修改值的！！！)

1．  *二叉树：属于非标准。

概念：

size:以自己为根的树的结点数。

Height节点至最深子节点的路径长度。

depth:节点到根的长度极为节点的深度。

lenth: :节点到节点的边数。

1）  平衡二叉树。

平衡二叉树的含义是任意节点的左子树和右子树高度height最多相差1。平衡二叉树的调整算法是对已经平衡的二叉树被一个元素的插入而导致失衡的调整。经过分析其中的第一个不平衡的子树必然可以归结为以下状况：

而且，是那个由于插入而导致失衡的元素必然是在两个满h的子树中的一个的叶子。注意当他的镜像一是一种情况。

那么，怎么调整是他变得平衡呢？

第一种情况（包括他的镜像情况）

第二种情况（包括他的镜像情况）较为复杂需要进一步的分析

经过以上分析，可见调整的算法了。

2) RG-tree由于其中的调整算法比较简单，本人未做讨论。<rb_tree><stl_tree.h>

构造方法：

rb_tree(const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type());

有关属性的基本方法：

iterator begin();       //rbegin

iterator end();            //rend

reference front();

reference back();

 

size_type size();

bool empty();

              应用的基本方法：

                     常规运算：(<,<=,>,>=,==,!=,=)

                     增加元素：

                            pair<iterator,bool> insert_unique(const value_type& __x);

                        iterator insert_equal(const value_type& __x);

iterator insert_unique(iterator __position, const value_type& __x);

iterator insert_equal(iterator __position, const value_type& __x);

template<typename _InputIterator>

                               void insert_unique(_InputIterator __first, _InputIterator __last);

template<typename _InputIterator>

                               void insert_equal(_InputIterator __first, _InputIterator __last);

                     删除元素：

                            void erase(iterator __position);

                        size_type erase(const key_type& __x);

                        void erase(iterator __first, iterator __last);

                        void erase(const key_type* __first, const key_type* __last);

                        void clear();

                     元素访问：

       _Compare key_comp() const

 

size_type count(const key_type& __x) const;

 

iterator find(const key_type& __x);

const_iterator find(const key_type& __x) const;

 

iterator lower_bound(const key_type& __x);

const_iterator lower_bound(const key_type& __x) const;

 

iterator upper_bound(const key_type& __x);

const_iterator upper_bound(const key_type& __x) const;

 

pair<iterator,iterator> equal_range(const key_type& __x);

pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;

内存相关：

                     size_type max_size() const;

迭代器：

       typedef bidirectional_iterator_tag iterator_category;

                     rb_tree<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

              小结：由于红黑树是查找树所以他有自己的查找函数find().

2．  其他

第七章：图

1．  Set

template<class _Key, class _Compare = less<_Key>,class _Alloc = allocator<_Key> >

class set;

构造方法：

set();

explicit set(const _Compare& __comp);

template<class _InputIterator> set(_InputIterator __first, _InputIterator __last);

template<class _InputIterator>

   set(_InputIterator __first, _InputIterator __last, const _Compare& __comp);

set(const set<_Key,_Compare,_Alloc>& __x);

有关属性的基本方法：

iterator begin();       //rbegin

iterator end();            //rend

 

size_type size();

bool empty();

              应用的基本方法：

                     常规运算：(<,<=,>,>=,==,!=,=)

                     增加元素：

                            pair<iterator,bool> insert(const value_type& __x);

iterator insert (iterator __position, const value_type& __x);

template<typename _InputIterator>

                               void insert (_InputIterator __first, _InputIterator __last);

                     删除元素：

                            void erase(iterator __position);

                        size_type erase(const key_type& __x);

                        void erase(iterator __first, iterator __last);

                        void clear();

                     元素访问：

       key_compare key_comp() const;

       value_compare value_comp() const;

 

       size_type count(const key_type& __x) const;

 

iterator find(const key_type& __x);

const_iterator find(const key_type& __x) const;

 

iterator lower_bound(const key_type& __x);

const_iterator lower_bound(const key_type& __x) const;

 

iterator upper_bound(const key_type& __x);

const_iterator upper_bound(const key_type& __x) const;

 

pair<iterator,iterator> equal_range(const key_type& __x);

pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;

内存相关：

                     size_type max_size() const;

迭代器：

       typedef bidirectional_iterator_tag iterator_category;

                     rb_tree<value_type>::interator i;

                     运算符：=,*，-〉，++，--，+，-，+=，-=

2.map

template <typename _Key, typename _Tp, typename _Compare = less<_Key>, 

        typename _Alloc = allocator<pair<const _Key, _Tp> > >

    class map;

构造方法：

map();

explicit map(const _Compare& __comp);

map(const map& __x);

template <typename _InputIterator>

map(_InputIterator __first, _InputIterator __last)

template <typename _InputIterator>

    map(_InputIterator __first, _InputIterator __last, const _Compare& __comp);

有关属性的基本方法：

iterator begin();       //rbegin

iterator end();            //rend

 

size_type size();

bool empty();

              应用的基本方法：

                     常规运算：(<,<=,>,>=,==,!=,=)

                     增加元素：

                            pair<iterator,bool> insert(const value_type& __x);

iterator insert (iterator __position, const value_type& __x);

template<typename _InputIterator>

                               void insert (_InputIterator __first, _InputIterator __last);

                     删除元素：

                            void erase(iterator __position);

                        size_type erase(const key_type& __x);

                        void erase(iterator __first, iterator __last);

                        void clear();

                     元素访问：

                            mapped_type& operator[](const key_type& __k);

 

       key_compare key_comp() const;

       value_compare value_comp() const;

 

       size_type count(const key_type& __x) const;

 

iterator find(const key_type& __x);

const_iterator find(const key_type& __x) const;

 

iterator lower_bound(const key_type& __x);

const_iterator lower_bound(const key_type& __x) const;

 

iterator upper_bound(const key_type& __x);

const_iterator upper_bound(const key_type& __x) const;

 

pair<iterator,iterator> equal_range(const key_type& __x);

pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;

内存相关：

                     size_type max_size() const;

迭代器：

       typedef bidirectional_iterator_tag iterator_category;

                     rb_tree<value_type>::interator i;

               运算符：=,*，-〉，++，--，+，-，+=，-=

第八章：查找

第八章：排序

附录：

       一.迭代器简要介绍。

1．  Iterator_traits是迭代器中最重要的部分。以下是其声明

template<class I>struct iterator_traits{

typedef typename I::iterator_category iterator_category;

typedef typename I::value_type     value_type;

typedef typename I::difference_type difference_type;

typedef typename I::pointer        pointer;

typedef typename I::reference      refernce;

}

2．  terator_traits用于通过模板的参数的推导得出值的类型。（出处：《STL源码剖析》侯捷 P86-）

a)         类迭代器

template<classs I> struct iterator_traits{

typedef typename I::value_type value_type;

};

如声明一个模板函数：

template <class I>

typename iterator_traite<I>::value_type  //整行都是函数的返回型别，其中typename func(I ite){       return *ite;      }        //指明这是一个型别否则编译器不通过。

 

举例typename iterator_traite<int *>::value_type展开为

b)        基本数据迭代器

template<class T>

struct iterator_traits<T*>{

typedef T value_type;

};

c)        const数据迭代器

template<class T>

struct iterator_traits<const T*>{

typedef T value_type;

};

3．  迭代器型别

Input iterator:只读。

Output iterator:唯写。

Forward iterator:允许“写入型”算法。

Bidirectional iterator:可双向移动。

Random Access iterator:提供所用指针算术能力。

 

为了区别STL使用了以下五个标记：

struct input_iterator_tag{};

struct output_iterator_tag{};

struct forward_iterator_tag:public input_iterator_tag{};

struct bidirectional_iterator_tag:public forward_iterator_tag{};

struct random_access_iterator_tag:public bidirectional_iterator_tag{};

这样以上五个标记可以作为函数的重载函数的第三个参数，通过调用以下函数求出指定指针的型别标记：

template <class I>

inline typename iterator_traits<I>::iterator_category

iterator_category(const I &){

        typedef typename iterator_traits<I>::iterator_category category;

        return category();

}

二.pair简介.

  /// pair holds two objects of arbitrary type.

  template<class _T1, class _T2>

  struct pair

  {

typedef _T1 first_type;  

typedef _T2 second_type;  

     _T1 first;               

     _T2 second;               

     pair();

     pair(const _T1& __a, const _T2& __b);

     template<class _U1, class _U2> pair(const pair<_U1, _U2>& __p);

        操作符==,<,!=  >,<=,>;

        template<class _T1, class _T2>

inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y);

};