标签:binary cat 位置 应该 迭代 缺省 构建 双向链表 遍历
所谓序列式容器,其中的元素都可序(ordered)【比如可以使用sort进行排序】,但未必有序(sorted)。C++语言本身提供了一个序列式容器array,STL另外再提供vector,list,deque,stack,queue,priority-queue 等等序列式容器。其中stack和queue由于只是将 deque 头换面而成,技术上被归类为一种配接器(adapter)。
vector的数据安排以及操作方式,与array非常相似。两者的唯一差别在于空间的运用的灵活性。
array是静态空间,一旦配置了就不能改变;要换个大(或小)一点的房子,可以,一切琐细得由客户端自己来:首先配置一块新空间,然后将元素从旧址一一搬往新址,再把原来的空间释还给系统。
vector是动态空间,随着元素的加入,它的内部机制会自行扩充空间以容纳新元素。因此,vector的运用对于内存的合理利用与运用的灵活性有很大的帮助,我们再也不必因为害怕空间不足而一开始就要求一个大块头array了,我们可以安心使用vector,吃多少用多少。
注意:
表示已存储数据的大小,而capital则是内部开辟的空间的大小
所以,在erase、pop_back、clear等删除操作,都不会使得其captial产生变化,只会变的就是size()
注意,所谓动态增加大小,并不是在原空间之后接续新空间(因为无法保证原空间之后尚有可供配置的空间),而是以原大小的两倍另外配置一块较大空间,然后将原内容拷贝过来,然后才开始在原内容之后构造新元素,并释放原空间。因此,对vector的任何操作,一旦引起空间重新配置,指向原vector的所有迭代器就都失效了。这是程序员易犯的一个错误,务需小心。
insert()会根据需要插入元素的位置p以及p后面的元素个数与需要插入元素个数n进行比较,分两种情况进行插入
1 struct President 2 { 3 President(std::string && p_name, std::string && p_country, int p_year) 4 : name(std::move(p_name)), country(std::move(p_country)), year(p_year) 5 { 6 std::cout << "I am being constructed.\n"; 7 } 8 President(President&& other) 9 : name(std::move(other.name)), country(std::move(other.country)), year(other.year) 10 { 11 std::cout << "I am being moved.\n"; 12 } 13 President& operator=(const President& other) = default; 14 }; 15 16 int main() 17 { 18 std::vector<President> elections; 19 std::cout << "emplace_back:\n"; 20 elections.emplace_back("Nelson Mandela", "South Africa", 1994); 21 22 std::vector<President> reElections; 23 std::cout << "\npush_back:\n"; 24 reElections.push_back(President("Franklin Delano Roosevelt", "the USA", 1936)); 25 } 26 emplace_back: 27 I am being constructed. 28 29 push_back: 30 I am being constructed. 31 I am being moved.
merge()函数:
merge方式要注意三点:
merge(vec1.begin(),vec1.end(),vec2.begin(),vec2.end(),vec3.begin());
1、vec1,和vec2需要经过排序,merge只能合并排序后的集合,不然会报错。
2、vec3需要指定好大小,不然会报错。
3、merge的时候指定vec3的位置一定要从begin开始,如果指定了end,它会认为没有空间,当然,中间的位置我没有试,回头有空试一下。
相较于vector的连续线性空间,1ist就显得复杂许多,它的好处是每次插人或删除一个元素,就配置或释放一个元素空间。因此,list 对于空间的运用有绝对的精准,一点也不浪费。而且,对于任何位置的元素插人或元素移除,list永远是常数时间。
由于STL1ist是一个双向链表(double linked-list),迭代器必须具备前移、后移的能力,所以1ist 提供的是Bidirectional lterators。
list 有一个重要性质:插入操作(insert)和接合操作(splice)都不会造成原有的list迭代器失效。这在vector是不成立的,因为vector的插入操作可能造成记忆体重新配置,导致原有的迭代器全部失效。甚至1ist的元素删除操作(erase),也只有“指向被删除元素”的那个迭代器失效,其它迭代器不受任何影响。
node->next = node;
node->prv = node;
void transfer(iterator position, iterator first, iterator last);
将list2的first-last之间的元素插入到list1中的position中
void splice( const_iterator pos, list& other ); |
(1) |
|
void splice( const_iterator pos, list&& other ); |
(1) |
(C++11 起) |
void splice( const_iterator pos, list& other, const_iterator it ); |
(2) |
|
void splice( const_iterator pos, list&& other, const_iterator it ); |
(2) |
(C++11 起) |
void splice( const_iterator pos, list& other, const_iterator first, const_iterator last); |
(3) |
|
void splice( const_iterator pos, list&& other, const_iterator first, const_iterator last ); |
(3) |
(C++11 起) |
从一个 list 转移元素给另一个。
不复制或移动元素,仅重指向链表结点的内部指针。若 get_allocator() != other.get_allocator() 则行为未定义。没有迭代器或引用被非法化,指向被移动元素的迭代器保持合法,但现在指代到 *this 中,而非到 other 中。
1) 从 other 转移所有元素到 *this 中。元素被插入到 pos 所指向的元素之前。操作后容器 other 变为空。若 other 与 *this 指代同一对象则行为未定义。
2) 从 other 转移 it 所指向的元素到 *this 。元素被插入到 pos 所指向的元素之前。
3) 从 other 转移范围 [first, last) 中的元素到 *this 。元素被插入到 pos 所指向的元素之前。若 pos 是范围 [first,last) 中的迭代器则行为未定义。
参数
pos |
- |
将插入内容到其前的元素 |
other |
- |
要自之转移内容的另一容器 |
it |
- |
要从 other 转移到 *this 的元素 |
first, last |
- |
要从 other 转移到 *this 的元素范围 |
c1.merge(c2) |
//合并2个有序的链表并使之有序,从新放到c1里,释放c2。 |
c1.merge(c2,comp) |
//合并2个有序的链表并使之按照自定义规则排序之后从新放到c1中,释放c2。 |
c1.splice(c1.beg,c2) |
//将c2连接在c1的beg位置,释放c2 |
c1.splice(c1.beg,c2,c2.beg) |
//将c2的beg位置的元素连接到c1的beg位置,并且在c2中释放掉beg位置的元素 |
c1.splice(c1.beg,c2,c2.beg,c2.end) |
//将c2的[beg,end)位置的元素连接到c1的beg位置并且释放c2的[beg,end)位置的元素 |
归并二个已排序链表为一个。链表应以升序排序。
不复制元素。操作后容器 other 变为空。若 other 与 *this 指代同一对象则函数不做任何事。若 get_allocator() != other.get_allocator() ,则行为未定义。没有引用和迭代器变得非法,除了被移动元素的迭代器现在指代到 *this 中,而非到 other 中,第一版本用 operator< 比较元素,第二版本用给定的比较函数 comp 。
此操作是稳定的:对于二个链表中的等价元素,来自 *this 的元素始终前驱来自 other 的元素,而且 *this 和 other 的等价元素顺序不更改。
参数
other |
- |
要交换的另一容器 |
comp |
- |
比较函数对象(即满足比较 (Compare) 概念的对象),若第一参数小于(即先序于)第二参数则返回 ?true 。 比较函数的签名应等价于如下: bool cmp(const Type1 &a, const Type2 &b); 虽然签名不必有 const & ,函数也不能修改传递给它的对象,而且必须接受(可为 const 的)类型 Type1 与 Type2的值,无关乎值类别(从而不允许 Type1 & ,亦不允许 Type1 ,除非 Type1 的移动等价于复制 (C++11 起))。 类型 Type1 与 Type2 必须使得 list<T,Allocator>::const_iterator 类型的对象能在解引用后隐式转换到这两个类型。 ? |
deque和vector的最大差异:【vector与deque都可以随机读取】
一在于deque允许于常数时间内对起头端进行元素的插入或移除操作,
二在于deque没有所谓容量(capacity)观念,因为它是动态地以分段连续空间组合而成,随时可以增加一段新的空间并链接起来。
deque是连续空间(至少逻辑上看来如此)。
deque系由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间,便配置一段定量连续空间,串接在整个deque的头端或尾端。
deque的最大任务,便是在这些分段的定量连续空间上,维护其整体连续的假象,并提供随机存取的接口。避开了“重新配置、复制、释放”的轮回,代价则是复杂的迭代器架构。
deque采用一块所谓的map(注意,不是STL的map容器)作为主控。这里所谓map是一小块连续空间,其中每个元素(此处称为一个节点,node)都是指针,指向另一段(较大的)连续线性空间,称为缓冲区。缓冲区才是deque的储存空间主体。SGI STL允许我们指定缓冲区大小,默认值0表示将使用512bytes缓冲区。
当map的空间也不够后,会开辟另一个大的map空间
deque是分段连续空间。维持其“整体连续”假象的任务,落在了迭代器的operator++和operator--两个运算子身上。
deque是双向开口的数据结构,若以deque为底部结构并封闭其头端开口,便轻而易举地形成了一个stack。因此,SGI STL便以deque作为缺省情况下的stack底部结构,stack的实现因而非常简单,源代码十分简短,
heap并不归属于STL容器组件,它是个幕后英雄,扮演priority queue
的助手。顾名思义,priority queue允许用户以任何次序将任何元素推入容器内,但取出时一定是从优先权最高(也就是数值最高)的元素开始取。binary max heap正是具有这样的特性,适合作为priority queue的底层机制。
如果使用list作为priority queue的底层机制,元素插入操作可享常数时间。但是要找到list中的极值,却需要对整个list进行线性扫描。我们也可以改变做法,让元素插人前先经过排序这一关,使得list的元素值总是由小到大(或由大到小),但这么一来,收之东隅却失之桑榆:虽然取得极值以及元素删除操作达到最高效率,可元素的插入却只有线性表现。
以binary search tree作为priority queue的底层机制。这么一来,元素的插入和极值的取得就有O(logN)的表现。
但杀鸡用牛刀,未免小题大做,一来binary search tree的输入需要足够的随机性,二来binary search tree并不容易实现。priority queue的复杂度,最好介于queue和binary search tree 之间,才算适得其所。binary heap便是这种条件下的适当候选人。
binary heap就是一种 complete binary tree(完全二叉树)2,也就是说,整棵binary tree除了最底层的叶节点(s)之外,是填满的,而最底层的叶节点(s)由左至右又不得有空隙。【即是一棵完全搜索二叉树】
实现的是堆排序中的插入操作
1 //向上调整 2 void upAdjust(int L, int R) 3 { 4 int i = R, j = (i - 1) / 2;//i为欲调整结点,j为其父亲 5 while (j >= L) 6 { 7 if (v[j] < v[i])//父节点小了,那么就将孩子节点调上来 8 { 9 swap(v[i], v[j]); 10 i = j; 11 j = (i - 1) / 2;//继续向上遍历 12 } 13 else//无需调整 14 break; 15 } 16 } 17 void insert(int x) 18 { 19 v[n] = x;//将新加入的值放置在数组的最后,切记保证数组空间充足 20 upAdjust(0, n);//向上调整新加入的结点n 21 }
1 //向下调整 2 void downAdjust(int L, int R) 3 { 4 int i = L, j = 2 * L + 1;//i为父节点,j为左子节点 5 while (j <= R) 6 { 7 if (j + 1 <= R && v[j + 1] > v[j])//若有右节点,且右节点大,那么就选右节点,即选取最大的子节点与父节点对比 8 ++j;//选取了右节点 9 if (v[j] <= v[i])//孩子节点都比父节点小,满足条件,无需调整 10 break; 11 //不满足的话,那么我就将最大孩子节点j与父节点i对调, 12 swap(v[i], v[j]); 13 i = j; 14 j = 2 * i + 1;//继续向下遍历 15 } 16 } 17 18 //删除堆顶元素 19 20 void deleteTop() 21 { 22 v[0] = v[n - 1];//也就是堆顶使用最后一个数值来替代 23 downAdjust(0, n - 2);//然后对前n-1个数进行排序 24 }
实现的就是堆排序
1 for (int i = n - 1; i > 0; --i)//从最后开始交换,直到只剩下最后一个数字 2 { 3 swap(v[i], v[0]);//每次都将最大值放到最后 4 downAdjust(0, i - 1);//将前0-i个数字重新构成大根堆 5 }
实现的是堆排序的构建
1 //建堆 2 void createHeap() 3 { 4 for (int i = n / 2; i >= 0; --i) 5 downAdjust(i, n - 1); 6 }
迭代器失效:
·由于vector在扩容时,是在一块新地址上开辟空间,然后将原数据复制过来,并把原来的内存空间给释放了,所以一旦vector发生扩容,那么指向原来迭代器将会失效。
·由于list不是连续空间,所以删除和添加都在原的内存上添加或删除一个空间即可,所以指向原来的迭代器不会失效【除非该迭代器指向的位置被删除了】。
·迭代器不仅可以后移,而且可以前进的,--ptr, ++ptr
标签:binary cat 位置 应该 迭代 缺省 构建 双向链表 遍历
原文地址:https://www.cnblogs.com/zzw1024/p/12079296.html