《数据结构与算法分析》习题-----第二章（3）（关于list的题目）

PS：这两条习题是添加到STL的List代码实现

http://www.cnblogs.com/alan-forever/archive/2012/09/12/2682437.html

3.15 给List类添加splice操作。

void splice（ iterator position， List<Object> & lst )

删除lst中的所有项，并将这些List * this中的位置position之前。lst和*this必须是不同的表，所写的例程必须是常量时间的。

PS：刚开始以为O（n）是常量，最后我发现我严重的错了，之前还想逐个逐个调用inset函数，好吧，我错了。

 1     void splice( iterator position, List<Object> & lst )
 2     {
 3         Node *p = position.current;
 4
 5         p->prev->next = lst.head->next;
 6         lst.head->next->prev = p->prev;
 7         lst.tail->prev->next = p;
 8         p->prev = lst.tail->prev;
 9
10         theSize += lst.size();
11
12         lst.init();
13     }

3.16，给STL List类实现添加逆向迭代器。定义reverse_iterator 和const_reverse_iterator。添加方法rbegin和rend，来分别返回逆向迭代器所指向末尾标记前的项的位置和表头结点的位置，逆向迭代器在内部逆转++和--操作的意义，应该可以使用下面的代码逆向打印链表。

List<int>::reverse_iterator itr1 = l1.rbegin();
while( itr1 != l1.rend() )
cout << *itr1++ <<" ";
cout << endl;

PS：代码里面的注释有点不正确，只是含糊解释。

PS：下图有助于理解迭代器！！！！

下面的代码是逆向迭代器类的定义。

  1     class const_reverse_iterator
  2     {
  3     public:
  4         const_reverse_iterator( ) : current( NULL ) { }
  5
  6         const Object & operator* ( ) const
  7         {
  8             return retrieve( );
  9         }
 10
 11         const_reverse_iterator & operator++ ( )
 12         {
 13             current = current->prev;
 14             return * this;
 15         }
 16
 17         const_reverse_iterator  operator++ ( int )
 18         {
 19             const_reverse_iterator old = *this;
 20             ++( *this );
 21             return old;
 22         }
 23
 24         const_reverse_iterator & operator--  ( )
 25         {
 26             current = current->next;
 27             return * this;
 28         }
 29
 30         const_reverse_iterator  operator-- ( int )
 31         {
 32             const_reverse_iterator old = *this;
 33             ++( *this );
 34             return old;
 35         }
 36
 37         bool operator== ( const const_reverse_iterator & rhs ) const
 38         {
 39             return current == rhs.current;
 40         }
 41
 42         bool operator!= ( const const_reverse_iterator & rhs ) const
 43         {
 44             return !( *this == rhs );
 45         }
 46
 47     private:
 48         Node * current;
 49
 50         Object & retrieve( ) const
 51         {
 52             return current->data;
 53         }
 54
 55         const_reverse_iterator( Node * p ) : current( p ) { }
 56
 57         friend class List<Object>;
 58     };
 59     //逆向迭代器
 60
 61     class reverse_iterator
 62     {
 63     public:
 64         reverse_iterator( ) : current( NULL ) { }
 65
 66         const Object & operator* ( ) const
 67         {
 68             return retrieve( );
 69         }
 70
 71         reverse_iterator & operator++ ( )
 72         {
 73             current = current->prev;
 74             return * this;
 75         }
 76
 77         reverse_iterator  operator++ ( int )
 78         {
 79             reverse_iterator old = *this;
 80             ++( *this );
 81             return old;
 82         }
 83
 84         const_reverse_iterator & operator--  ( )
 85         {
 86             current = current->next;
 87             return * this;
 88         }
 89
 90         reverse_iterator  operator-- ( int )
 91         {
 92             const_reverse_iterator old = *this;
 93             --( *this );
 94             return old;
 95         }
 96
 97         bool operator== ( const reverse_iterator & rhs ) const
 98         {
 99             return current == rhs.current;
100         }
101
102         bool operator!= ( const reverse_iterator & rhs ) const
103         {
104             return !( *this == rhs );
105         }
106
107     private:
108         Node * current;
109
110         Object & retrieve( ) const
111         {
112             return current->data;
113         }
114
115         reverse_iterator( Node * p ) : current( p ) { }
116
117         friend class List<Object>;
118     };

下面代码是返回特殊位置的迭代器

 1 reverse_iterator rbegin( )
 2     {
 3         return reverse_iterator( tail->prev );
 4     }
 5     const_reverse_iterator rbegin( ) const
 6     {
 7         return const_reverse_iterator( tail->prev );
 8     }
 9     //逆向begin迭代器，返回tail的前一个迭代器。
10
11     reverse_iterator rend( )
12     {
13         return reverse_iterator( head );
14     }
15     const_reverse_iterator rend( ) const
16     {
17         return const_reverse_iterator( head );
18     }
19     //逆向end迭代器，返回head节点的迭代器。

转载于:https://www.cnblogs.com/alan-forever/archive/2012/10/15/2725290.html

《数据结构与算法分析》习题-----第二章（3）（关于list的题目）相关推荐

数据结构和算法分析：第二章算法分析
算法是为求解一个问题所要遵循的,被清楚指定的简单指令的集合. 2.1 数学基础相对增长率大O标记法 2.2 模型为了正式的架构中分析算法,我们需要一个计算模型.我们的模型基本上是一台标准的计算机 ...
python数据结构题目_《数据结构与算法Python语言描述》习题第二章第三题（python版）...
ADT Rational: #定义有理数的抽象数据类型 Rational(self, int num, int den) #构造有理数num/den +(self, Rational r2) #求出本 ...
数据结构与算法分析-第2章
<?xml version="1.0" encoding="utf-8"?> 数据结构与算法分析-第2章数据结构与算法分析-第2章 Table o ...
比特数据结构与算法（第二章收尾）带头双向循环链表的实现
1.链表的分类链表的分类 ① 单向或者双向 ② 带头或者不带头 ③ 循环或者非循环常用的链表: 根据上面的分类我们可以细分出8种不同类型的链表,这么多链表我们一个个讲解这并没有意义.我们实际中最常 ...
ADSP重点习题第二章-第三章（原版书第四章）
ADSP重点习题第二章例题2.1.5 习题2.12 习题2.13 第三章习题3.2 习题3.7 尤利-沃克方程: PACS(部分自相关序列的计算) 习题3.11 习题3.21 低阶极点模型(低阶 ...
java中北大学ppt总结+课后习题第二章（小宇特详解）
java中北大学ppt总结+课后习题第二章(小宇特详解) 基本数据类型 Java语言有8种基本数据类型. 逻辑类型:boolean.1字节整数类型: 1字节整数类型:byte. 2字节整数类型:sh ...
《算法设计与分析（第4版）》课后习题第二章第2小题
<算法设计与分析(第4版)>课后习题第二章第2小题下面的7个算法与本章中的二分搜索算法binarySearch略有不同.请判断这7个算法的正确性,并说明原因和证明. 第二章二分搜索算法b ...
《Python数据结构与算法分析》第一章课后习题
这里写自定义目录标题 Introduction 练习题 Python易错总结: Introduction 最近开始学数据结构,打算用python作为语言,看的书是米勒和戴维的<Python数据结 ...
为什么我要放弃javaScript数据结构与算法（第二章）—— 数组
第二章数组几乎所有的编程语言都原生支持数组类型,因为数组是最简单的内存数据结构.JavaScript里也有数组类型,虽然它的第一个版本并没有支持数组.本章将深入学习数组数据结构和它的能力. 为什么 ...
【Java数据结构与算法】第二章单链表及简单面试题
第二章单链表文章目录第二章单链表一.单链表 1.基本介绍 2.思路 3.代码实现二.简单面试题 1.求单链表中有效节点的个数 2.查找单链表中的倒数第k个节点(新浪面试题) 3.单链表的反 ...

《数据结构与算法分析》习题-----第二章（3）（关于list的题目）

《数据结构与算法分析》习题-----第二章（3）（关于list的题目）相关推荐

最新文章

热门文章