《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——跳表
2014-07-07 23:50
323 查看
2014.07.07 22:03
简介:
跳表(skip list)是一种随机化的有序数据结构。从形状上来看,长得比较像分层索引。能够在接近对数级别的时间内完成增、删、改、查操作。
你姑且可以认为这种数据结构的用途、用法都和平衡树很相似,但内部的实现原理则完全不同。
图示:
下面是一条有序的单链表:
如果你要查找某一个整数,必然需要O(n)级别的时间去搜索链表。
但如果从这个链表抽取几个元素,然后在上面加上一层呢,比如这样:
上面的双层链表的上层是通过从下层抽取一部分元素得到的。并且上下之间也存在指针链接,允许由上至下、由左至右的遍历。
这么做有什么用呢?我们先继续看看这个:
我们可以像这样,从每一层选出部分元素,在正上方组成新的一层,这样就能够形成一个看起来不整齐的多层链表。
这个图形很不规则,我们来考虑一个规则的情况:如果这个多层链表恰好有5层,每层元素个数分别为1,2,4,8,16。那么查找任意一个元素是不是能够在对数时间内完成呢?
答案当然是可以。因为多层索引的代表结构——B+树就是这种形状规则而且有序的分层结构。稳定的对数级别的操作时间就是它们的最大优势。
跳表使用另一种思维方式来构造一个类似的分层结构,但是因为包含了随机数而导致形状没那么“规则”,所以效率接近对数级别,但不稳定。
刚才我们的描述方式是一层一层地构建了这个多层链表,而正确的理解方式应该是——一个一个地插入节点。关键在于每个插入的节点有可能只插入一层,也有可能插入多层。
下面是一个空的跳表:
其中begin表示一个实际的节点,尽管其中的数据没有意义,我们需要它的指针进行移动。end则可以用空指针NULL来代表,表示链表尾。
下面如果我们要插入一个整数34,并且插入的高度是3层,结果将是这样:
如此一来有了3个34。接下来我们再插入5,插入1层:
那么插入的规则是怎么定的呢?比如将元素x插入到第k层?
如果我们将最底层定义为1层,那么x元素将被插入到1~k的所有层中。
当你从跳表的左端顶部的begin节点出发时,在每一层你都只能至多向右或向下走一步。
由于每一层的链表都是有序的,所以插入元素时每一层的操作就和有序单链表的操作一样了。
于是我们从第k层开始插入,完成后下降到k-1层,逐层插入直到最底层。
下面我们再插入元素7,高度为2:
那么,每个元素插入的高度怎么决定呢?随机定就行了。此处“随机”的方法,指的是抛硬币。
如果每次有50%的概率抛出正面,那么我们就一直抛硬币,抛出正面为止,看看到底要抛多少次。将抛硬币的次数作为高度(至少抛一次,所以高度至少为1)。
这样的随机方法严格服从于p=0.5的几何分布。因此期望高度为2,虽然偶尔也能出现很高的层数。
那么,这种多层的结构并不是严格的二分查找,为何它的基本操作的效率接近对数级呢?
1. 越是在高层,移动一步就能跨过越多的元素,步子越大速度越快
2. 分析一下几何分布的分布列,此处从概率上是符合二分规律的,因此“接近对数”是有理论支持的
教材上对于跳表的评价是:一种平衡树的替代品,实现简便,效率不错。
亲自实现之后,发现跳表虽然也没那么简单,但的确比AVL树简单多了。也许我们基本不需要亲自写这些结构,但至少应该了解这种随机化的数据结构为何如此巧妙。
在我的印象里,这本书的第十章尽管充满了精华知识,在我大二的数据结构课程里,老师却几乎只字未提。
就我们学校而言,计算机教育实在是囫囵吞枣。课程好几十门,没有一门深入过。难怪我现在复习这本教材几乎等于重新学习。
呵呵的是教育,惭愧的是自己。你区区一个本科生,既然什么都不会就别拽了。赶紧学习吧。
(跳表还可以进一步优化为确定性跳表,不过那部分我已经无力研究了,饶了我吧)
实现:
简介:
跳表(skip list)是一种随机化的有序数据结构。从形状上来看,长得比较像分层索引。能够在接近对数级别的时间内完成增、删、改、查操作。
你姑且可以认为这种数据结构的用途、用法都和平衡树很相似,但内部的实现原理则完全不同。
图示:
下面是一条有序的单链表:
如果你要查找某一个整数,必然需要O(n)级别的时间去搜索链表。
但如果从这个链表抽取几个元素,然后在上面加上一层呢,比如这样:
上面的双层链表的上层是通过从下层抽取一部分元素得到的。并且上下之间也存在指针链接,允许由上至下、由左至右的遍历。
这么做有什么用呢?我们先继续看看这个:
我们可以像这样,从每一层选出部分元素,在正上方组成新的一层,这样就能够形成一个看起来不整齐的多层链表。
这个图形很不规则,我们来考虑一个规则的情况:如果这个多层链表恰好有5层,每层元素个数分别为1,2,4,8,16。那么查找任意一个元素是不是能够在对数时间内完成呢?
答案当然是可以。因为多层索引的代表结构——B+树就是这种形状规则而且有序的分层结构。稳定的对数级别的操作时间就是它们的最大优势。
跳表使用另一种思维方式来构造一个类似的分层结构,但是因为包含了随机数而导致形状没那么“规则”,所以效率接近对数级别,但不稳定。
刚才我们的描述方式是一层一层地构建了这个多层链表,而正确的理解方式应该是——一个一个地插入节点。关键在于每个插入的节点有可能只插入一层,也有可能插入多层。
下面是一个空的跳表:
其中begin表示一个实际的节点,尽管其中的数据没有意义,我们需要它的指针进行移动。end则可以用空指针NULL来代表,表示链表尾。
下面如果我们要插入一个整数34,并且插入的高度是3层,结果将是这样:
如此一来有了3个34。接下来我们再插入5,插入1层:
那么插入的规则是怎么定的呢?比如将元素x插入到第k层?
如果我们将最底层定义为1层,那么x元素将被插入到1~k的所有层中。
当你从跳表的左端顶部的begin节点出发时,在每一层你都只能至多向右或向下走一步。
由于每一层的链表都是有序的,所以插入元素时每一层的操作就和有序单链表的操作一样了。
于是我们从第k层开始插入,完成后下降到k-1层,逐层插入直到最底层。
下面我们再插入元素7,高度为2:
那么,每个元素插入的高度怎么决定呢?随机定就行了。此处“随机”的方法,指的是抛硬币。
如果每次有50%的概率抛出正面,那么我们就一直抛硬币,抛出正面为止,看看到底要抛多少次。将抛硬币的次数作为高度(至少抛一次,所以高度至少为1)。
这样的随机方法严格服从于p=0.5的几何分布。因此期望高度为2,虽然偶尔也能出现很高的层数。
那么,这种多层的结构并不是严格的二分查找,为何它的基本操作的效率接近对数级呢?
1. 越是在高层,移动一步就能跨过越多的元素,步子越大速度越快
2. 分析一下几何分布的分布列,此处从概率上是符合二分规律的,因此“接近对数”是有理论支持的
教材上对于跳表的评价是:一种平衡树的替代品,实现简便,效率不错。
亲自实现之后,发现跳表虽然也没那么简单,但的确比AVL树简单多了。也许我们基本不需要亲自写这些结构,但至少应该了解这种随机化的数据结构为何如此巧妙。
在我的印象里,这本书的第十章尽管充满了精华知识,在我大二的数据结构课程里,老师却几乎只字未提。
就我们学校而言,计算机教育实在是囫囵吞枣。课程好几十门,没有一门深入过。难怪我现在复习这本教材几乎等于重新学习。
呵呵的是教育,惭愧的是自己。你区区一个本科生,既然什么都不会就别拽了。赶紧学习吧。
(跳表还可以进一步优化为确定性跳表,不过那部分我已经无力研究了,饶了我吧)
实现:
// My implementation for skip list. #include <cstdlib> #include <ctime> #include <iostream> #include <string> using namespace std; template <class TKey> struct ListNode { TKey *key; ListNode *down; ListNode *next; ListNode(): key(nullptr), down(nullptr), next(nullptr) {} }; template <class TKey> class SkipList { public: SkipList() { m_root = new ListNode<TKey>(); m_size = 0; m_level = 0; } bool contains(const TKey &key) { if (m_size == 0) { return false; } ListNode<TKey> *ptr = m_root; while (true) { if (ptr->next != nullptr) { if (key < *(ptr->next->key)) { if (ptr->down != nullptr) { ptr = ptr->down; } else { return false; } } else if (key > *(ptr->next->key)) { ptr = ptr->next; } else { return true; } } else { if (ptr->down != nullptr) { ptr = ptr->down; } else { return false; } } } } void insert(const TKey &key) { if (contains(key)) { return; } ListNode<TKey> *ptr; int new_level = _randomLevel(); if (new_level > m_level) { // Extra levels need to be added. for (int i = m_level; i < new_level; ++i) { ptr = new ListNode<TKey>(); ptr->down = m_root; m_root = ptr; } m_level = new_level; } int lvl = m_level; ListNode<TKey> *last, *cur; ptr = m_root; last = cur = nullptr; while (true) { if (ptr->next != nullptr) { if (key < *(ptr->next->key)) { if (lvl <= new_level) { cur = new ListNode<TKey>(); if (last == nullptr) { cur->key = new TKey(key); } else { cur->key = last->key; last->down = cur; } last = cur; cur->next = ptr->next; ptr->next = cur; } if (ptr->down != nullptr) { ptr = ptr->down; --lvl; } else { break; } } else if (key > *(ptr->next->key)) { ptr = ptr->next; } else { break; } } else { if (lvl <= new_level) { cur = new ListNode<TKey>(); if (last == nullptr) { cur->key = new TKey(key); } else { cur->key = last->key; last->down = cur; } last = cur; cur->next = ptr->next; ptr->next = cur; } if (ptr->down != nullptr) { ptr = ptr->down; --lvl; } else { break; } } } ++m_size; } void erase(const TKey &key) { if (!contains(key)) { return; } ListNode<TKey> *ptr = m_root; ListNode<TKey> *cur; while (true) { if (ptr->next != nullptr) { if (key < *(ptr->next->key)) { if (ptr->down != nullptr) { ptr = ptr->down; } else { break; } } else if (key > *(ptr->next->key)) { ptr = ptr->next; } else { cur = ptr->next; ptr->next = cur->next; if (ptr->down != nullptr) { delete cur; ptr = ptr->down; } else { delete cur->key; delete cur; break; } } } else { if (ptr->down != nullptr) { ptr = ptr->down; } else { break; } } } --m_size; ptr = m_root; while (ptr->next == nullptr) { // Empty levels are removed. if (ptr->down == nullptr) { break; } else { m_root = m_root->down; delete ptr; ptr = m_root; --m_level; } } } size_t size() { return m_size; } void clear() { _clearUp(); m_root = new ListNode<TKey>(); m_size = 0; m_level = 0; } void debugPrint() { ListNode<TKey> *p1, *p2; cout << '{' << endl; p1 = m_root; while (p1 != nullptr) { p2 = p1->next; cout << " "; while (p2 != nullptr) { cout << *(p2->key) << ' '; p2 = p2->next; } cout << endl; p1 = p1->down; } cout << '}' << endl; } ~SkipList() { _clearUp(); } private: int m_level; int m_size; ListNode<TKey> *m_root; void _clearUp() { ListNode<TKey> *head = m_root; ListNode<TKey> *p1, *p2; while (head != nullptr) { p1 = head; head = head->down; while (p1 != nullptr) { p2 = p1->next; if (p1->key != nullptr && p1->down == nullptr) { delete p1->key; } delete p1; p1 = p2; } } } int _randomLevel() { int level = 0; while (rand() & 1) { ++level; } return level; } }; int main() { srand((unsigned int)time(nullptr)); string s; SkipList<int> sl; int key; while (cin >> s) { if (s == "i") { cin >> key; sl.insert(key); } else if (s == "c") { cin >> key; cout << (sl.contains(key) ? "Yes" : "No") << endl; } else if (s == "e") { cin >> key; sl.erase(key); } else if (s == "cl") { sl.clear(); } sl.debugPrint(); } sl.clear(); return 0; }
相关文章推荐
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——质数检验
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——平面最近点对
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——拿石头游戏
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——Minimax策略
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——收费站重建问题
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——Alpha-Beta剪枝
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——Strassen矩阵乘法
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——Huffman编码
- 《数据结构与算法分析:C语言描述》复习——第十章“算法设计技巧”——矩阵连乘问题
- 【算法复习三】算法设计技巧与优化----各种背包问题总结
- 【算法复习三】算法设计技巧与优化----算法设计技巧之中位数
- 【算法复习三】算法设计技巧与优化----各种背包问题总结
- 【算法复习三】算法设计技巧与优化----算法设计技巧之中位数
- 【算法复习三】算法设计技巧与优化----算法设计技巧
- 【算法复习三】算法设计技巧与优化----算法设计技巧
- AutoPilot高层次综合C算法设计技巧-移位寄存器
- 设计技巧15:模板方法 Template Method 在一个方法中定义一个算法的骨架,而将一些步骤延迟的子类中,实现Ioc
- 算法设计技巧与分析
- 【算法】算法设计技巧
- 数据结构与算法分析(六)——算法设计技巧