码迷,mamicode.com
首页 > 编程语言 > 详细

6.5-数据结构&算法-标准模板STL/STL容器/向量

时间:2018-11-27 21:11:57      阅读:174      评论:0      收藏:0      [点我收藏+]

标签:class   priority   模板库   扩容   oid   访问   下标   hat   ring   

一、标准模板库(STL)
1.定义了一系列的容器模板,实现泛型化的数据结构。
1)向量(vector),内存连续,支持下标访问和随机迭代,只有在尾部进行插入和删除效率才比较高。
2)列表(list),内存不连续,不支持下标访问和随机迭代,在任何位置进行插入和删除效率都很高。
3)双端队列(deque),内存连续,支持下标访问和随机迭代,在首尾两端进行插入和删除效率都比较高。
以上三种合称为线性容器。
4)堆栈(stack),后进先出
5)队列(queue),先进先出
6)优先队列(priority_queue),优者先出
以上三种合称为适配器容器,通过某种线性容器适配。
7)映射(map),键值对(KVP)的集合,按键升序,键唯一。
8)集合(set),没有值只有键的映射。
9)多重映射(multimap),允许重复键的映射。
10)多重集合(multiset),没有值只有键的多重映射。
以上四种合称为关联容器。通过有序树表达数据的关联性。
2.泛型函数
template<typename T>
void swap (T& a, T& b) {
  T c = a;
  a = b;
  b = c;
}
template<typename IT>
void print (IT begin, IT end) {
  while (begin != end)
    cout << *begin++ << ‘ ‘;
  cout << endl;
}
int a[5] = {1, 2, 3, 4, 5};
print (a, a + 5);
List list;
list.push_back (...);
...
print (list.begin (), list.end ());
3.实用工具
auto_ptr
string
pair
 
二、STL容器共性
1.所有的容器都支持拷贝构造和拷贝赋值,可以完整意义上的容器对象副本。
2.所有的容器都支持“==”运算符。容器的相等:容器的类型相同,容器中元素的类型相同,容器中元素的个数相等,对应元素还要满足相等性的判断。
3.容器中元素都是放入源对象拷贝。
int b;
int a[3];
a[0] = b;
 
4.容器中元素需要支持完整的拷贝语义。auto_ptr不适合放在容器中使用。
5.如果需要对容器的元素进行排序或者查找操作,该元素的类型还需要支持“<”和“==”操作符。
 
三、向量(vector)
1.基本特点
1)连续内存和下标访问
2)动态内存管理
int a[10];
int *b = new int[10];
3)通过预分配内存空间减小动态内存管理的额外开销
4)可以再随机位置做插入和删除,但只有在接近尾部的操作才是高效的。
2.定义变量
#include <vector>
using namespace std;
vector<int> vi;
vector<string> vs;
3.迭代器
vector<...>::iterator - 正向迭代器
vector<...>::const_iterator - 常正向迭代器
vector<...>::reverse_iterator - 反向迭代器
vector<...>::const_reverse_iterator - 常反向迭代器
向量的四种迭代器都是随机迭代器,可以和整数做加减运算。
通过vector<...>调用,begin()返回起始迭代器,end()返回终止迭代器,最后一个元素的下一个位置。rbegin()返回起始反向迭代器,rend()返回终止反向迭代器。
通过const vector<...>&/*调用以上函数,返回的将是const_iterator/const_reverse_interator。
4.预分配和初始化
vector<int> vi (10);
将vi初始化10个int元素,初始值为0。
vector<类> vc (10);
将vi初始化10个类类型的元素,通过无参构造函数初始化。
vector<int> vi (10, 8);
将vi初始化10个int元素,初始值为8。
vector<类> vc (10, 类 (...));
将vi初始化10个类类型的元素,通过拷贝构造函数初始化。
5.size()/resize()/clear()/capacity()/reserve()
size() - 获取元素个数,而不是容量。
resize() - 增减元素的个数,增引发构造,减引发析构。如果在新增元素时发现当前容量不够,自动扩容。但是在减少元素时不会自动收缩容量。
clear() - 清空所有的元素,导致析构。同样不会自动收缩容量。
capacity() - 获取容量,以元素为单位。
reserve() - 手动扩容。新增部分不做初始化。
6.insert()/erase()/sort()/find()
insert()/erase() - 根据迭代器参数做插入和删除。
sort()/find() - 全局算法函数,排序(快速)和查找
7.类类型对象的向量
1)无参构造
2)拷贝构造
3)拷贝赋值
4)operator==:find
5)operator</operator基本类型/比较器
练习:编写程序读取m.dat中的电影票房记录,找出票房前十名,按票房从高到低的顺序写入另一文件中。
 
四、双端队列(deque)
1.连续内存,下标访问和随机迭代,在首尾两端都可以进行高效的增删。
2.因为要维护首尾两端的开放性,因此双端队列和向量相比,其空间和时间复杂度要略高一些。
3.比vector多了push_front/pop_front,少了reserve。
五、列表(list)
front/back
push_front/pop_front
push_back/pop_back
insert/erase/remove
size
1.sort
2.unique - 将连续出现的相同元素唯一化。
23 35 35 35 60 12 35 35 99 35 22
|unique
V
23 35 60 12 35 99 35 22
3.splice - 将参数链表的部分或全部剪切到调用链表的特定位置。
void splice (
  iterator pos,
  list&    lst);
list1.splice (pos, list2);
将list2中的全部数据剪切到list1的pos处。
void splice (
  iterator pos,
  list     &lst,
  iterator del);
将list2中del所指向数据剪切到list1的pos处。
void splice (
  iterator pos,
  list&    lst,
  iterator start,
  iterator end );
将list2中start和end之间的数据剪切到list1的pos处。
class.cpp
#include <vector>
#include <algorithm>
#include "print.h"
class A {
public:
    A (int i = 0) : m_i (i) {
        cout << "无参构造:" << this << endl;
    }
    A (const A& that) : m_i (that.m_i) {
        cout << "拷贝构造:" << &that << "->" << this
            << endl;
    }
    A& operator= (const A& that) {
        cout << "拷贝赋值:" << &that << "->" << this
            << endl;
        if (&that != this)
            m_i = that.m_i;
        return *this;
    }
    ~A (void) {
        cout << "析构函数:" << this << endl;
    }
    operator int& (void) {
        return m_i;
    }
    /*
    operator const int& (void) const {
        return static_cast<int&> (
            const_cast<A&> (*this));
    }
    */
    bool operator== (const A& that) const {
        return m_i == that.m_i;
    }
    /*
    bool operator< (const A& that) const {
        return m_i < that.m_i;
    }
    */
    bool operator() (const A& a, const A& b) const {
        return a.m_i < b.m_i;
    }
private:
    int m_i;
};
int main (void) {
    cout << "---- 1 ----" << endl;
    vector<A> va (3);
    cout << "---- 2 ----" << endl;
    va.push_back (A ());
    cout << "---- 3 ----" << endl;
    va.erase (va.begin ());
    cout << "---- 0 ----" << endl;
    va[0] = A (10);
    va[1] = A (50);
    va[2] = A (70);
    va.push_back (A (60));
    vector<A>::iterator it = find (va.begin (),
        va.end (), A (70));
    if (it == va.end ())
        cout << "没找到!" << endl;
    else
        cout << "找到了:" << *it << endl;
//    sort (va.begin (), va.end ());
    sort (va.begin (), va.end (), va[0]);
    print (va.begin (), va.end ());
    return 0;
}

 

deque.cpp
#include <deque>
#include <algorithm>
#include "print.h"
int main (void) {
    deque<int> di;
    di.push_back (24);
    di.push_back (33);
    di.push_front (18);
    di.push_front (68);
    di.insert (di.begin () + 2, 47);
    print (di.begin (), di.end ()); // 68 18 47 24 33
    di.pop_back ();
    di.pop_front ();
    di.erase (di.begin () + 1);
    print (di.begin (), di.end ()); // 18 24
    di.push_back (20);
    sort (di.begin (), di.end ());
    print (di.begin (), di.end ()); // 18 20 24
    size_t size = di.size ();
    for (size_t i = 0; i < size; ++i)
        cout << di[i] <<  ;
    cout << endl;
    di.resize (10);
    print (di.begin (), di.end ());
    return 0;
}

 

fe.cpp

#include <iostream>
//#include <algorithm>
using namespace std;
template<typename IT, typename DOIT>
void for_each (IT begin, IT end, DOIT doit) {
    while (begin != end)
        doit (*begin++);
}
void print (int& x) {
    cout << x << endl;
}
void add (int& x) {
    ++x;
}
int main (void) {
    int a[5] = {1, 2, 3, 4, 5};
    for_each (a, a + 5, print);
    for_each (a, a + 5, add);
    for_each (a, a + 5, print);
    return 0;
}

 

insert.cpp
#include <algorithm>
#include <vector>
#include "print.h"
template<typename iterator, typename type>
iterator find (iterator begin, iterator end,
    const type& key) {
    for (; begin != end; ++begin)
        if (*begin == key)
            break;
    return begin;
}    
bool cmpInt (const int& a, const int& b) {
    return a > b;
}
class CmpInt {
public:
    CmpInt (bool less = true) : m_less (less) {}
    bool operator() (const int& a, const int& b) const{
        return m_less ? (a < b) : (a > b);
    }
private:
    bool m_less;
};
int main (void) {
    int ai[] = {10, 20, 30, 40, 50};
    vector<int> vi (ai, &ai[5]);
    print (vi.begin (), vi.end ());
    vector<int>::iterator it = vi.begin ();
    it = vi.insert (it + 1, 15);
    print (vi.begin (), vi.end ());
    ++++++it;
    it = vi.erase (it);
    print (vi.begin (), vi.end ());
    cout << *it << endl; // 50
    vi.insert (vi.begin (), 37);
    vi.insert (vi.begin () + 2, 43);
    vi.insert (vi.begin () + 4, 29);
    vi.push_back (18);
    vi.push_back (24);
    print (vi.begin (), vi.end ());
    sort (vi.begin (), vi.end ());
    print (vi.begin (), vi.end ());
    sort (vi.begin (), vi.end (),
        /*cmpInt*/CmpInt (false));
    print (vi.begin (), vi.end ());
    it = ::find (vi.begin (), vi.end (), 18);
    if (it == vi.end ())
        cout << "没找到!" << endl;
    else
        cout << "找到了:" << *it << endl;
    return 0;
}

 

list.cpp

#include <list>
#include "print.h"
int main (void) {
    list<int> li;
    li.push_back (34);
    li.push_back (28);
    li.push_back (34);
    li.push_back (34);
    li.push_back (55);
    li.push_back (34);
    print (li.begin (), li.end ());
    li.unique ();
    print (li.begin (), li.end ());
    li.sort ();
    print (li.begin (), li.end ());
    li.unique ();
    print (li.begin (), li.end ());
    list<int> li2;
    li2.push_front (100);
    li2.push_front (200);
    li2.push_front (300);
    list<int>::iterator pos = li.begin ();
    ++pos;
//    li.splice (pos, li2);
    list<int>::iterator start = li2.begin ();
    ++start;
//    li.splice (pos, li2, start);
    list<int>::iterator end = li2.end ();
    li.splice (pos, li2, start, end);
    print (li.begin (), li.end ());
    cout << li2.size () << endl;
    return 0;
}

 

print.h
#ifndef _PRINT_H
#define _PRINT_H
#include <iostream>
using namespace std;
template<typename iterator>
void print (iterator begin, iterator end) {
    while (begin != end)
        cout << *begin++ <<  ;
    cout << endl;
}
#endif // _PRINT_H

 

size.cpp
#include <iostream>
#include <vector>
using namespace std;
void print (const vector<int>& vi) {
    cout << "大小:" << vi.size () << endl;
    cout << "容量:" << vi.capacity () << endl;
    for (vector<int>::const_iterator it = vi.begin ();
        it != vi.end (); ++it)
        cout << *it <<  ;
    cout << endl;
}
int main (void) {
    vector<int> vi (5, 3);
    print (vi);
    vi.push_back (4);
    print (vi);
    vi[6] = 100;
    cout << vi[6] << endl;
    vi.push_back (5);
    cout << vi[6] << endl;
    vi.resize (12);
    print (vi);
    vi.resize (2);
    print (vi);
    vi.clear ();
    print (vi);
    vi.reserve (20);
    print (vi);
    cout << vi[19] << endl;
    vi.reserve (5);
    print (vi);
    return 0;
}

 

top.cpp
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
class Movie {
public:
    friend istream& operator>> (istream& is,
        Movie& movie) {
        return is >> movie.m_title >> movie.m_comp
            >> movie.m_gross;
    }
    friend ostream& operator<< (ostream& os,
        const Movie& movie) {
        return os << movie.m_title <<  
            << movie.m_comp <<   << movie.m_gross;
    }
    bool operator< (const Movie& movie) const {
        return gross () > movie.gross ();
    }
private:
    double gross (void) const {
        string str (m_gross);
        size_t pos = 0;
        while ((pos = str.find_first_of ("$,", pos)) !=
            string::npos)
            str.erase (pos, 1);
        return atof (str.c_str ());
    }
    string m_title;
    string m_comp;
    string m_gross;
};
bool read (const char* file, vector<Movie>& vm) {
    ifstream ifs (file);
    if (! ifs) {
        perror ("打开票房文件失败");
        return false;
    }
    Movie movie;
    while (ifs >> movie)
        vm.push_back (movie);
    ifs.close ();
    return true;
}
bool write (const char* file, const vector<Movie>& vm){
    ofstream ofs (file);
    if (! ofs) {
        perror ("打开排行文件失败");
        return false;
    }
    for (vector<Movie>::const_iterator it = vm.begin();
        it != vm.end (); ++it)
        ofs << *it << endl;
    ofs.close ();
    return true;
}
int main (int argc, char* argv[]) {
    if (argc < 3) {
        cerr << "用法:" << argv[0]
            << " <票房文件> <排行文件>" << endl;
        return -1;
    }
    vector<Movie> vm;
    if (! read (argv[1], vm))
        return -1;
    sort (vm.begin (), vm.end ());
    if (vm.size () > 10)
        vm.resize (10);
    if (! write (argv[2], vm))
        return -1;
    return 0;
}

 

vector.cpp
#include <iostream>
#include <vector>
using namespace std;
class A {
public:
    A (int i = 0) : m_i (i) {};
    int m_i;
};
void print (const vector<int>& vi) {
    size_t size = vi.size ();
    cout << size << endl;
    for (size_t i = 0; i < size; ++i)
        cout << vi[i] <<  ;
    cout << endl;
}
int main (void) {
    vector<int> vi;
    vi.push_back (10);
    vi.push_back (20);
    vi.push_back (30);
    vi.push_back (20);
    vi.push_back (10);
    print (vi);
    vi.pop_back ();
    print (vi);
    ++vi.front ();
    vi.back () = 100;
    cout << vi.front () <<   << vi.back () << endl;
    typedef vector<int>::iterator IT;
    typedef vector<int>::const_iterator CIT;
    typedef vector<int>::reverse_iterator RIT;
    typedef vector<int>::const_reverse_iterator CRIT;
    for (IT it = vi.begin (); it != vi.end (); ++it)
        ++*it;
    const vector<int>& cvi = vi;
    for (CIT it = cvi.begin (); it != cvi.end (); ++it)
        cout << /*--*/*it <<  ;
    cout << endl;
    for (CRIT it = cvi.rbegin (); it!=cvi.rend(); ++it)
        cout << *it <<  ;
    cout << endl;
    vector<string> vs;
    vs.push_back ("beijing");
    vs.push_back ("tianjin");
    vs.push_back ("shanghai");
    cout << *(vs.begin () + 2) << endl;
    *const_cast<char*> ((vs.end () - 1)->c_str ())=S;
    cout << *(vs.end () - 1) << endl;
    vector<int> vi2 (10);
    print (vi2);
    vector<A> va (10);
    for (vector<A>::const_iterator it = va.begin ();
        it != va.end (); ++it)
        cout << it->m_i <<  ;
    cout << endl;
    vector<int> vi3 (10, 8);
    print (vi3);
    vector<A> va2 (10, A (8));
    for (vector<A>::const_iterator it = va2.begin ();
        it != va2.end (); ++it)
        cout << it->m_i <<  ;
    cout << endl;
    return 0;
}

 

 
 
 

6.5-数据结构&算法-标准模板STL/STL容器/向量

标签:class   priority   模板库   扩容   oid   访问   下标   hat   ring   

原文地址:https://www.cnblogs.com/xuxaut-558/p/10028408.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!