├── Chapter03
    ├── List.h
    ├── README.md
    ├── test.cpp
    ├── Queue.h
    ├── Vector.h
    ├── Stack.h
    └── SimpleCalculator.h
├── Data-Structure.vcxproj.user
├── Chapter02
    ├── README.md
    ├── exercise02.cpp
    ├── example.h
    └── exercise02.h
├── Chapter01
    ├── README.md
    ├── exercise01.cpp
    └── exercise01.h
├── Chapter08
    ├── test.cpp
    ├── README.md
    └── DisjSets.h
├── Chapter04
    ├── README.md
    ├── test.cpp
    ├── BinarySearchTree.h
    ├── exercise04.h
    └── AVLTree.h
├── Chapter05
    ├── README.md
    ├── test.cpp
    ├── HashTable(Separate_Chaining).h
    └── HashTable(Open_Addressing_Hashing).h
├── Data-Structure.vcxproj.filters
├── Chapter07
    ├── Timer.h
    ├── test.cpp
    ├── README.md
    └── Sort.h
├── Chapter06
    ├── test.cpp
    ├── README.md
    ├── BinaryHeap.h
    ├── LeftistHeap.h
    └── BinomialQueue.h
├── Data-Structure.sln
├── README.md
├── .gitattributes
├── .gitignore
├── Data-Structure.vcxproj
└── LICENSE


/Chapter03/List.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i-square/Data-Structure/HEAD/Chapter03/List.h


--------------------------------------------------------------------------------
/Data-Structure.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup>
4 |     <ShowAllFiles>true</ShowAllFiles>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/Chapter02/README.md:
--------------------------------------------------------------------------------
 1 | # 第二章 算法分析
 2 | 
 3 | ## 内容
 4 | * 主要内容是复杂度分析
 5 | * 大O标记
 6 | * 计算大O时的一般法则
 7 |     - 对数规律的一般法则  
 8 |       如果一个算法用常数时间（O(1)）将问题的大小削减为其一部分（通常是1/2），那么该算法就是O(logN)的。
 9 | 
10 | ## 例子
11 | 1. 二分搜索提供了O(logN)的查找算法
12 | 2. 最大公因数的欧几里得算法也是O(logN)的
13 | 3. 幂运算的递归算法


--------------------------------------------------------------------------------
/Chapter01/README.md:
--------------------------------------------------------------------------------
 1 | # 第一章 引论
 2 | 
 3 | ## 内容
 4 | 
 5 | * 介绍基本数学知识
 6 | * 简要复习递归
 7 | * 介绍用到的C++知识
 8 | 
 9 | ## 递归的四条基本法则
10 | 1. 基准情形。必须总有某些基准情形不用递归就能求解。  
11 | 2. 不断推进。对于那些需要递归求解的情形，递归调用必须总能够朝着基准情形的方向推进。  
12 | 3. 设计法则。假设所有的递归调用都能运行。  
13 | 4. 合成效益法则。在求解一个问题的同一实例时，切勿在不同的递归调用中做重复性的工作。


--------------------------------------------------------------------------------
/Chapter03/README.md:
--------------------------------------------------------------------------------
 1 | # 表、栈和队列
 2 | 
 3 | ## 内容
 4 | * 介绍三种基本的数据结构
 5 | * 介绍抽象数据类型(ADT, abstract data type)的概念
 6 | * 介绍栈ADT及其在实现递归方面的应用
 7 | * 介绍队列ADT及其在操作系统和算法设计中的应用
 8 | * 给出vector和list的重要子集的实现
 9 | 
10 | ## 栈
11 | ### 实现
12 | 栈是一个表，因此任何实现表的方法都能实现栈。
13 | ### 应用
14 | 1. 符号平衡
15 | 2. 后缀（逆波兰）表达式计算
16 | 3. 中缀到后缀的转换
17 | 4. 函数调用  
18 | （代码实现了一个简单的计算器，应保证输入合法）
19 | 
20 | ## 总结
21 | ### 快慢指针
22 | ex 3.34 提示：判断一个链表是否有环，只使用O(1)的额外空间，使用两个迭代器p,q p每次递增1，q每次递增2，若q到了末尾则没环，否则pq必定在环中间相遇
23 | 
24 | 也可用于快速找出单链表的中间节点


--------------------------------------------------------------------------------
/Chapter01/exercise01.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "exercise01.h"
 4 | 
 5 | int main()
 6 | {
 7 |     OrderedCollection<int> ARR;
 8 | 
 9 |     int temp = 0;
10 |     cout << "Please input some numbers(-1 means end): ";
11 |     while ((cin >> temp) && (temp != -1))
12 |         ARR.insert(temp);
13 |     
14 |     if (ARR.size()) {
15 |         cout << "Max number is: " << *ARR.findMax() << endl;
16 |         cout << "Min number is: " << *ARR.findMin() << endl;
17 |     }
18 | 
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Chapter08/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | #include "DisjSets.h"
 5 | 
 6 | int main()
 7 | {
 8 |     DisjSets One(5000);
 9 | 
10 |     int root1 = 0, root2 = 0;
11 |     for (int i = 10; i < 1000; ++i) {
12 |         root1 = One.find(2 * i + 1);
13 |         root2 = One.find(3 * i + 1);
14 |         One.unionSets(root1, root2);
15 |     }
16 |     for (int i = 0; i < 1000; ++i) {
17 |         cout << i << " : " << One.find(i) << endl;
18 |     }
19 | 
20 |     getchar();
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Chapter02/exercise02.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "exercise02.h"
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     maxInfo i;
10 |     vector<int> arr;
11 |     int temp = 0;
12 |     cout << "Please input some numbers: ";
13 |     while (cin >> temp) {
14 |         arr.push_back(temp);
15 |     }
16 | 
17 |     cout << "最小连续子序列和: " << minSubSum(arr) << endl;
18 |     
19 |     i = maxSubSum(arr);
20 |     cout << "最大连续子序列和: " << i.Sum << ", 起始下标: " << i.begin << ", 结束下标: " << i.end << endl;
21 |      
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Chapter04/README.md:
--------------------------------------------------------------------------------
 1 | # 树
 2 | 
 3 | ## 内容
 4 | * 了解树是如何用于实现文件系统的
 5 | * 了解树如何用来计算算术表达式的值
 6 | * 了解如何用树实现O(logN)时间进行搜素
 7 | * 讨论并使用set和map
 8 | 
 9 | ## 二叉树的遍历
10 | * 前序：先处理自己后处理左右儿子
11 | * 中序：先处理左儿子再处理自己再处理右儿子
12 | * 后序：先处理左右儿子再处理自己
13 | 
14 | ## 二叉查找树（平均深度O(logN)）
15 | 性质：对于树中的每个节点X，左子树中所有项的值小于X中的项，右子树中所有项的值大于X中的项  
16 | 缺点：不能动态调整，若输入为已排序序列则构造出最坏情况下的斜树
17 | 
18 | ## AVL树
19 | * 带有**平衡条件**的二叉查找树
20 | * 一棵AVL树是每个节点的左子树和右子树的高度最多相差1的二叉查找树（空树高度定义为-1）
21 | * 插入新节点可能破坏AVL树的平衡，需要通过**旋转**解决
22 | 
23 | 把需要平衡的节点叫α  
24 | 
25 | 1. 对α的左儿子的左子树进行一次插入
26 | 2. 对α的左儿子的右子树进行一次插入
27 | 3. 对α的右儿子的左子树进行一次插入
28 | 4. 对α的右儿子的右子树进行一次插入
29 | 
30 | 1和4（左左，右右）发生在外边，进行一次**单旋转**即可，2和3（左右，右左）则发生在内部，需要通过**双旋转**调整
31 | 
32 | ## 伸展树
33 | 节点可以达到任意深度，每次访问某节点后把该节点调整为根节点，任意连续M次操作花费O(MlogN)时间
34 | 
35 | ## B树（平衡M路树）
36 | M=3时：2-3树，实现平衡查找树的另一种方法
37 | 
38 | ## 注意
39 | 通过插入元素构造查找树，然后执行中序遍历，可以得到排序后的元素。  
40 | 这是一种O(NlogN)的排序算法


--------------------------------------------------------------------------------
/Chapter08/README.md:
--------------------------------------------------------------------------------
 1 | # 不相交集类
 2 | 这一章介绍解决等价问题的一种有效数据结构。实现简单，也非常快，每种操作只需要常数平均时间。
 3 | 
 4 | ## 等价关系 (equivalence relation)
 5 | 若对于每一对元素(a,b),a,b∈S, `a R b`或者为true或者为false，则称在集合S上定义关系R。如果`a R b`为true，我们说a和b有关系。
 6 | 
 7 | **等价关系**是满足下列三个性质的关系R：
 8 | 
 9 | 1. 自反性：对于所有的a∈S，`a R a`
10 | 2. 对称性：`a R b`当且仅当`b R a`
11 | 3. 传递性：若`a R b`且b R c则`a R c`
12 | 
13 | 元素a∈S的**等价类**(equivalence class)是S的子集，它包含所有与a有（等价）关系的元素。注意，等价类形成对S的一个划分：S的每一个成员恰好出现在一个等价类中。为确定是否a~b，我们只需验证a和b是否都在同一个等价类中。
14 | 
15 | 输入数据最初是N个集合(collection)的类，每个集合含有一个元素。初始的描述是所有的关系均为false（自反的关系除外）。每个集合都有一个不同的元素，从而`Si∩Sj=⊙`，称为**不相交**(disjoint)
16 | 
17 | 基本操作有两种，称为**求并/查找**(union/find)算法。
18 | 
19 | ## 灵巧求并算法
20 | 直观的union操作相当随意，它简单地通过使第二棵树成为第一棵树的子树而完成合并。对其进行简单改进，使得总是较小的树成为较大的树的子树，称为**按大小求并**(union by size)，它保证树的深度最大是O(logN)。  
21 | 连续M次操作平均需要O(M)时间。
22 | 
23 | 另一种方法是**按高度求并**(union by height)，它同样保证树的深度最大是O(logN)。做法是使浅的树成为深的树的子树。
24 | 
25 | ## 一个应用
26 | 应用求并/查找数据结构的一个例子是迷宫的生成。初始化时所有格子都在自己的等价类中，之后不断合并，最终生成迷宫。


--------------------------------------------------------------------------------
/Chapter08/DisjSets.h:
--------------------------------------------------------------------------------
 1 | #ifndef DS_CH08_DISJSETS_H
 2 | #define DS_CH08_DISJSETS_H
 3 | 
 4 | #include <vector>
 5 | 
 6 | class DisjSets {
 7 | public:
 8 |     explicit DisjSets(int numElements) : s(numElements, -1) {}
 9 | 
10 |     int find(int x) const
11 |     {
12 |         if (s[x] < 0)
13 |             return x;
14 |         else
15 |             return find(s[x]);
16 |     }
17 |     //路径压缩
18 |     int find(int x)
19 |     {
20 |         if (s[x] < 0)
21 |             return x;
22 |         else
23 |             return s[x] = find(s[x]);
24 |     }
25 |     //按高度求并 初始为-1，存储高度-1
26 |     void unionSets(int root1, int root2)
27 |     {
28 |         if (s[root2] < s[root1])
29 |             s[root1] = root2;
30 |         else {
31 |             if (s[root1] == s[root2])
32 |                 --s[root1]; //更新高度
33 |             s[root2] = root1;
34 |         }
35 |     }
36 | 
37 | private:
38 |     std::vector<int> s;
39 | };
40 | 
41 | #endif // DS_CH08_DISJSETS_H
42 | 


--------------------------------------------------------------------------------
/Chapter05/README.md:
--------------------------------------------------------------------------------
 1 | # 散列
 2 | 散列表（hash table）的实现通常称为散列（hashing），指用于以O(1)时间执行插入、删除和查找的技术，但不支持需要排序信息的树操作，比如findMin、findMax以及在线性时间内按顺序打印整个表都不支持
 3 | 
 4 | ## 内容
 5 | 中心数据结构是**散列表**
 6 | 
 7 | * 实现散列表的几种方法
 8 | * 分析比较几种方法
 9 | * 介绍散列的多种应用
10 | * 比较散列表与二叉查找树
11 | 
12 | ## 散列函数
13 | 基本思想：将每个键(Key)映射到从[0, TableSize)这个范围中的某个数，并且将其放到适当的单元中，这个映射就称为**散列函数**。  
14 | 问题：选择一个函数，决定当两个键散列到同一个值的时候（称为**冲突(collision)**应该做什么以及如何确定散列表的大小。  
15 | _注：一般使表的大小为素数，有助于避免部分冲突问题_
16 | 
17 | ## 装填因子(load factor)
18 | 定义散列表的装填因子 λ 为散列表中的元素个数与散列表大小的比值。
19 | 
20 | ## 分离链接法
21 | 将散列到同一个值的所有元素保留到一个链表中。  
22 | 一般法则：使 λ ≈ 1，控制链表的长度，若 λ > 1 则通过再散列扩充
23 | 
24 | ## 开放定址法
25 | 不用链表存储，实现分配较大空间，称为**探测散列表**  
26 | hi(x) = (hash(x) + f(i)) mod TableSize, f(0) = 0.  
27 | 一般 λ > 0.5 就要再散列
28 | 
29 | * 线性探测 f(i) = i
30 | * 平方探测 f(i) = i^2
31 | * 双散列 f(i) = i * hash2(x), hash2(x) = R - (x mod R) 这样的函数会起作用，其中R为小于TableSize的素数
32 | 
33 | ## 再散列(rehash)
34 | 1. 只要表到一半就再散列
35 | 2. 只有插入失败时才再散列
36 | 3. 途中策略：当表到达某一个装填因子时进行再散列（最优）
37 | 


--------------------------------------------------------------------------------
/Chapter05/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <random>
 3 | #include <chrono>
 4 | 
 5 | using namespace std;
 6 | 
 7 | #include "HashTable(Separate_Chaining).h"
 8 | #include "HashTable(Open_Addressing_Hashing).h"
 9 | 
10 | int main()
11 | {
12 |     default_random_engine e(static_cast<unsigned int>(time(nullptr)));
13 |     uniform_int_distribution<int> u(0, 10000);
14 | 
15 |     int arr[10000] = { 0 };
16 |     for (int i = 0; i < 10000; ++i)
17 |         arr[i] = u(e);
18 | 
19 |     HashTable_SC<int> tableSC(100);
20 |     HashTable_OAH<int> tableOAH(100);
21 | 
22 |     for (int i = 0; i < 10000; ++i) {
23 |         tableSC.insert(arr[i]);
24 |         tableOAH.insert(arr[i]);
25 |     }
26 | 
27 |     cout << "SC size: " << tableSC.size() << ", find " << arr[5] << " ? " 
28 |          << boolalpha << tableSC.contains(arr[5]) << endl;
29 |     cout << "OAH size: " << tableOAH.size() << ", find " << arr[5] << " ? "
30 |         << boolalpha << tableOAH.contains(arr[5]) << endl;
31 | 
32 |     getchar();
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/Chapter03/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "SimpleCalculator.h"
 4 | #include "Queue.h"
 5 | #include "List.h"
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |     SimpleCalculator cal("14+2-32+8*9+(54*7+92-4)");
12 |     cout << cal.getResult() << endl;
13 |     cout << cal.calcu("13+2-32+8*9+(54*7+92-4)") << endl;
14 | 
15 |     int a[20] = { 29, 14, 15, 84, 65, 85, 92, 81, 51, 13, 5, 18, -64, 89, 66, 21, 32, 27, 24, 52 };
16 |     LinkQueue<int> que;
17 |     SingleList<int> lst;
18 |     List<int> dlst;
19 | 
20 |     for (int i = 0; i < 20; ++i) {
21 |         que.enqueue(a[i]);
22 |         lst.add(a[i]);
23 |         dlst.push_back(a[i]);
24 |     }
25 | 
26 |     cout << "queue: ";
27 |     for (int i = 0; i < 20; ++i)
28 |         cout << que.dequeue() << "→";
29 |     cout << endl;
30 | 
31 |     cout << "single list: ";
32 |     lst.print();
33 | 
34 |     cout << dlst.back() << " pop_back: ";
35 |     dlst.pop_back();
36 |     cout << dlst.back() << endl;
37 | 
38 |     getchar();
39 | 
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Chapter02/example.h:
--------------------------------------------------------------------------------
 1 | #ifndef DS_CH02_EXAMPLE_H
 2 | #define DS_CH02_EXAMPLE_H
 3 | 
 4 | #include <vector>
 5 | using std::vector;
 6 | 
 7 | // 二分搜索
 8 | template <typename Comparable>
 9 | int binarySearch(const vector<Comparable> &a, const Comparable &x)
10 | {
11 |     int low = 0, high = a.size() - 1, mid = 0;
12 |     while (low <= high) {
13 |         mid = (low + high) >> 1;
14 |         if (a[mid] < x)
15 |             low = mid + 1;
16 |         else if (a[mid] > x)
17 |             high = mid - 1;
18 |         else
19 |             return mid;
20 |     }
21 |     return -1; // -1 means NOT FOUND
22 | }
23 | 
24 | // 最大公因数的欧几里得算法
25 | long gcd(long m, long n)
26 | {
27 |     while (n != 0) {
28 |         long rem = m % n;
29 |         m = n;
30 |         n = rem;
31 |     }
32 |     return m;
33 | }
34 | 
35 | // 幂运算的递归算法
36 | long pow(long x, int n)
37 | {
38 |     if (n == 0)
39 |         return 1;
40 |     if (n & 1)
41 |         return pow(x, n - 1) * x;
42 |     else
43 |         return pow(x * x, n >> 1);
44 | }
45 | 
46 | #endif // DS_CH02_EXAMPLE_H
47 | 


--------------------------------------------------------------------------------
/Data-Structure.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="源文件">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="头文件">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="资源文件">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClInclude Include="Chapter08\DisjSets.h">
19 |       <Filter>头文件</Filter>
20 |     </ClInclude>
21 |   </ItemGroup>
22 |   <ItemGroup>
23 |     <ClCompile Include="Chapter08\test.cpp">
24 |       <Filter>源文件</Filter>
25 |     </ClCompile>
26 |   </ItemGroup>
27 | </Project>


--------------------------------------------------------------------------------
/Chapter07/Timer.h:
--------------------------------------------------------------------------------
 1 | #ifndef DS_CH07_TIMER_H
 2 | #define DS_CH07_TIMER_H
 3 | 
 4 | #include <chrono>
 5 | using namespace std::chrono;
 6 | 
 7 | class Timer {
 8 | public:
 9 |     using s = seconds;
10 |     using ms = milliseconds;
11 |     using us = microseconds;
12 |     using ns = nanoseconds;
13 | 
14 | public:
15 |     Timer() : tpStart(high_resolution_clock::now()), tpStop(tpStart) {}
16 | 
17 | public:
18 |     void start() { tpStart = high_resolution_clock::now(); }
19 |     void stop() { tpStop = high_resolution_clock::now(); }
20 | 
21 |     template <typename span>
22 |     auto delta() const { return duration_cast<span>(tpStop - tpStart).count(); }
23 | 
24 |     template <typename span>
25 |     auto stop_delta() { stop(); return duration_cast<span>(tpStop - tpStart).count(); }
26 | 
27 |     template <typename span>
28 |     auto stop_delta_start()
29 |     {
30 |         stop();
31 |         auto ts = duration_cast<span>(tpStop - tpStart).count();
32 |         start();
33 |         return ts;
34 |     }
35 | 
36 | private:
37 |     time_point<high_resolution_clock> tpStart;
38 |     time_point<high_resolution_clock> tpStop;
39 | };
40 | 
41 | #endif // DS_CH07_TIMER_H
42 | 


--------------------------------------------------------------------------------
/Chapter07/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <random>
 3 | 
 4 | using namespace std;
 5 | 
 6 | #include "Timer.h"
 7 | #include "Sort.h"
 8 | 
 9 | #define PRINT_SORT_TIME(A, sortfun) \
10 | {\
11 |     vector<int> arrt(A);\
12 |     Timer ts;\
13 |     sortfun(arrt);\
14 |     cout << #sortfun##" " << maxSize << " 个随机数用时: " << ts.stop_delta<Timer::ms>() << " ms" << endl;\
15 | }
16 | 
17 | int main()
18 | {
19 |     const int maxSize = 10000;
20 |     default_random_engine e(static_cast<unsigned int>(time(nullptr)));
21 |     uniform_int_distribution<int> u(1, maxSize);
22 | 
23 |     vector<int> arr;
24 |     for (int i = 0; i < maxSize; ++i)
25 |         arr.push_back(u(e));
26 | 
27 |     if (maxSize <= 1000)
28 |         PRINT_SORT_TIME(arr, insertionSort);
29 |     PRINT_SORT_TIME(arr, shellSort);
30 |     PRINT_SORT_TIME(arr, heapSort);
31 |     PRINT_SORT_TIME(arr, mergeSort);
32 |     PRINT_SORT_TIME(arr, mergeSort2);
33 |     PRINT_SORT_TIME(arr, quickSort);
34 |     {
35 |         vector<int> arr1(arr);
36 |         quickSelect(arr1, 0, maxSize - 1, maxSize >> 1);
37 |         cout << "the median num is: " << arr1[(maxSize >> 1) - 1] << endl;
38 |     }
39 | 
40 |     getchar();
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Chapter06/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <random>
 3 | #include <chrono>
 4 | 
 5 | using namespace std;
 6 | 
 7 | #include "BinaryHeap.h"
 8 | #include "LeftistHeap.h"
 9 | #include "BinomialQueue.h"
10 | 
11 | int main()
12 | {
13 |     const int maxSize = 13;
14 |     default_random_engine e(static_cast<unsigned int>(time(nullptr)));
15 |     uniform_int_distribution<int> u(1, maxSize);
16 | 
17 |     int arr[maxSize] = { 0 };
18 |     for (int i = 0; i < maxSize; ++i)
19 |         arr[i] = u(e);
20 | 
21 |     BinaryHeap<int> BHeap(maxSize);
22 |     LeftistHeap<int> LHeap;
23 |     BinomialQueue<int> BQ;
24 | 
25 |     for (int i = 0; i < maxSize; ++i) {
26 |         BHeap.insert(arr[i]);
27 |         LHeap.insert(arr[i]);
28 |         BQ.insert(arr[i]);
29 |     }
30 | 
31 |     cout << "BHeap size: " << BHeap.size() << ", min: " << BHeap.findMin() << endl;
32 |     cout << "LHeap min: " << LHeap.findMin() << endl;
33 |     cout << "BQ min: " << BQ.findMin() << endl;
34 |     cout << "LHeap:" << endl;
35 |     LHeap.printTree();
36 |     cout << endl << "BinomialQueue:" << endl;
37 |     BQ.printForest();
38 |     BQ.deleteMin();
39 |     cout << "deleteMin:" << endl;
40 |     BQ.printForest();
41 | 
42 |     getchar();
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Chapter02/exercise02.h:
--------------------------------------------------------------------------------
 1 | #ifndef DS_CH02_EXERCISE02_H
 2 | #define DS_CH02_EXERCISE02_H
 3 | 
 4 | #include <vector>
 5 | using std::vector;
 6 | 
 7 | //2.17
 8 | //a.求最小连续子序列和  O(N)算法
 9 | int minSubSum(const vector<int> &a)
10 | {
11 |     int minSum = 0, thisSum = 0;
12 |     for (int i = 0; i < a.size(); ++i) {
13 |         thisSum += a[i];
14 |         if (thisSum < minSum)
15 |             minSum = thisSum;
16 |         else if (thisSum > 0)
17 |             thisSum = 0;
18 |     }
19 |     return minSum;
20 | }
21 | 
22 | //2.19
23 | //返回最大连续子序列和以及对应的下标
24 | struct maxInfo {
25 |     maxInfo() = default;
26 |     int Sum;
27 |     int begin;
28 |     int end;
29 | };
30 | 
31 | maxInfo info;
32 | 
33 | maxInfo maxSubSum(const vector<int> &a)
34 | {
35 |     int thisSum = 0;
36 |     bool isBegin = false;
37 |     for (int i = 0; i < a.size(); ++i) {
38 |         thisSum += a[i];
39 |         if (thisSum > info.Sum) {
40 |             info.Sum = thisSum;
41 |             if (!isBegin) {
42 |                 isBegin = true;
43 |                 info.begin = i;
44 |             }
45 |             info.end = i;
46 |         } else if (thisSum < 0) {
47 |             thisSum = 0;
48 |             isBegin = false;
49 |         }
50 |     }
51 |     return info;
52 | }
53 | 
54 | #endif // DS_CH02_EXERCISE02_H
55 | 


--------------------------------------------------------------------------------
/Data-Structure.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.25420.1
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Data-Structure", "Data-Structure.vcxproj", "{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Debug|x64.Build.0 = Debug|x64
18 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Debug|x86.Build.0 = Debug|Win32
20 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Release|x64.ActiveCfg = Release|x64
21 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Release|x64.Build.0 = Release|x64
22 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Release|x86.ActiveCfg = Release|Win32
23 | 		{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Data-Structure
 2 | 
 3 | ## 代码内容
 4 | 《数据结构与算法分析C++描述拆分》上的代码实现,
 5 | 按照该书的章节顺序，主要实现书上给出的例子，包括部分课后习题。
 6 | 
 7 | ## 文件内容
 8 | 所有实现均~~计划~~给出`.h` `.cpp`文件以及部分用于测试的`test.cpp`文件
 9 | 
10 | ## 环境
11 | - Windows 10 \& 8.1
12 | - Visual Studio 2015 with update 3
13 | - C++ (部分C++11语法)
14 | 
15 | ## 章节列表
16 | ### 第一章 引论 & 第二章 算法分析
17 | :white_check_mark: 部分课后习题+简单例程
18 | ### 第三章 表、栈和队列
19 | :white_check_mark: Vector和List  
20 | :white_check_mark: 链表  
21 | :white_check_mark: 栈  
22 | :white_check_mark: 队列  
23 | ### 第四章 树
24 | :white_check_mark: 二叉查找树  
25 | :white_check_mark: AVL树  
26 | ### 第五章 散列
27 | :white_check_mark: 哈希表（分离链接法）  
28 | :white_check_mark: 哈希表（开放定址法/平方探测）  
29 | ### 第六章 优先队列（堆）
30 | :white_check_mark: 二叉堆  
31 | :white_check_mark: 左式堆  
32 | :white_check_mark: 二项队列  
33 | ### 第七章 排序
34 | :white_check_mark: 插入排序  
35 | :white_check_mark: 希尔排序  
36 | :white_check_mark: 堆排序  
37 | :white_check_mark: 归并排序  
38 | :white_check_mark: 快速排序  
39 | :white_check_mark: 快速选择  
40 | ### 第八章 不相交集类
41 | :white_check_mark: 不相交集  
42 | ### 第九章 图论算法
43 | :white_large_square: 邻接表(Version 1,2)  
44 | :white_large_square: 拓扑排序(Version 1,2)  
45 | :white_large_square: 单源最短路径算法  
46 | :white_large_square: 最大网络流  
47 | :white_large_square: 最小生成树  
48 | :white_large_square: 深度优先搜索  
49 | :white_large_square: 双连通性  
50 | :white_large_square: 欧拉回路  
51 | ### 第十章 算法设计技巧
52 | :white_large_square: 分治算法：最近点问题  
53 | :white_large_square: 动态规划：斐波那契数列，递归关系，矩阵乘法顺序，最优搜索二叉树  
54 | :white_large_square: 随机化算法：跳表  
55 | :white_large_square: 回溯法：收费公路重建，三连棋游戏（带AI）  
56 | ### 第十二章 高级数据结构及其实现
57 | :white_large_square: 红黑树：自顶向下插入，自顶向下删除  
58 | :white_large_square: AA树  
59 | :white_large_square: Treap树  
60 | :white_large_square: Kd树  
61 | :white_large_square: 配对堆  


--------------------------------------------------------------------------------
/Chapter04/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <random>
 3 | #include <chrono>
 4 | 
 5 | using namespace std;
 6 | 
 7 | #include "BinarySearchTree.h"
 8 | #include "AVLTree.h"
 9 | #include "exercise04.h"
10 | 
11 | int main()
12 | {
13 |     default_random_engine e(static_cast<unsigned int>(time(nullptr)));
14 |     uniform_int_distribution<int> u(-50, 50);
15 | 
16 |     int arr[50] = { 0 };
17 |     for (int i = 0; i < 50; ++i)
18 |         arr[i] = u(e);
19 | 
20 |     cout << "BinarySearchTree Test:" << endl;
21 |     BinarySearchTree<int> BSTree;
22 |     for (int i = 0; i < 20; ++i)
23 |         BSTree.insert(arr[i]);
24 | 
25 |     cout << "max: " << BSTree.findMax() << endl;
26 |     cout << "min: " << BSTree.findMin() << endl;
27 |     cout << "是否包含5 ? " << boolalpha << BSTree.contains(5) << endl;
28 |     BSTree.printTree();
29 |     cout << endl << endl << endl;
30 | 
31 |     cout << "AVLTree Test:" << endl;
32 |     AVLTree<int> AvlTree;
33 | 
34 |     for (int i = 0; i < 30; ++i)
35 |         AvlTree.insert(arr[i+20]);
36 | 
37 |     AvlTree.printTree();
38 | 
39 |     cout << endl << "Remove ";
40 |     for (int i = 0; i < 5; ++i) {
41 |         int t = arr[i + 20 + 4 * i];
42 |         cout << t << ",";
43 |         AvlTree.remove(t);
44 |     }
45 |     cout << endl << endl;
46 |     
47 |     AvlTree.printTree();
48 | 
49 |     //ex4.11
50 |     Set<int> st;
51 |     for (int i = 0; i < 50; ++i)
52 |         st.insert(arr[i]);
53 | 
54 |     cout << "Set contains: " << endl;
55 |     Set<int>::const_iterator itr = st.begin();
56 |     for (int i = 0; i < st.size(); ++i, ++itr) {
57 |         cout << *itr << ",";
58 |     }
59 |     cout << endl;
60 |     cout << "erase: " << arr[10] << endl;
61 |     st.erase(arr[10]);
62 |     cout << "Now contains: " << endl;
63 |     itr = st.begin();
64 |     for (int i = 0; i < st.size(); ++i, ++itr) {
65 |         cout << *itr << ",";
66 |     }
67 |     cout << endl;
68 | 
69 |     getchar();
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/Chapter06/README.md:
--------------------------------------------------------------------------------
 1 | # 优先队列（堆）
 2 | 本章讨论优先队列（priority queue），介绍优先队列在离散事件模拟中的应用  
 3 | 作者评价：这类数据结构属于计算机科学中最雅致的一种
 4 | 
 5 | ## 内容
 6 | * 优先队列ADT的高效实现
 7 | * 优先队列的使用
 8 | * 优先队列的高级实现
 9 | 
10 | ## 二叉堆 (binary heap)
11 | 插入删除最坏O(logN)，实际上插入花费常数平均时间，若无删除干扰，该结构将以线性时间建立一个具有N项的优先队列。  
12 | 与二叉查找树一样，堆具有两个性质，堆的操作必须满足所有性质才能终止。
13 | 
14 | ### 结构性质
15 | 堆是一棵**完全二叉树**（三角形缺右下角），特例是满二叉树（三角形），最底层元素必须从左往右填入，如有空缺则不是完全二叉树  
16 | 一棵高为h的完全二叉树有[2^h , 2^(h+1) - 1]个节点，这意味着完全二叉树的高是 下取整(logN)，显然它是O(logN)的  
17 | 因为此规律，所以堆可以用数组表示而不用链表，对于数组中任一位置i上的元素，其左儿子在位置2i上，右儿子在左儿子后的(2i+1)上，它的父亲在位置 下取整(i/2) 上
18 | 
19 | ### 堆序性质
20 | 在堆中，除根节点以外，每一个节点的值都大于（或等于）它的父节点的值  
21 | 根据堆序性质，最小值总在根结点，因此可以以O(1)时间做findMin  
22 | 相应地，通过改变堆序性质，也可以建立一个max堆，以O(1)时间做findMax
23 | 
24 | ### 插入（上滤策略）
25 | 为了插入新元素X，在堆的下一个可用位置（为了满足结构性质）创建一个空穴，若X放入空穴仍满足堆序性质，则插入完成，否则交换空穴和其父节点，直到X被放入并满足堆序性质为止
26 | 
27 | ### 删除（下滤策略）
28 | 找出最小元很容易，难的是删除它。  
29 | 当删除一个最小元时，堆中最后一个元素X必须移动到该堆的某个地方。策略是在根节点建立一个空穴，然后将两个儿子中的较小者移入空穴，重复该步骤直到X可以被放入空穴中。代码中则是用X直接替换根结点的值，然后下滤。
30 | 
31 | ### 注意
32 | 在堆的实现中经常出现的错误是，当堆中存在偶数个元素时，将出现一个节点只有一个儿子的情况。因此我们必须以节点不总有两个儿子为前提，这需要额外的测试。
33 | 
34 | ### 应用
35 | #### 选择问题
36 | 输入N个元素及整数k，找出第k个最大的元素，极端情况是k=上取整(N/2)，此时实际上是找中位数，以下两个算法都能在找中位数的情况下以O(NlogN)时间运行
37 | 
38 | * A 将N个元素读入数组，对数组应用buildHeap，再执行k次deleteMin，最后根节点上的就是第k个最小值，构造一个最大堆就可以找到第k个最大值
39 | * B 用buildHeap将前k个元素构造成一个最大堆，若下一个元素大于堆里的最小值，则删除最小值，插入新元素，最终的最小值就是所求的第k个最大值
40 | 
41 | ## d堆
42 | 类似B树，深度变浅，每个节点有d个儿子
43 | 
44 | ## 左式堆 (leftist heap)
45 | 左式堆也是二叉树，但它不是理想平衡的，事实上是趋于非常不平衡
46 | 
47 | 定义任一节点X的**零路径长(null path length)**npl(X)为从X到一个不具有两个儿子的节点的最短路径长  
48 | 因此，具有0个或1个儿子的节点npl为0，而npl(NULL)=-1  
49 | 注意，任一节点的npl比它儿子节点的npl的最小值多1
50 | 
51 | ### 左式堆性质
52 | 对于堆中的每一个节点X，左儿子的npl至少与右儿子的npl一样大  
53 | 这个性质导致树向左增加深度，沿左式堆右侧的右路径是堆中最短的路径  
54 | 定理：在右路径上有r个节点的左式堆必然至少有2^r -1个节点
55 | 
56 | 对左式堆的基本操作是合并。插入可以看成是合并一个单节点堆，删除即是删掉根结点，然后合并左右子树。
57 | 
58 | ## 斜堆 (skew heap)
59 | 斜堆是左式堆的自调节形式，具有堆序，但不存在结构限制。斜堆不需要存储npl，每次合并无条件交换左右儿子。
60 | 
61 | ## 二项队列 (binomial queue)
62 | 以最坏O(logN)支持插入、合并、deleteMin，插入操作平均花费常数时间
63 | 
64 | 实质是由**二项树**(binomial tree)构成的**森林**(forest)。  
65 | 每一个高度上最多存在一棵二项树。高度为k的二项树Bk是通过将一棵二项树B(k-1)附接到另一棵二项树B(k-1)的根上构成的。高度为k的二项树有2^k个节点，在深度d处的节点数是二项系数C(d,k)
66 | 
67 | 如果把堆序性质施加到二项树上并允许任意高度上最多一棵二项树，则可以用二项树的集合唯一地表示任意大小的优先队列。如大小为13的优先队列可以用B3,B2,B0表示，可以写成1101，同时也是13的二进制形式。
68 | 
69 | ### 操作
70 | 基本操作仍然是合并，思想是从小到大合并相同高度的二项树  
71 | 插入是特殊情况下的合并  
72 | deleteMin将原二项队列一分为二，再合并
73 | 
74 | 编程需要注意**进位**的实现


--------------------------------------------------------------------------------
/Chapter01/exercise01.h:
--------------------------------------------------------------------------------
 1 | #ifndef DS_CH01_EXERCISE01_H
 2 | #define DS_CH01_EXERCISE01_H
 3 | 
 4 | // ex 1.5
 5 | int ones(int n)
 6 | {
 7 |     if (n < 2)
 8 |         return n;
 9 |     return (n & 1) + ones(n >> 1);
10 | }
11 | 
12 | #include <vector>
13 | 
14 | using namespace std;
15 | 
16 | //ex 1.13
17 | template <typename Object>
18 | class Collection {
19 | public:
20 |     typedef typename vector<Object>::const_iterator const_iterator;
21 |     typedef typename vector<Object>::size_type      size_type;
22 | 
23 | public:
24 |     size_type size() const { return arr.size(); }
25 |     bool isEmpty() const { return arr.empty(); }
26 |     void makeEmpty() { arr.clear(); }
27 |     bool contains(const Object &obj) { return _find(obj) != arr.cend(); }
28 |     void insert(const Object &obj) { arr.push_back(obj); }
29 |     void remove(const Object &obj)
30 |     { 
31 |         auto it = _find(obj);
32 |         if (it != arr.cend())
33 |             arr.erase(it);
34 |     }
35 | private:
36 |     const_iterator _find(const Object &obj)
37 |     {
38 |         auto it = arr.cbegin();
39 |         while (it != arr.cend()) {
40 |             if (*it == obj)
41 |                 return it;
42 |             ++it;
43 |         }
44 |         return it;
45 |     }
46 | 
47 | private:
48 |     vector<Object> arr;
49 | };
50 | 
51 | //ex 1.14
52 | template <typename Comparable>
53 | class OrderedCollection {
54 |     typedef typename vector<Comparable>::const_iterator const_iterator;
55 |     typedef typename vector<Comparable>::size_type      size_type;
56 | 
57 | public:
58 |     size_type size() const { return arr.size(); }
59 |     bool isEmpty() const { return arr.empty(); }
60 |     void makeEmpty() { arr.clear(); }
61 |     void insert(const Comparable &obj) { arr.push_back(obj); }
62 |     void remove(const Comparable &obj)
63 |     {
64 |         auto it = arr.cbegin();
65 |         while (it != arr.cend()) {
66 |             if (*it == obj) {
67 |                 arr.erase(it);
68 |                 break;
69 |             }
70 |         }
71 |     }
72 |     const_iterator findMin() const
73 |     {
74 |         size_type minIdx = 0;
75 |         for (size_type i = 1; i < size(); ++i) {
76 |             if (arr[minIdx] > arr[i])
77 |                 minIdx = i;
78 |         }
79 |         return arr.cbegin() + minIdx;
80 |     }
81 |     const_iterator findMax() const
82 |     {
83 |         size_type minIdx = 0;
84 |         for (size_type i = 1; i < size(); ++i) {
85 |             if (arr[minIdx] < arr[i])
86 |                 minIdx = i;
87 |         }
88 |         return arr.cbegin() + minIdx;
89 |     }
90 | 
91 | private:
92 |     vector<Comparable> arr;
93 | };
94 | 
95 | #endif // DS_CH01_EXERCISE01_H
96 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | *.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | *.vcxproj   merge=binary
29 | *.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | *.jpg   binary
44 | *.png   binary
45 | *.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/Chapter03/Queue.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH03_QUEUE_H
  2 | #define DS_CH03_QUEUE_H
  3 | 
  4 | #include "List.h"
  5 | 
  6 | template <typename T>
  7 | class LinkQueue {
  8 | private:
  9 |     struct Node {
 10 |         Node(const T &d = T(), Node *n = nullptr)
 11 |             : data(d), next(n)
 12 |         {}
 13 |         T data;
 14 |         Node *next;
 15 |     };
 16 |     
 17 | public:
 18 |     LinkQueue() : front(nullptr), rear(nullptr) {}
 19 |     LinkQueue(const LinkQueue &rhs) { operator=(rhs); }
 20 |     ~LinkQueue() { clear(); }
 21 | 
 22 | public:
 23 |     LinkQueue &operator=(const LinkQueue &rhs)
 24 |     {
 25 |         if (this != &rhs) {
 26 |             clear();
 27 | 
 28 |             Node *src = rhs.front;
 29 |             while (src != nullptr) {
 30 |                 enqueue(src->data);
 31 |                 src = src->next;
 32 |             }
 33 |         }
 34 |         return *this;
 35 |     }
 36 | 
 37 |     void enqueue(const T &x)
 38 |     {
 39 |         Node *ptr = new Node(x);
 40 |         if (rear != nullptr)
 41 |             rear = rear->next = ptr;
 42 |         else
 43 |             front = rear = ptr;
 44 |     }
 45 |     T dequeue()
 46 |     {
 47 |         T tmp = front->data;
 48 |         Node *ptr = front;
 49 |         if (front->next == nullptr)
 50 |             front = rear = nullptr;
 51 |         else
 52 |             front = front->next;
 53 |         delete ptr;
 54 |         return tmp;
 55 |     }
 56 |     void clear()
 57 |     {
 58 |         while (front != nullptr)
 59 |             dequeue();
 60 |     }
 61 | 
 62 | private:
 63 |     Node *front;
 64 |     Node *rear;
 65 | };
 66 | 
 67 | #include <vector>
 68 | using std::vector;
 69 | 
 70 | template <typename T>
 71 | class ArrQueue {
 72 | public:
 73 |     ArrQueue(int size = 16) : maxSize(size), front(0), rear(0) { theArray.resize(maxSize); }
 74 |     ArrQueue(const ArrQueue &rhs) { operator=(rhs); }
 75 |     ~ArrQueue() { clear(); }
 76 | 
 77 | public:
 78 |     ArrQueue &operator=(const ArrQueue &rhs)
 79 |     {
 80 |         if (this != &rhs) {
 81 |             clear();
 82 | 
 83 |             front = rhs.front;
 84 |             rear = rhs.rear;
 85 |             maxSize = rhs.maxSize;
 86 |             theArray.resize(maxSize);
 87 |             for (int i = 0; i < maxSize; ++i)
 88 |                 theArray[i] = rhs.theArray[i];
 89 |         }
 90 |         return *this;
 91 |     }
 92 | 
 93 |     void enqueue(const T &x)
 94 |     {
 95 |         if (!full()) {
 96 |             theArray[rear] = x;
 97 |             rear = (rear + 1) % maxSize;
 98 |         }
 99 |     }
100 |     T dequeue()
101 |     {
102 |         T tmp = theArray[front];
103 |         front = (front + 1) % maxSize;
104 |         return tmp;
105 |     }
106 |     void clear()
107 |     {
108 |         while (!empty())
109 |             dequeue();
110 |     }
111 |     bool empty() const { return front == rear; }
112 |     bool full() const { return (rear + 1) % maxSize == front; }
113 | 
114 | private:
115 |     int front, rear;
116 |     int maxSize;
117 |     vector<T> theArray;
118 | };
119 | 
120 | #endif // DS_CH03_QUEUE_H
121 | 


--------------------------------------------------------------------------------
/Chapter03/Vector.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH03_VECTOR_H
  2 | #define DS_CH03_VECTOR_H
  3 | 
  4 | #include <stdexcept>
  5 | 
  6 | template <typename Object>
  7 | class Vector {
  8 |     enum { SPARE_CAPACITY = 16 };
  9 |     typedef Object       *iterator;
 10 |     typedef const Object *const_iterator;
 11 | 
 12 | public:
 13 |     explicit Vector(int initSize = 0)
 14 |         : theSize(initSize), theCapacity(initSize + SPARE_CAPACITY)
 15 |     {
 16 |         objects = new Object[theCapacity];
 17 |     }
 18 |     Vector(const Vector &rhs) : objects(nullptr)
 19 |     {
 20 |         operator=(rhs);
 21 |     }
 22 |     ~Vector()
 23 |     {
 24 |         delete[] objects;
 25 |     }
 26 | 
 27 |     Vector &operator=(const Vector &rhs)
 28 |     {
 29 |         if (this != &rhs) {
 30 |             delete[] objects;
 31 |             theSize = rhs.size();
 32 |             theCapacity = rhs.capacity();
 33 | 
 34 |             objects = new Object[theCapacity];
 35 |             for (int i = 0; i < size(); ++i)
 36 |                 objects[i] = rhs.objects[i];
 37 |         }
 38 |         return *this;
 39 |     }
 40 | 
 41 |     void resize(int newSize)
 42 |     {
 43 |         if (newSize > theCapacity)
 44 |             reserve(newSize * 2 + 1);
 45 |         theSize = newSize;
 46 |     }
 47 | 
 48 |     void reserve(int newCapacity)
 49 |     {
 50 |         if (newCapacity < theSize)
 51 |             return;
 52 |         Object *oldArray = objects;
 53 |         
 54 |         objects = new Object[newCapacity];
 55 |         for (int i = 0; i < theSize; ++i)
 56 |             objects[i] = oldArray[i];
 57 | 
 58 |         theCapacity = newCapacity;
 59 | 
 60 |         delete[] oldArray;
 61 |     }
 62 | 
 63 |     Object &operator[](int index)
 64 |     {
 65 |         // ex3.7 添加边界检测
 66 |         if (index >= 0 && index < size())
 67 |             return objects[index];
 68 |         else
 69 |             throw std::runtime_error("index out of bounds");
 70 |     }
 71 |     const Object &operator[](int index) const
 72 |     {
 73 |         // ex3.7 添加边界检测
 74 |         if (index >= 0 && index < size())
 75 |             return objects[index];
 76 |         else
 77 |             throw std::runtime_error("index out of bounds");
 78 |     }
 79 |     
 80 |     bool empty() const { return size() == 0; }
 81 |     void clear() { theSize = 0; }
 82 |     int size() const { return theSize; }
 83 |     int capacity() const { return theCapacity;}
 84 | 
 85 |     void push_back(const Object &x)
 86 |     {
 87 |         if (theSize == theCapacity)
 88 |             reserve(2 * theCapacity + 1);
 89 |         objects[theSize++] = x;
 90 |     }
 91 | 
 92 |     void pop_back() { --theSize; }
 93 | 
 94 |     const Object &back() const { return objects[theSize - 1]; }
 95 | 
 96 |     iterator begin() { return &objects[0]; }
 97 |     const_iterator begin() const { return &objects[0]; }
 98 |     iterator end() { return &objects[size()]; }
 99 |     const_iterator end() const { return &objects[size()]; }
100 | 
101 | private:
102 |     int theSize;
103 |     int theCapacity;
104 |     Object *objects;
105 | };
106 | 
107 | #endif // DS_CH03_VECTOR_H
108 | 


--------------------------------------------------------------------------------
/Chapter06/BinaryHeap.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH06_BINARYHEAP_H
  2 | #define DS_CH06_BINARYHEAP_H
  3 | 
  4 | #include <vector>
  5 | #include <stdexcept>
  6 | 
  7 | template <typename T>
  8 | class BinaryHeap {
  9 | public:
 10 |     BinaryHeap() = delete;
 11 |     explicit BinaryHeap(int capacity) : arr(capacity), curSize(0) { }
 12 |     BinaryHeap(const vector<T> &items)
 13 |         : arr(items.size() + 10), curSize(int(items.size()))
 14 |     {
 15 |         if (!empty()) {
 16 |             for (int i = 0; i < items.size(); ++i)
 17 |                 arr[i + 1] = items[i];
 18 |             buildHeap();
 19 |         }
 20 |     }
 21 |     BinaryHeap(const BinaryHeap &rhs) : curSize(0), arr(100) { operator=(rhs); }
 22 |     ~BinaryHeap() = default;
 23 |     
 24 | public:
 25 |     BinaryHeap &operator=(const BinaryHeap &rhs)
 26 |     {
 27 |         if (this != &rhs) {
 28 |             makeEmpty();
 29 |             
 30 |             arr.resize(rhs.arr.capacity());
 31 |             curSize = rhs.size();
 32 |             for (int i = 0; i < rhs.size(); ++i)
 33 |                 arr[i + 1] = rhs.arr[i + 1];
 34 |         }
 35 |         return *this;
 36 |     }
 37 | 
 38 |     int size() const { return curSize; }
 39 |     bool empty() const { return size() == 0; }
 40 |     const T &findMin() const
 41 |     {
 42 |         if (empty())
 43 |             throw std::underflow_error("当前堆为空");
 44 |         return arr[1];
 45 |     }
 46 |     
 47 |     void insert(const T &x)
 48 |     {
 49 |         if (curSize == arr.size() - 1)
 50 |             arr.resize(arr.size() << 1);
 51 | 
 52 |         //percolateUp
 53 |         int hole = ++curSize;
 54 |         //这样的操作避免了交换，只需替换
 55 |         for (; hole > 1 && x < arr[hole >> 1]; hole >>= 1)
 56 |             arr[hole] = arr[hole >> 1];
 57 | 
 58 |         arr[hole] = x;
 59 |     }
 60 |     void deleteMin()
 61 |     {
 62 |         if (empty())
 63 |             throw std::underflow_error("当前堆为空");
 64 | 
 65 |         arr[1] = arr[curSize--];
 66 |         percolateDown(1);
 67 |     }
 68 |     void deleteMin(T &minItem) //删除min并将min值返回给minItem
 69 |     {
 70 |         if (empty())
 71 |             throw std::underflow_error("当前堆为空");
 72 | 
 73 |         minItem = arr[1];
 74 |         arr[1] = arr[curSize--];
 75 |         percolateDown(1);
 76 |     }
 77 |     void makeEmpty() { curSize = 0; arr.clear(); }
 78 |     
 79 | private:
 80 |     void buildHeap()
 81 |     {
 82 |         for (int i = curSize >> 1; i > 0; --i)
 83 |             percolateDown(i);
 84 |     }
 85 |     void percolateDown(int hole)
 86 |     {
 87 |         int child = 0;
 88 |         T tmp = arr[hole];
 89 |         for (; (child = hole << 1) <= curSize; hole = child) {
 90 |             //下面if里的第一个判断保证最后一个节点是左儿子的情况下的正确性
 91 |             if (child != curSize && arr[child + 1] < arr[child])
 92 |                 ++child;
 93 |             if (arr[child] < tmp)
 94 |                 arr[hole] = arr[child];
 95 |             else
 96 |                 break;
 97 |         }
 98 |         arr[hole] = tmp;
 99 |     }
100 | 
101 | private:
102 |     int curSize;
103 |     vector<T> arr;
104 | };
105 | 
106 | #endif // DS_CH06_BINARYHEAP_H
107 | 


--------------------------------------------------------------------------------
/Chapter05/HashTable(Separate_Chaining).h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH05_HASHTABLE_SC_H
  2 | #define DS_CH05_HASHTABLE_SC_H
  3 | 
  4 | #include <vector>
  5 | #include <list>
  6 | #include <string>
  7 | #include <algorithm>
  8 | #include <xhash>
  9 | 
 10 | template <typename T>
 11 | class HashTable_SC {
 12 |     int primes[24] = {
 13 |         53, 97, 193, 389, 769, 1453, 3079, 6151, 12893, 24593, 49157, 98317,
 14 |         196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917,
 15 |         25165843, 50331653, 100663319, 201326611, -1
 16 |     };
 17 | 
 18 |     int nextPrime(int n)
 19 |     {
 20 |         for (int i = 0; i < 24; ++i)
 21 |             if (n < primes[i])
 22 |                 return primes[i];
 23 |         return primes[23];
 24 |     }
 25 | 
 26 | public:
 27 |     HashTable_SC() = delete;
 28 |     explicit HashTable_SC(int size) : curSize(0), theLists(size) { makeEmpty(); }
 29 |     HashTable_SC(const HashTable_SC &rhs) { operator=(rhs); }
 30 |     ~HashTable_SC() = default;
 31 |     HashTable_SC &operator=(const HashTable_SC &rhs)
 32 |     {
 33 |         if (this != &rhs) {
 34 |             makeEmpty();
 35 |             for (const auto l : rhs.theLists) {
 36 |                 for (const auto t : l) {
 37 |                     insert(t);
 38 |                 }
 39 |             }
 40 |         }
 41 |         return *this;
 42 |     }
 43 | 
 44 |     int size() const { return curSize; }
 45 |     bool contains(const T &x) const
 46 |     {
 47 |         const auto whichList = theLists[myHash(x)];
 48 |         return find(whichList.cbegin(), whichList.cend(), x) != whichList.cend();
 49 |     }
 50 |     bool insert(const T &x)
 51 |     {
 52 |         auto &whichList = theLists[myHash(x)];
 53 |         if (find(whichList.cbegin(), whichList.cend(), x) != whichList.cend())
 54 |             return false;
 55 | 
 56 |         whichList.push_back(x);
 57 | 
 58 |         if (++curSize > theLists.size())
 59 |             rehash();
 60 | 
 61 |         return true;
 62 |     }
 63 |     bool remove(const T &x)
 64 |     {
 65 |         auto &whichList = theLists[myHash(x)];
 66 |         auto itr = find(whichList.cbegin(), whichList.cend(), x);
 67 |         if (itr == whichList.cend())
 68 |             return false;
 69 | 
 70 |         whichList.erase(itr);
 71 |         --curSize;
 72 |         return true;
 73 |     }
 74 | 
 75 |     void makeEmpty()
 76 |     {
 77 |         curSize = 0;
 78 |         for (auto &l : theLists) {
 79 |             l.clear();
 80 |         }
 81 |     }
 82 | 
 83 | private:
 84 |     void rehash()
 85 |     {
 86 |         auto oldLists = theLists;
 87 |         theLists.resize(nextPrime(int(theLists.size() << 1)));
 88 |         for (auto &l : theLists) {
 89 |             l.clear();
 90 |         }
 91 | 
 92 |         curSize = 0;
 93 |         for (const auto l : oldLists) {
 94 |             for (const auto t : l) {
 95 |                 insert(t);
 96 |             }
 97 |         }
 98 |     }
 99 |     int myHash(const T &x) const
100 |     {
101 |         int hashVal = int(hash_value(x));
102 |         hashVal %= theLists.size();
103 |         if (hashVal < 0)
104 |             hashVal += int(theLists.size());
105 |         return hashVal;
106 |     }
107 | private:
108 |     vector<list<T>> theLists;
109 |     int curSize;
110 | };
111 | 
112 | #endif // DS_CH05_HASHTABLE_SC_H
113 | 


--------------------------------------------------------------------------------
/Chapter05/HashTable(Open_Addressing_Hashing).h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH05_HASHTABLE_OAH_H
  2 | #define DS_CH05_HASHTABLE_OAH_H
  3 | 
  4 | #include <vector>
  5 | #include <xhash>
  6 | 
  7 | //平方探测
  8 | template <typename T>
  9 | class HashTable_OAH {
 10 |     enum EntryType { ACTIVE, EMPTY, DELETED };
 11 | 
 12 |     int primes[24] = {
 13 |         53, 97, 193, 389, 769, 1453, 3079, 6151, 12893, 24593, 49157, 98317,
 14 |         196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917,
 15 |         25165843, 50331653, 100663319, 201326611, -1
 16 |     };
 17 | 
 18 |     int nextPrime(int n)
 19 |     {
 20 |         for (int i = 0; i < 24; ++i)
 21 |             if (n < primes[i])
 22 |                 return primes[i];
 23 |         return primes[23];
 24 |     }
 25 | 
 26 | private:
 27 |     struct HashEntry {
 28 |         HashEntry(const T &e = T(), EntryType i = EMPTY) : ele(e), info(i) {}
 29 |         T ele;
 30 |         EntryType info;
 31 |     };
 32 | 
 33 | public:
 34 |     HashTable_OAH() = delete;
 35 |     explicit HashTable_OAH(int size) : curSize(0), arr(size) { makeEmpty(); }
 36 |     HashTable_OAH(const HashTable_OAH &rhs) { operator=(rhs); }
 37 |     ~HashTable_OAH() = default;
 38 |     HashTable_OAH &operator=(const HashTable_OAH &rhs)
 39 |     {
 40 |         if (this != &rhs) {
 41 |             makeEmpty();
 42 |             for (const auto HE : rhs.arr) {
 43 |                 insert(HE);
 44 |             }
 45 |         }
 46 |         return *this;
 47 |     }
 48 | 
 49 |     int size() const { return curSize; }
 50 |     bool contains(const T &x) const
 51 |     {
 52 |         return isActive(findPos(x));
 53 |     }
 54 |     bool insert(const T &x)
 55 |     {
 56 |         int curPos = findPos(x);
 57 |         if (isActive(curPos))
 58 |             return false;
 59 | 
 60 |         arr[curPos] = HashEntry(x, ACTIVE);
 61 | 
 62 |         if (++curSize > (arr.size() >> 1))
 63 |             rehash();
 64 | 
 65 |         return true;
 66 |     }
 67 |     bool remove(const T &x)
 68 |     {
 69 |         int curPos = findPos(x);
 70 |         if (!isActive(curPos))
 71 |             return false;
 72 | 
 73 |         arr[curPos].info = DELETED;
 74 |         --curSize;
 75 |         return true;
 76 |     }
 77 | 
 78 |     void makeEmpty()
 79 |     {
 80 |         curSize = 0;
 81 |         for (auto &HE : arr) {
 82 |             HE.info = EMPTY;
 83 |         }
 84 |     }
 85 | 
 86 | private:
 87 |     bool isActive(int curPos) const
 88 |     {
 89 |         return arr[curPos].info == ACTIVE;
 90 |     }
 91 |     int findPos(const T &x) const
 92 |     {
 93 |         int offset = 1;
 94 |         int curPos = myHash(x);
 95 | 
 96 |         while (arr[curPos].info != EMPTY &&
 97 |             arr[curPos].ele != x) {
 98 |             //平方探测的快速方法
 99 |             //由 f(i) = f(i-1) + 2i - 1 推得
100 |             curPos += offset;
101 |             offset += 2;
102 |             if (curPos >= arr.size())
103 |                 curPos -= int(arr.size());
104 |         }
105 | 
106 |         return curPos;
107 |     }
108 |     void rehash()
109 |     {
110 |         auto oldArr = arr;
111 |         arr.resize(nextPrime(int(oldArr.size() << 1)));
112 |         for (auto HE : arr)
113 |             HE.info = EMPTY;
114 | 
115 |         curSize = 0;
116 |         for (const auto HE : oldArr)
117 |             if (HE.info == ACTIVE)
118 |                 insert(HE.ele);
119 |     }
120 |     int myHash(const T &x) const
121 |     {
122 |         int hashVal = int(hash_value(x));
123 |         hashVal %= arr.size();
124 |         if (hashVal < 0)
125 |             hashVal += int(arr.size());
126 |         return hashVal;
127 |     }
128 | private:
129 |     vector<HashEntry> arr;
130 |     int curSize;
131 | };
132 | 
133 | #endif // DS_CH05_HASHTABLE_OAH_H
134 | 


--------------------------------------------------------------------------------
/Chapter03/Stack.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH03_STACK_H
  2 | #define DS_CH03_STACK_H
  3 | 
  4 | template <typename T>
  5 | class LinkStack {
  6 | private:
  7 |     struct Node {
  8 |         Node(const T &d = T(), Node *n = nullptr)
  9 |             : data(d), next(n)
 10 |         { }
 11 |         T data;
 12 |         Node *next;
 13 |     };
 14 | 
 15 | public:
 16 |     LinkStack() : stackSize(0), head(nullptr) { }
 17 |     LinkStack(const LinkStack &rhs) : stackSize(0), head(nullptr) { operator=(rhs); }
 18 |     ~LinkStack() { clear(); }
 19 |     LinkStack &operator=(const LinkStack &rhs)
 20 |     {
 21 |         if (this != &rhs) {
 22 |             clear();
 23 | 
 24 |             Node *src = rhs.head;
 25 | 
 26 |             while (src != nullptr) {
 27 |                 push(src->data);
 28 |                 src = src->next;
 29 |             }
 30 |         }
 31 |         return *this;
 32 |     }
 33 | 
 34 |     void push(const T &x)
 35 |     {
 36 |         Node *ptr = new Node(x, head);
 37 |         head = ptr;
 38 |         ++stackSize;
 39 |     }
 40 |     void pop()
 41 |     {
 42 |         Node *ptr = head->next;
 43 |         delete head;
 44 |         head = ptr;
 45 |         --stackSize;
 46 |     }
 47 |     T &top()
 48 |     {
 49 |         return head->data;
 50 |     }
 51 |     const T &top() const
 52 |     {
 53 |         return head->data;
 54 |     }
 55 |     bool empty() const { return size() == 0; }
 56 |     int size() const { return stackSize; }
 57 |     void clear()
 58 |     {
 59 |         while (!empty())
 60 |             pop();
 61 |     }
 62 |     
 63 | private:
 64 |     int stackSize;
 65 |     Node *head;
 66 | };
 67 | 
 68 | template <typename T>
 69 | class ArrStack {
 70 |     enum { SPARE_CAPACITY = 16 };
 71 | 
 72 | public:
 73 |     explicit ArrStack(int initSize = 0)
 74 |         : topOfStack(-1), theCapacity(initSize + SPARE_CAPACITY)
 75 |     {
 76 |         theArray = new T[theCapacity];
 77 |     }
 78 |     ArrStack(const ArrStack &rhs) : theArray(nullptr)
 79 |     {
 80 |         operator=(rhs);
 81 |     }
 82 |     ~ArrStack()
 83 |     {
 84 |         delete[] theArray;
 85 |     }
 86 | 
 87 |     ArrStack &operator=(const ArrStack &rhs)
 88 |     {
 89 |         if (this != &rhs) {
 90 |             delete[] theArray;
 91 |             topOfStack = rhs.topOfStack;
 92 |             theCapacity = rhs.theCapacity;
 93 | 
 94 |             theArray = new T[theCapacity];
 95 |             for (int i = 0; i < size(); ++i)
 96 |                 theArray[i] = rhs.theArray[i];
 97 |         }
 98 |         return *this;
 99 |     }
100 | 
101 |     void push(const T &x)
102 |     {
103 |         if (++topOfStack == theCapacity)
104 |             reserve(2 * theCapacity + 1);
105 |         theArray[topOfStack] = x;
106 |     }
107 |     T &pop()
108 |     {
109 |         return theArray[topOfStack--];
110 |     }
111 |     const T &pop() const
112 |     {
113 |         return theArray[topOfStack--];
114 |     }
115 |     T &top()
116 |     {
117 |         return theArray[topOfStack];
118 |     }
119 |     const T &top() const
120 |     {
121 |         return theArray[topOfStack];
122 |     }
123 | 
124 |     int size() const { return topOfStack + 1; }
125 |     bool empty() const { return topOfStack == -1; }
126 |     void clear()
127 |     {
128 |         while (!empty())
129 |             pop();
130 |     }
131 | 
132 | private:
133 |     void reserve(int newCapacity)
134 |     {
135 |         T *oldArray = theArray;
136 | 
137 |         theArray = new T[newCapacity];
138 |         for (int i = 0; i < size(); ++i)
139 |             theArray[i] = oldArray[i];
140 | 
141 |         theCapacity = newCapacity;
142 | 
143 |         delete[] oldArray;
144 |     }
145 | 
146 | private:
147 |     int topOfStack;
148 |     int theCapacity;
149 |     T *theArray;
150 | };
151 | 
152 | #endif // DS_CH03_STACK_H
153 | 


--------------------------------------------------------------------------------
/Chapter07/README.md:
--------------------------------------------------------------------------------
  1 | # 排序
  2 | 在内存里的排序称为内部排序，而在磁盘上的排序称为外部排序。  
  3 | 假设输入数据支持"<"和">"操作符，除赋值运算外，这种运算是仅有的允许对输入数据进行的操作，在此条件下的排序称为基于比较的排序。
  4 | 
  5 | ## 内容
  6 | 对内部排序的考查将指出：
  7 | 
  8 | * 存在几种直观的算法以O(N^2)排序，如冒泡、选择、插入排序
  9 | * 希尔排序编程简单，以o(N^2)运行，在实践中很有效
 10 | * 还有一些稍微复杂的O(NlogN)算法
 11 | * 任何只使用比较的排序算法在最坏情形下和平均情形下均需要Ω(NlogN)次比较
 12 | 
 13 | ## 插入排序 (insertion sort)
 14 | 插入排序由N-1趟（pass）排序组成，排序策略是，在第p趟，将位置p上的元素向左移动至它在前p+1个元素中的正确位置上。
 15 | 
 16 | ### 分析
 17 | O(N^2) 精确界，反序输入可达。  
 18 | 若已排序输入，则O(N)  
 19 | 平均情形Θ(N^2)
 20 | 
 21 | ## 一些简单排序算法的下界
 22 | 定理1 N个互异元素的数组的平均逆序数是N(N-1)/4  
 23 | 定理2 通过交换相邻元素进行排序的任何算法平均需要Ω(N^2)时间  
 24 | 对冒泡排序、选择排序、插入排序都有效  
 25 | 定理2告诉我们，为了以o(N^2)排序，必须执行比较，特别是要对相距较远的元素进行交换。排序通过删除逆序得以继续进行，为了有效进行，必须每次交换删除多个逆序。
 26 | 
 27 | ## 希尔排序 (shell sort)
 28 | 发明者是Donald Shell，该算法是冲破二次时间屏障的第一批算法之一，不过，直到它最初被发现的若干年后才证明了它的亚二次时间界。
 29 | 
 30 | 它通过比较相距一定间隔的元素来工作，各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。因此，希尔排序又是也叫做**缩减增量排序**(diminishing increment sort)
 31 | 
 32 | ### 分析
 33 | 使用希尔增量的最坏情形Θ(N^2)  
 34 | Hibbard增量：1，3，7，…… ，2^k - 1  
 35 | 使用Hibbard增量的最坏情形Θ(N^(3/2))  
 36 | Sedgewick提出了几种增量序列，最坏情形时间O(N^(4/3))  
 37 | 希尔排序的性能在实践中是可以接受的，由于编程简单，适度数量的输入数据经常选用。
 38 | 
 39 | ## 堆排序 (heap sort)
 40 | 如第六章所说，优先队列可以用O(NlogN)时间进行排序，基于该思想的算法称为堆排序
 41 | 
 42 | 由数组建立N个元素的二叉堆花费O(N)时间，每次deleteMin花费O(logN)，N次总共花费O(NlogN)  
 43 | 使用了附加数组，存储需求增加了一倍
 44 | 
 45 | 避免使用附加数组的方法：每次deleteMin之后把min放到刚刚空出来的位置上，N次deleteMin之后，数组将是递减顺序，因此可以构建max堆
 46 | 
 47 | 1. 以O(N)建立max堆
 48 | 2. 交换最后一个和第一个元素，堆大小减1并下滤，相当于执行deleteMax
 49 | 3. 循环执行步骤2，N-1次
 50 | 
 51 | ### 分析
 52 | 在最坏情形下堆排序最多使用2NlogN-O(N)次比较  
 53 | 堆排序非常稳定：它平均使用的比较只比最坏情形界指出的略少
 54 | 
 55 | 定理1 对N个互异项的随机排列进行堆排序，所用的比较平均次数为2NlogN-O(NloglogN)
 56 | 
 57 | 可以证明，堆排序总是至少使用NlogN-O(N)次比较，而且存在达到这个界的数据。似乎平均情形也应该是2NlogN-O(N)次比较（而不是定理1中的第二项），但目前无法证明
 58 | 
 59 | ## 归并排序 (merge sort)
 60 | 以最坏情形O(NlogN)时间运行，所使用的比较次数几乎是最优的，它是递归算法的一个很好的实例
 61 | 
 62 | 算法的基本操作是合并两个已排序的表，取两个输入A、B，一个输出C，每次将A、B中的小者放入C，相关的位置推进，这显然是线性的
 63 | 
 64 | ### 算法
 65 | 基准情形：N=1时，结果是显然的  
 66 | 否则，递归地将前半部分和后半部分各自归并排序，再将两部分合并
 67 | 
 68 | 该算法是经典的**分治**策略，它将问题**分**(divide)成一些小问题然后递归求解，而**治**(conquering)的阶段则是将分的阶段解得的各答案合并在一起
 69 | 
 70 | ### 分析
 71 | 分析递归例程技巧的经典实例：必须给运行时间写出一个递推关系。  
 72 | 假设N是2的幂，从而总可以将它分裂成相等的两部分。对于N=1，所用时间是常数，将其记为1。则有  
 73 | T(1) = 1  
 74 | T(N) = 2T(N/2) + N  
 75 | 求解得 T(N) = NlogN + N = O(NlogN)
 76 | 
 77 | 利弊：在java中比较耗时多于移动，因此在java中归并排序是一般目的排序的最佳选择；但在C++中，比较耗时少而复制对象代价很大，因此实践中不常用
 78 | 
 79 | ## 快速排序 (quick sort)
 80 | 快排是实践中最快的已知排序算法，平均运行时间是O(NlogN)，最坏情形是O(N^2)，但稍作努力就可避免。  
 81 | 通过将堆排序与快速排序结合，可以在堆排序O(NlogN)最坏运行时间下，得到几乎所有输入的最快运行时间。
 82 | 
 83 | 快排也是分治的递归算法，排序数组S步骤如下：
 84 | 
 85 | 1. 若S中元素数是0或1，则返回
 86 | 2. 取S中任一元素v，称之为**枢纽元**(pivot)
 87 | 3. 将S-{v}（S中其余元素）**划分**成两个不相交的集合：S1={x∈S-{v}|x≤v}和S2={x∈S-{v}|x≥v}
 88 | 4. 返回{quickSort(S1),后跟v,继而quickSort(S2)}
 89 | 
 90 | 第三步中划分的标准不是唯一的，因此这就成了设计决策。一部分好的实现方法是将这种情形尽可能有效地处理。直观地看，我们希望枢纽元能将元素对半分，一半在S1，另一半在S2。
 91 | 
 92 | ### 选取枢纽元
 93 | 1. 一种典型的错误是将第一个元素选作枢纽元。若输入随机，那么这是可以接受的，但实际情况有很多预排序的序列，这样的分割是劣质的。类似的还有选取前2个元素的大者，这是一样的，不要使用。
 94 | 2. 一种安全的做法是随机选取枢纽元，但这取决于随机数生成器的质量，而且声称随机数的代价一般也是很昂贵的。
 95 | 3. 三数中值分割法  
 96 | 一组N个数的中值是第上取整(N/2)个最大的数。枢纽元的最好选择是数组的中值，但算出中值代价太高。一般的做法是选取左端、右端和中心位置上的三个元素的中值作为枢纽元。显然该方法消除了预排序输入的不好情形，并且减少了约14%的比较次数。
 97 | 
 98 | ### 分割策略
 99 | 1. 将枢纽元与最后的元素交换
100 | 2. i从第一个元素开始，j从倒数第二个元素开始
101 | 3. 当i在j左边时，右移i，移过小于枢纽元的元素，j左移，移过大于枢纽元的元素，i,j都停止时交换两个元素，直到i,j交错
102 | 4. 将枢纽元与i所指向的元素交换
103 | 
104 | 如何处理等于枢纽元的元素？  
105 | 若等于，则停止移动
106 | 
107 | ### 小数组
108 | 对于很小的数组（N≤20），快速排序不如插入排序，而且，因为快排是递归的，这样的情形经常发生。通常的解决办法是，对于小数组使用插入排序。一种好的截止范围(cutoff range)是N=10
109 | 
110 | ### 分析
111 | 最坏情形：O(N^2)
112 | 最佳情形：O(NlogN)
113 | 平均情形：O(NlogN)
114 | 
115 | ## 快速选择 (quick select)
116 | 修改快速排序以解决选择问题，即找第k个最大（小）元。
117 | 
118 | 前3步和快速排序一样  
119 | 第4步
120 | 
121 | * 若k≤S1，那么k必然在S1中，返回quickSelect(S1, K)
122 | * 若k = 1 + |S1|，那么枢纽元就是第k个最小元
123 | * 否则，第k个最小元就在S2中，它是S2中的第（k-|S1|-1）个最小元，返回quickSelect(S2, k-|S1|-1)
124 | 
125 | ### 分析
126 | 与快排相比，快速选择只进行了一次递归调用而不是两次
127 | 
128 | 最坏情形：O(N^2)，当S1和S2一个是空时
129 | 平均情形：O(N)


--------------------------------------------------------------------------------
/Chapter06/LeftistHeap.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH06_LEFTISTHEAP_H
  2 | #define DS_CH06_LEFTISTHEAP_H
  3 | 
  4 | #include <stdexcept>
  5 | #include <iostream>
  6 | using std::cout;
  7 | using std::endl;
  8 | 
  9 | template <typename T>
 10 | class LeftistHeap {
 11 | private:
 12 |     struct LeftistNode {
 13 |         LeftistNode(const T &theEle, LeftistNode *lt = nullptr, 
 14 |             LeftistNode *rt = nullptr, int np = 0)
 15 |             : ele(theEle), left(lt), right(rt), npl(np) {}
 16 |         LeftistNode *left;
 17 |         LeftistNode *right;
 18 |         int npl;
 19 |         T ele;
 20 |     };
 21 | 
 22 | public:
 23 |     LeftistHeap() : root(nullptr) {}
 24 |     LeftistHeap(const LeftistHeap &rhs) { operator=(rhs); }
 25 |     ~LeftistHeap() { makeEmpty(); }
 26 | 
 27 | public:
 28 |     LeftistHeap &operator=(const LeftistHeap &rhs)
 29 |     {
 30 |         if (this != &rhs) {
 31 |             makeEmpty();
 32 |             root = clone(rhs.root);
 33 |         }
 34 |         return *this;
 35 |     }
 36 | 
 37 |     bool empty() const { return root == nullptr; }
 38 |     const T &findMin() const { return root->ele; } //应保证非空调用
 39 | 
 40 |     void printTree() const { printTree(root); }
 41 |     //插入可以看成是合并一个单节点堆，时间界也是O(logN)
 42 |     void insert(const T &x)
 43 |     {
 44 |         root = merge(new LeftistNode(x), root);
 45 |     }
 46 |     //删除可以看成是删除根结点，再合并左右子树，时间界也是O(logN)
 47 |     void deleteMin()
 48 |     {
 49 |         if (empty())
 50 |             throw std::underflow_error("当前堆为空");
 51 | 
 52 |         LeftistNode *oldRoot = root;
 53 |         root = merge(root->left, root->right);
 54 |         delete oldRoot;
 55 |     }
 56 |     void deleteMin(T &minItem)
 57 |     {
 58 |         minItem = findMin();
 59 |         deleteMin();
 60 |     }
 61 |     void makeEmpty() { makeEmpty(root); }
 62 |     //合并两个堆的时间界为O(logN)
 63 |     void merge(LeftistHeap &rhs)
 64 |     {
 65 |         if (this != &rhs) {
 66 |             root = merge(root, rhs.root);
 67 |             rhs.makeEmpty();
 68 |         }
 69 |     }
 70 | 
 71 | private:
 72 |     void printDepth(const T &x, int depth = 0) const
 73 |     {
 74 |         while (depth--)
 75 |             cout << "\t";
 76 |         cout << "[" << x << "]" << endl;
 77 |     }
 78 |     void printTree(LeftistNode *t, int depth = 0) const
 79 |     {
 80 |         if (t == nullptr)
 81 |             return; // do nothing
 82 |         printTree(t->left, depth + 1);
 83 |         printDepth(t->ele, depth); //这句放的位置决定了前中后序遍历
 84 |         printTree(t->right, depth + 1);
 85 |     }
 86 |     void makeEmpty(LeftistNode *&t)
 87 |     {
 88 |         if (t != nullptr) {
 89 |             makeEmpty(t->left);
 90 |             makeEmpty(t->right);
 91 |             delete t;
 92 |         }
 93 |         t = nullptr;
 94 |     }
 95 |     LeftistNode *clone(LeftistNode *t) const
 96 |     {
 97 |         if (t == nullptr)
 98 |             return nullptr;
 99 | 
100 |         return new LeftistNode(t->ele, clone(t->left), clone(t->right), t->npl);
101 |     }
102 |     LeftistNode *merge(LeftistNode *h1, LeftistNode *h2)
103 |     {
104 |         if (h1 == nullptr)
105 |             return h2;
106 |         if (h2 == nullptr)
107 |             return h1;
108 |         return h1->ele < h2->ele ? merge1(h1, h2) : merge1(h2, h1);
109 |     }
110 |     LeftistNode *merge1(LeftistNode *h1, LeftistNode *h2)
111 |     {
112 |         if (h1->left == nullptr) {
113 |             h1->left = h2;
114 |         } else {
115 |             h1->right = merge(h1->right, h2);
116 |             if (h1->left->npl < h1->right->npl)
117 |                 swapChildren(h1);
118 |             h1->npl = h1->right->npl + 1;
119 |         }
120 |         return h1;
121 |     }
122 |     void swapChildren(LeftistNode *t)
123 |     {
124 |         LeftistNode *temp = t->left;
125 |         t->left = t->right;
126 |         t->right = temp;
127 |     }
128 | 
129 | private:
130 |     LeftistNode *root;
131 | };
132 | 
133 | #endif // DS_CH06_LEFTISTHEAP_H
134 | 


--------------------------------------------------------------------------------
/Chapter04/BinarySearchTree.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH04_BINARYSEARCHTREE_H
  2 | #define DS_CH04_BINARYSEARCHTREE_H
  3 | 
  4 | #include <iostream>
  5 | using std::cout;
  6 | using std::endl;
  7 | 
  8 | template <typename T>
  9 | class BinarySearchTree {
 10 | private:
 11 |     struct BinaryNode {
 12 |         BinaryNode (const T &element, BinaryNode *lt, BinaryNode *rt)
 13 |             : ele(element), left(lt), right(rt)
 14 |         {}
 15 |         T ele;
 16 |         BinaryNode *left;
 17 |         BinaryNode *right;
 18 |     };
 19 | 
 20 | public:
 21 |     BinarySearchTree() : root(nullptr) {}
 22 |     BinarySearchTree(const BinarySearchTree &rhs) { operator=(rhs); }
 23 |     ~BinarySearchTree() { makeEmpty(); }
 24 | 
 25 | public:
 26 |     BinarySearchTree &operator=(const BinarySearchTree &rhs)
 27 |     {
 28 |         if (this != &rhs) {
 29 |             makeEmpty();
 30 |             root = clone(rhs.root);
 31 |         }
 32 |         return *this;
 33 |     }
 34 | 
 35 |     const T &findMin() const { return findMin(root)->ele; } //应保证非空调用
 36 |     const T &findMax() const { return findMax(root)->ele; } //应保证非空调用
 37 |     bool contains(const T &x) const { return contains(x, root); }
 38 |     bool empty() const { return root == nullptr; }
 39 |     void printTree() const { printTree(root); }
 40 | 
 41 |     void makeEmpty() { makeEmpty(root); }
 42 |     void insert(const T &x) { insert(x, root); }
 43 |     void remove(const T &x) { remove(x, root); }
 44 | 
 45 | private:
 46 |     BinaryNode *clone(BinaryNode *t) const
 47 |     {
 48 |         if (t == nullptr)
 49 |             return nullptr;
 50 | 
 51 |         return new BinaryNode(t->ele, clone(t->left), clone(t->right));
 52 |     }
 53 |     BinaryNode *findMin(BinaryNode *t) const
 54 |     {
 55 |         if (t == nullptr)
 56 |             return nullptr;
 57 |         if (t->left == nullptr)
 58 |             return t;
 59 |         return findMin(t->left);
 60 |     }
 61 |     BinaryNode *findMax(BinaryNode *t) const
 62 |     {
 63 |         if (t != nullptr) {
 64 |             while (t->right != nullptr)
 65 |                 t = t->right;
 66 |         }
 67 |         return t;
 68 |     }
 69 |     bool contains(const T &x, BinaryNode *t) const
 70 |     {
 71 |         if (t == nullptr)
 72 |             return false;
 73 |         else if (x < t->ele)
 74 |             return contains(x, t->left);
 75 |         else if (t->ele < x)
 76 |             return contains(x, t->right);
 77 |         else
 78 |             return true;
 79 |     }
 80 |     void printDepth(const T &x, int depth = 0) const
 81 |     {
 82 |         while (depth--)
 83 |             cout << "\t";
 84 |         cout << "[" << x << "]" << endl;
 85 |     }
 86 |     void printTree(BinaryNode *t, int depth = 0) const
 87 |     {
 88 |         if (t == nullptr)
 89 |             return; // do nothing
 90 |         printTree(t->left, depth + 1);
 91 |         printDepth(t->ele, depth); //这句放的位置决定了前中后序遍历
 92 |         printTree(t->right, depth + 1);
 93 |     }
 94 |     void makeEmpty(BinaryNode *&t)
 95 |     {
 96 |         if (t != nullptr) {
 97 |             makeEmpty(t->left);
 98 |             makeEmpty(t->right);
 99 |             delete t;
100 |         }
101 |         t = nullptr;
102 |     }
103 |     void insert(const T &x, BinaryNode *&t)
104 |     {
105 |         if (t == nullptr)
106 |             t = new BinaryNode(x, nullptr, nullptr);
107 |         else if (x < t->ele)
108 |             insert(x, t->left);
109 |         else if (t->ele < x)
110 |             insert(x, t->right);
111 |         else
112 |             ; //do nothing
113 |     }
114 |     void remove(const T &x, BinaryNode *&t)
115 |     {
116 |         if (t == nullptr)
117 |             ; //not found, do nothing
118 |         if (x < t->ele)
119 |             remove(x, t->left);
120 |         else if (t->ele < x)
121 |             remove(x, t->right);
122 |         else if (t->left != nullptr && t->right != nullptr) { //2 children
123 |             t->ele = findMin(t->right)->ele; //用右子树的最小值替代当前值
124 |             remove(t->ele, t->right); //删掉右子树的最小值
125 |         } else {
126 |             BinaryNode *old = t;
127 |             t = (t->left != nullptr) ? t->left : t->right;
128 |             delete old;
129 |         }
130 |     }
131 | 
132 | private:
133 |     BinaryNode *root;
134 | };
135 | 
136 | #endif // DS_CH04_BINARYSEARCHTREE_H
137 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | # *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | [Xx]64/
 19 | [Xx]86/
 20 | [Bb]uild/
 21 | bld/
 22 | [Bb]in/
 23 | [Oo]bj/
 24 | 
 25 | # Visual Studio 2015 cache/options directory
 26 | .vs/
 27 | # Uncomment if you have tasks that create the project's static files in wwwroot
 28 | #wwwroot/
 29 | 
 30 | # MSTest test Results
 31 | [Tt]est[Rr]esult*/
 32 | [Bb]uild[Ll]og.*
 33 | 
 34 | # NUNIT
 35 | *.VisualState.xml
 36 | TestResult.xml
 37 | 
 38 | # Build Results of an ATL Project
 39 | [Dd]ebugPS/
 40 | [Rr]eleasePS/
 41 | dlldata.c
 42 | 
 43 | # DNX
 44 | project.lock.json
 45 | artifacts/
 46 | 
 47 | *_i.c
 48 | *_p.c
 49 | *_i.h
 50 | *.ilk
 51 | *.meta
 52 | *.obj
 53 | *.pch
 54 | *.pdb
 55 | *.pgc
 56 | *.pgd
 57 | *.rsp
 58 | *.sbr
 59 | *.tlb
 60 | *.tli
 61 | *.tlh
 62 | *.tmp
 63 | *.tmp_proj
 64 | *.log
 65 | *.vspscc
 66 | *.vssscc
 67 | .builds
 68 | *.pidb
 69 | *.svclog
 70 | *.scc
 71 | 
 72 | # Chutzpah Test files
 73 | _Chutzpah*
 74 | 
 75 | # Visual C++ cache files
 76 | ipch/
 77 | *.aps
 78 | *.ncb
 79 | *.opendb
 80 | *.opensdf
 81 | *.sdf
 82 | *.cachefile
 83 | *.VC.db
 84 | 
 85 | # Visual Studio profiler
 86 | *.psess
 87 | *.vsp
 88 | *.vspx
 89 | *.sap
 90 | 
 91 | # TFS 2012 Local Workspace
 92 | $tf/
 93 | 
 94 | # Guidance Automation Toolkit
 95 | *.gpState
 96 | 
 97 | # ReSharper is a .NET coding add-in
 98 | _ReSharper*/
 99 | *.[Rr]e[Ss]harper
100 | *.DotSettings.user
101 | 
102 | # JustCode is a .NET coding add-in
103 | .JustCode
104 | 
105 | # TeamCity is a build add-in
106 | _TeamCity*
107 | 
108 | # DotCover is a Code Coverage Tool
109 | *.dotCover
110 | 
111 | # NCrunch
112 | _NCrunch_*
113 | .*crunch*.local.xml
114 | nCrunchTemp_*
115 | 
116 | # MightyMoose
117 | *.mm.*
118 | AutoTest.Net/
119 | 
120 | # Web workbench (sass)
121 | .sass-cache/
122 | 
123 | # Installshield output folder
124 | [Ee]xpress/
125 | 
126 | # DocProject is a documentation generator add-in
127 | DocProject/buildhelp/
128 | DocProject/Help/*.HxT
129 | DocProject/Help/*.HxC
130 | DocProject/Help/*.hhc
131 | DocProject/Help/*.hhk
132 | DocProject/Help/*.hhp
133 | DocProject/Help/Html2
134 | DocProject/Help/html
135 | 
136 | # Click-Once directory
137 | publish/
138 | 
139 | # Publish Web Output
140 | *.[Pp]ublish.xml
141 | *.azurePubxml
142 | 
143 | # TODO: Un-comment the next line if you do not want to checkin
144 | # your web deploy settings because they may include unencrypted
145 | # passwords
146 | #*.pubxml
147 | *.publishproj
148 | 
149 | # NuGet Packages
150 | *.nupkg
151 | # The packages folder can be ignored because of Package Restore
152 | **/packages/*
153 | # except build/, which is used as an MSBuild target.
154 | !**/packages/build/
155 | # Uncomment if necessary however generally it will be regenerated when needed
156 | #!**/packages/repositories.config
157 | # NuGet v3's project.json files produces more ignoreable files
158 | *.nuget.props
159 | *.nuget.targets
160 | 
161 | # Microsoft Azure Build Output
162 | csx/
163 | *.build.csdef
164 | 
165 | # Microsoft Azure Emulator
166 | ecf/
167 | rcf/
168 | 
169 | # Windows Store app package directory
170 | AppPackages/
171 | BundleArtifacts/
172 | 
173 | # Visual Studio cache files
174 | # files ending in .cache can be ignored
175 | *.[Cc]ache
176 | # but keep track of directories ending in .cache
177 | !*.[Cc]ache/
178 | 
179 | # Others
180 | ClientBin/
181 | [Ss]tyle[Cc]op.*
182 | ~$*
183 | *~
184 | *.dbmdl
185 | *.dbproj.schemaview
186 | *.pfx
187 | *.publishsettings
188 | node_modules/
189 | orleans.codegen.cs
190 | 
191 | # RIA/Silverlight projects
192 | Generated_Code/
193 | 
194 | # Backup & report files from converting an old project file
195 | # to a newer Visual Studio version. Backup files are not needed,
196 | # because we have git ;-)
197 | _UpgradeReport_Files/
198 | Backup*/
199 | UpgradeLog*.XML
200 | UpgradeLog*.htm
201 | 
202 | # SQL Server files
203 | *.mdf
204 | *.ldf
205 | 
206 | # Business Intelligence projects
207 | *.rdl.data
208 | *.bim.layout
209 | *.bim_*.settings
210 | 
211 | # Microsoft Fakes
212 | FakesAssemblies/
213 | 
214 | # GhostDoc plugin setting file
215 | *.GhostDoc.xml
216 | 
217 | # Node.js Tools for Visual Studio
218 | .ntvs_analysis.dat
219 | 
220 | # Visual Studio 6 build log
221 | *.plg
222 | 
223 | # Visual Studio 6 workspace options file
224 | *.opt
225 | 
226 | # Visual Studio LightSwitch build output
227 | **/*.HTMLClient/GeneratedArtifacts
228 | **/*.DesktopClient/GeneratedArtifacts
229 | **/*.DesktopClient/ModelManifest.xml
230 | **/*.Server/GeneratedArtifacts
231 | **/*.Server/ModelManifest.xml
232 | _Pvt_Extensions
233 | 
234 | # LightSwitch generated files
235 | GeneratedArtifacts/
236 | ModelManifest.xml
237 | 
238 | # Paket dependency manager
239 | .paket/paket.exe
240 | 
241 | # FAKE - F# Make
242 | .fake/
243 | 


--------------------------------------------------------------------------------
/Chapter03/SimpleCalculator.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH03_SIMPLECALCULATOR_H
  2 | #define DS_CH03_SIMPLECALCULATOR_H
  3 | 
  4 | #include <string>
  5 | using std::string;
  6 | 
  7 | #include "Vector.h"
  8 | #include "Stack.h"
  9 | 
 10 | class SimpleCalculator {
 11 | public:
 12 |     SimpleCalculator() = default;
 13 |     explicit SimpleCalculator(const string &s) { _rpn = toRPN(s); }
 14 |     SimpleCalculator(const SimpleCalculator &rhs) = delete;
 15 |     ~SimpleCalculator() = default;
 16 | 
 17 | public:
 18 |     double calcu(const string &s)
 19 |     {
 20 |         Vector<string> rpn = toRPN(s);
 21 |         double d = 0.0, d1 = 0.0, d2 = 0.0;
 22 |         LinkStack<double> dstk;
 23 |         string strT;
 24 | 
 25 |         for (auto it = rpn.begin(); it != rpn.end(); ++it) {
 26 |             strT = *it;
 27 |             if (isdigit(strT[0])) {
 28 |                 dstk.push(std::stod(strT));
 29 |             } else {
 30 |                 d1 = dstk.top();
 31 |                 dstk.pop();
 32 |                 d2 = dstk.top();
 33 |                 dstk.pop();
 34 | 
 35 |                 if (strT == "+") {
 36 |                     d = d2 + d1;
 37 |                 } else if (strT == "-") {
 38 |                     d = d2 - d1;
 39 |                 } else if (strT == "*") {
 40 |                     d = d2 * d1;
 41 |                 } else if (strT == "/") {
 42 |                     d = d2 / d1;
 43 |                 }
 44 | 
 45 |                 dstk.push(d);
 46 |             }
 47 |         }
 48 |         return dstk.top();
 49 |     }
 50 |     double getResult()
 51 |     {
 52 |         double d = 0.0, d1 = 0.0, d2 = 0.0;
 53 |         LinkStack<double> dstk;
 54 |         string strT;
 55 | 
 56 |         for (auto it = _rpn.begin(); it != _rpn.end(); ++it) {
 57 |             strT = *it;
 58 |             if (isdigit(strT[0])) {
 59 |                 dstk.push(std::stod(strT));
 60 |             } else {
 61 |                 d1 = dstk.top();
 62 |                 dstk.pop();
 63 |                 d2 = dstk.top();
 64 |                 dstk.pop();
 65 | 
 66 |                 if (strT == "+") {
 67 |                     d = d2 + d1;
 68 |                 } else if (strT == "-") {
 69 |                     d = d2 - d1;
 70 |                 } else if (strT == "*") {
 71 |                     d = d2 * d1;
 72 |                 } else if (strT == "/") {
 73 |                     d = d2 / d1;
 74 |                 }
 75 | 
 76 |                 dstk.push(d);
 77 |             }
 78 |         }
 79 |         return dstk.top();
 80 |     }
 81 | 
 82 | private:
 83 |     const Vector<string> toRPN(const string &s)
 84 |     {
 85 |         Vector<string> vec;
 86 |         LinkStack<char> opStk;
 87 |         char tch[2] = { 0 };
 88 | 
 89 |         for (auto it = s.cbegin(); it != s.cend(); ++it) {
 90 |             if (isdigit(*it)) {
 91 |                 auto tit = it;
 92 |                 while (isdigit(*tit))
 93 |                     ++tit;
 94 |                 vec.push_back(string(it, tit));
 95 |                 it = --tit;
 96 |             } else {
 97 |                 switch (*it) {
 98 |                 case '(':
 99 |                     opStk.push(*it);
100 |                     break;
101 |                 case ')':
102 |                     tch[0] = opStk.top();
103 |                     while (tch[0] != '(') {
104 |                         vec.push_back(string(tch));
105 |                         opStk.pop();
106 |                         tch[0] = opStk.top();
107 |                     }
108 |                     opStk.pop();
109 |                     break;
110 |                 case '+':
111 |                 case '-':
112 |                     while (!opStk.empty()) {
113 |                         tch[0] = opStk.top();
114 |                         if (tch[0] == '(')
115 |                             break;
116 |                         opStk.pop();
117 |                         vec.push_back(string(tch));
118 |                     }
119 |                     opStk.push(*it);
120 |                     break;
121 |                 case '*':
122 |                 case '/':
123 |                     while (!opStk.empty()) {
124 |                         tch[0] = opStk.top();
125 |                         if (tch[0] == '(' || tch[0] == '+' || tch[0] == '-')
126 |                             break;
127 |                         opStk.pop();
128 |                         vec.push_back(string(tch));
129 |                     }
130 |                     opStk.push(*it);
131 |                     break;
132 |                 default:
133 |                     break;
134 |                 }
135 |             }
136 |         }
137 |         while (!opStk.empty()) {
138 |             tch[0] = opStk.top();
139 |             opStk.pop();
140 |             vec.push_back(string(tch));
141 |         }
142 |         return vec;
143 |     }
144 |     int priority(const char &ch)
145 |     {
146 |         switch (ch) {
147 |         case '+':
148 |         case '-':
149 |             return 1;
150 |         case '*':
151 |         case '/':
152 |             return 2;
153 |         case '(':
154 |             return 3;
155 |         default:
156 |             break;
157 |         }
158 |         return -1;
159 |     }
160 | 
161 | private:
162 |     Vector<string> _rpn;
163 | };
164 | 
165 | #endif // DS_CH03_SIMPLECALCULATOR_H
166 | 


--------------------------------------------------------------------------------
/Data-Structure.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <ItemGroup>
 22 |     <ClInclude Include="Chapter08\DisjSets.h" />
 23 |   </ItemGroup>
 24 |   <ItemGroup>
 25 |     <ClCompile Include="Chapter08\test.cpp" />
 26 |   </ItemGroup>
 27 |   <PropertyGroup Label="Globals">
 28 |     <ProjectGuid>{BB2BB86B-D2ED-42B0-AF95-C1F72D5031E6}</ProjectGuid>
 29 |     <RootNamespace>Data-Structure</RootNamespace>
 30 |     <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
 31 |   </PropertyGroup>
 32 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 33 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 34 |     <ConfigurationType>Application</ConfigurationType>
 35 |     <UseDebugLibraries>true</UseDebugLibraries>
 36 |     <PlatformToolset>v140</PlatformToolset>
 37 |     <CharacterSet>MultiByte</CharacterSet>
 38 |   </PropertyGroup>
 39 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 40 |     <ConfigurationType>Application</ConfigurationType>
 41 |     <UseDebugLibraries>false</UseDebugLibraries>
 42 |     <PlatformToolset>v140</PlatformToolset>
 43 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 44 |     <CharacterSet>MultiByte</CharacterSet>
 45 |   </PropertyGroup>
 46 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 47 |     <ConfigurationType>Application</ConfigurationType>
 48 |     <UseDebugLibraries>true</UseDebugLibraries>
 49 |     <PlatformToolset>v140</PlatformToolset>
 50 |     <CharacterSet>MultiByte</CharacterSet>
 51 |   </PropertyGroup>
 52 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 53 |     <ConfigurationType>Application</ConfigurationType>
 54 |     <UseDebugLibraries>false</UseDebugLibraries>
 55 |     <PlatformToolset>v140</PlatformToolset>
 56 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 57 |     <CharacterSet>MultiByte</CharacterSet>
 58 |   </PropertyGroup>
 59 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 60 |   <ImportGroup Label="ExtensionSettings">
 61 |   </ImportGroup>
 62 |   <ImportGroup Label="Shared">
 63 |   </ImportGroup>
 64 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 65 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 66 |   </ImportGroup>
 67 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 68 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 69 |   </ImportGroup>
 70 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 71 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 72 |   </ImportGroup>
 73 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 74 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 75 |   </ImportGroup>
 76 |   <PropertyGroup Label="UserMacros" />
 77 |   <PropertyGroup />
 78 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 79 |     <ClCompile>
 80 |       <WarningLevel>Level3</WarningLevel>
 81 |       <Optimization>Disabled</Optimization>
 82 |       <SDLCheck>true</SDLCheck>
 83 |     </ClCompile>
 84 |   </ItemDefinitionGroup>
 85 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 86 |     <ClCompile>
 87 |       <WarningLevel>Level3</WarningLevel>
 88 |       <Optimization>Disabled</Optimization>
 89 |       <SDLCheck>true</SDLCheck>
 90 |     </ClCompile>
 91 |   </ItemDefinitionGroup>
 92 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 93 |     <ClCompile>
 94 |       <WarningLevel>Level3</WarningLevel>
 95 |       <Optimization>MaxSpeed</Optimization>
 96 |       <FunctionLevelLinking>true</FunctionLevelLinking>
 97 |       <IntrinsicFunctions>true</IntrinsicFunctions>
 98 |       <SDLCheck>true</SDLCheck>
 99 |     </ClCompile>
100 |     <Link>
101 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
102 |       <OptimizeReferences>true</OptimizeReferences>
103 |     </Link>
104 |   </ItemDefinitionGroup>
105 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
106 |     <ClCompile>
107 |       <WarningLevel>Level3</WarningLevel>
108 |       <Optimization>MaxSpeed</Optimization>
109 |       <FunctionLevelLinking>true</FunctionLevelLinking>
110 |       <IntrinsicFunctions>true</IntrinsicFunctions>
111 |       <SDLCheck>true</SDLCheck>
112 |     </ClCompile>
113 |     <Link>
114 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
115 |       <OptimizeReferences>true</OptimizeReferences>
116 |     </Link>
117 |   </ItemDefinitionGroup>
118 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
119 |   <ImportGroup Label="ExtensionTargets">
120 |   </ImportGroup>
121 | </Project>


--------------------------------------------------------------------------------
/Chapter07/Sort.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH07_SORT_H
  2 | #define DS_CH07_SORT_H
  3 | 
  4 | #include <vector>
  5 | #include <algorithm>
  6 | 
  7 | //插入排序
  8 | template <typename T>
  9 | void insertionSort(vector<T> &a)
 10 | {
 11 |     int j = 0;
 12 |     T tmp;
 13 | 
 14 |     for (int p = 1; p < a.size() ; ++p) {
 15 |         tmp = a[p];
 16 |         for (j = p; j > 0 && tmp < a[j - 1]; --j) {
 17 |             a[j] = a[j - 1];
 18 |         }
 19 |         a[j] = tmp;
 20 |     }
 21 | }
 22 | 
 23 | template <typename T>
 24 | void insertionSort(vector<T> &a, int left, int right)
 25 | {
 26 |     int j = 0;
 27 |     T tmp;
 28 | 
 29 |     for (int p = left + 1; p < right + 1; ++p) {
 30 |         tmp = a[p];
 31 |         for (j = p; j > 0 && tmp < a[j - 1]; --j) {
 32 |             a[j] = a[j - 1];
 33 |         }
 34 |         a[j] = tmp;
 35 |     }
 36 | }
 37 | 
 38 | //希尔排序 使用Shell增量
 39 | template <typename T>
 40 | void shellSort(vector<T> &a)
 41 | {
 42 |     int i = 0, j = 0;
 43 |     T tmp;
 44 | 
 45 |     for (int gap = static_cast<int>(a.size() >> 1); gap > 0; gap >>= 1) {
 46 |         for (i = gap; i < a.size(); ++i) {
 47 |             tmp = a[i];
 48 |             for (j = i; j >= gap && tmp < a[j - gap]; j -= gap) {
 49 |                 a[j] = a[j - gap];
 50 |             }
 51 |             a[j] = tmp;
 52 |     	}
 53 |     }
 54 | }
 55 | 
 56 | //堆排序 不使用附加数组
 57 | inline int leftChild(int i)
 58 | {
 59 |     return (i << 1) + 1;
 60 | }
 61 | 
 62 | template <typename T>
 63 | void percolateDown(vector<T> &a, int hole, int n)
 64 | {
 65 |     int child = 0;
 66 |     T tmp;
 67 |     for (tmp = a[hole]; leftChild(hole) < n; hole = child) {
 68 |         child = leftChild(hole);
 69 |         //下面if里的第一个判断保证最后一个节点是左儿子的情况下的正确性
 70 |         if (child != n - 1 && a[child] < a[child + 1])
 71 |             ++child;
 72 |         if (tmp < a[child])
 73 |             a[hole] = a[child];
 74 |         else
 75 |             break;
 76 |     }
 77 |     a[hole] = tmp;
 78 | }
 79 | 
 80 | template <typename T>
 81 | void heapSort(vector<T> &a)
 82 | {
 83 |     //buildheap
 84 |     for (int i = static_cast<int>(a.size() >> 1); i >= 0; --i)
 85 |         percolateDown(a, i, static_cast<int>(a.size()));
 86 | 
 87 |     //deleteMax
 88 |     for (int i = static_cast<int>(a.size() - 1); i > 0; --i) {
 89 |         std::swap(a[0], a[i]);
 90 |         percolateDown(a, 0, i);
 91 |     }
 92 | }
 93 | 
 94 | //归并排序 递归实现
 95 | template <typename T>
 96 | void merge(vector<T> &a, vector<T> &tmp, int leftPos, int rightPos, int rightEnd)
 97 | {
 98 |     //进入这里的时候，A,B均已排序
 99 |     //A的范围[leftPos, leftEnd], B的范围[rightPos, rightEnd]
100 |     int leftEnd = rightPos - 1;
101 |     int tmpPos = leftPos;
102 |     int numElements = rightEnd - leftPos + 1;
103 | 
104 |     //A,B里的小者放入C 相关下标推进
105 |     while (leftPos <= leftEnd && rightPos <= rightEnd) {
106 |         if (a[leftPos] <= a[rightPos])
107 |             tmp[tmpPos++] = a[leftPos++];
108 |         else
109 |             tmp[tmpPos++] = a[rightPos++];
110 |     }
111 | 
112 |     while (leftPos <= leftEnd) //拷贝左半边
113 |         tmp[tmpPos++] = a[leftPos++];
114 | 
115 |     while (rightPos <= rightEnd) //或者拷贝右半边
116 |         tmp[tmpPos++] = a[rightPos++];
117 | 
118 |     for (int i = 0; i < numElements; ++i, --rightEnd)
119 |         a[rightEnd] = tmp[rightEnd]; //拷贝回去
120 | }
121 | 
122 | template <typename T>
123 | void mergeSort(vector<T> &a, vector<T> &tmp, int left, int right)
124 | {
125 |     if (left < right) {
126 |         int center = (left + right) >> 1;
127 |         mergeSort(a, tmp, left, center);
128 |         mergeSort(a, tmp, center + 1, right);
129 |         merge(a, tmp, left, center + 1, right);
130 |     }
131 | }
132 | 
133 | template <typename T>
134 | void mergeSort(vector<T> &a)
135 | {
136 |     vector<T> tmp(a.size());
137 |     mergeSort(a, tmp, 0, static_cast<int>(a.size() - 1));
138 | }
139 | 
140 | //ex 7.16 归并排序的非递归实现
141 | template <typename T>
142 | void mergeSort2(vector<T> &a)
143 | {
144 |     int n = static_cast<int>(a.size());
145 |     vector<T> tmp(n);
146 |     int part1Start = 0, part2Start = 0, part2End = 0;
147 | 
148 |     for (int subListSize = 1; subListSize < n ; subListSize <<= 1) {
149 |         part1Start = 0;
150 |         while (part1Start + subListSize < n - 1) {
151 |             part2Start = part1Start + subListSize;
152 |             part2End = std::min(n - 1, part2Start + subListSize - 1);
153 |             merge(a, tmp, part1Start, part2Start, part2End);
154 |             part1Start = part2End + 1;
155 |         }
156 |     }
157 | }
158 | 
159 | //快速排序
160 | template <typename T>
161 | const T &median3(vector<T> &a, int left, int right)
162 | {
163 |     int center = (left + right) >> 1;
164 |     if (a[center] < a[left])
165 |         std::swap(a[left], a[center]);
166 |     if (a[right] < a[left])
167 |         std::swap(a[left], a[right]);
168 |     if (a[right] < a[center])
169 |         std::swap(a[right], a[center]);
170 | 
171 |     std::swap(a[center], a[right - 1]);
172 |     return a[right - 1];
173 | }
174 | 
175 | template <typename T>
176 | void quickSort(vector<T> &a, int left, int right)
177 | {
178 |     if (left + 10 <= right) {
179 |         T pivot = median3(a, left, right);
180 | 
181 |         int i = left, j = right - 1;
182 |         for (;;) {
183 |             while (a[++i] < pivot) {}
184 |             while (pivot < a[--j]) {}
185 |             if (i < j)
186 |                 std::swap(a[i], a[j]);
187 |             else
188 |                 break;
189 |         }
190 | 
191 |         std::swap(a[i], a[right - 1]);
192 | 
193 |         quickSort(a, left, i - 1);
194 |         quickSort(a, i + 1, right);
195 |     } else {
196 |         insertionSort(a, left, right);
197 |     }
198 | }
199 | 
200 | template <typename T>
201 | void quickSort(vector<T> &a)
202 | {
203 |     quickSort(a, 0, static_cast<int>(a.size() - 1));
204 | }
205 | 
206 | //快速选择 执行完后第k个最小元是a[k-1]
207 | template <typename T>
208 | void quickSelect(vector<T> &a, int left, int right, int k)
209 | {
210 |     if (left + 10 <= right) {
211 |         T pivot = median3(a, left, right);
212 | 
213 |         int i = left, j = right - 1;
214 |         for (;;) {
215 |             while (a[++i] < pivot) {}
216 |             while (pivot < a[--j]) {}
217 |             if (i < j)
218 |                 std::swap(a[i], a[j]);
219 |             else
220 |                 break;
221 |         }
222 | 
223 |         std::swap(a[i], a[right - 1]);
224 | 
225 |         if (k <= i)
226 |             quickSelect(a, left, i - 1, k);
227 |         else if (k > i + 1)
228 |             quickSelect(a, i + 1, right, k);
229 |     } else {
230 |         insertionSort(a, left, right);
231 |     }
232 | }
233 | 
234 | #endif // DS_CH07_SORT_H
235 | 


--------------------------------------------------------------------------------
/Chapter04/exercise04.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH04_EXERCISE04_H
  2 | #define DS_CH04_EXERCISE04_H
  3 | 
  4 | //ex4.11 未考虑end()如何实现
  5 | template <typename T>
  6 | class Set {
  7 | private:
  8 |     struct BinaryNode {
  9 |         BinaryNode() : left(nullptr), right(nullptr), parent(nullptr)
 10 |         {}
 11 |         BinaryNode(const T &element)
 12 |             : ele(element), left(nullptr), right(nullptr), parent(nullptr)
 13 |         {}
 14 |         BinaryNode(const T &element, BinaryNode *lt, BinaryNode *rt, BinaryNode *pt)
 15 |             : ele(element), left(lt), right(rt), parent(pt)
 16 |         {}
 17 |         T ele;
 18 |         BinaryNode *left;
 19 |         BinaryNode *right;
 20 |         BinaryNode *parent;
 21 |     };
 22 | 
 23 | public:
 24 |     class const_iterator {
 25 |     public:
 26 |         const_iterator() : current(nullptr) {}
 27 |         const T &operator*() const { return retrieve(); }
 28 |         const_iterator &operator++()
 29 |         {
 30 |             BinaryNode *t;
 31 |             if (current->right) { //若存在右儿子，则下一个是右子树的最小值
 32 |                 t = current->right;
 33 |                 while (t->left != nullptr)
 34 |                     t = t->left;
 35 |                 current = t;
 36 |             } else { //否则上溯，若本身是右儿子则持续上溯
 37 |                 t = current->parent;
 38 |                 while (t != nullptr && t->ele < current->ele)
 39 |                     t = t->parent;
 40 |                 current = t;
 41 |             }
 42 |             return *this;
 43 |         }
 44 |         const_iterator &operator++(int)
 45 |         {
 46 |             const_iterator old = *this;
 47 |             ++(*this);
 48 |             return old;
 49 |         }
 50 | 
 51 |         bool operator==(const const_iterator &rhs) const
 52 |         {
 53 |             return current == rhs.current;
 54 |         }
 55 |         bool operator!=(const const_iterator &rhs) const
 56 |         {
 57 |             return !(*this == rhs);
 58 |         }
 59 | 
 60 |     protected:
 61 |         friend class Set<T>;
 62 |         const_iterator(BinaryNode *p) : current(p) {}
 63 |         T &retrieve() const { return current->ele; }
 64 |         BinaryNode *current;
 65 |     };
 66 | 
 67 |     class iterator : public const_iterator {
 68 |     public:
 69 |         iterator() {}
 70 | 
 71 |         T &operator*() { return retrieve(); }
 72 |         const T &operator*() const { return const_iterator::operator*(); }
 73 | 
 74 |         iterator &operator++()
 75 |         {
 76 |             BinaryNode *t;
 77 |             if (current->right) { //若存在右儿子，则下一个是右子树的最小值
 78 |                 t = current->right;
 79 |                 while (t->left != nullptr)
 80 |                     t = t->left;
 81 |                 current = t;
 82 |             } else { //否则上溯，若本身是右儿子则持续上溯
 83 |                 t = current->parent;
 84 |                 while (t != nullptr && t->ele < current->ele)
 85 |                     t = t->parent;
 86 |                 current = t;
 87 |             }
 88 |             return *this;
 89 |         }
 90 |         iterator &operator++(int)
 91 |         {
 92 |             iterator old = *this;
 93 |             ++(*this);
 94 |             return old;
 95 |         }
 96 | 
 97 |         bool operator==(const iterator &rhs) const
 98 |         {
 99 |             return current == rhs.current;
100 |         }
101 |         bool operator!=(const iterator &rhs) const
102 |         {
103 |             return !(*this == rhs);
104 |         }
105 |     protected:
106 |         friend class Set<T>;
107 |         iterator(BinaryNode *p) : const_iterator(p) {}
108 |     };
109 | 
110 | public:
111 |     Set() : root(nullptr) {}
112 |     Set(const Set &rhs) : root(nullptr) { operator=(rhs); }
113 |     ~Set() { clear(); }
114 | 
115 | public:
116 |     Set &operator=(const Set &rhs)
117 |     {
118 |         if (this != &rhs) {
119 |             clear();
120 |             const_iterator itr = rhs.begin();
121 |             for (int i = 0; i < rhs.size(); ++i) {
122 |                 insert(*itr);
123 |                 ++itr;
124 |             }
125 |         }
126 |         return *this;
127 |     }
128 | 
129 |     iterator insert(const T &x) { return insert(x, root, root); }
130 |     void erase(const T &x) { erase(x, root); }
131 |     
132 |     bool contains(const T &x) const { return contains(x, root); }
133 |     bool empty() const { return size() == 0; }
134 |     int size() const { return theSize; }
135 |     void clear()
136 |     {
137 |         while (!empty())
138 |             erase(*begin());
139 |     }
140 | 
141 |     iterator begin()
142 |     {
143 |         BinaryNode *t = root;
144 |         while (t->left != nullptr)
145 |             t = t->left;
146 |         return iterator(t);
147 |     }
148 |     const_iterator begin() const
149 |     {
150 |         BinaryNode *t = root;
151 |         while (t->left != nullptr)
152 |             t = t->left;
153 |         return const_iterator(t);
154 |     }
155 | 
156 | private:
157 |     bool contains(const T &x, BinaryNode *t) const
158 |     {
159 |         if (t == nullptr)
160 |             return false;
161 |         else if (x < t->ele)
162 |             return contains(x, t->left);
163 |         else if (t->ele < x)
164 |             return contains(x, t->right);
165 |         else
166 |             return true;
167 |     }
168 |     iterator insert(const T &x, BinaryNode *&t, BinaryNode *p)
169 |     {
170 |         if (t == nullptr) {
171 |             t = new BinaryNode(x, nullptr, nullptr, p);
172 |             ++theSize;
173 |             return iterator(t);
174 |         }
175 |         else if (x < t->ele)
176 |             return insert(x, t->left, t);
177 |         else if (t->ele < x)
178 |             return insert(x, t->right, t);
179 |         return iterator(t);
180 |     }
181 |     void erase(const T &x, BinaryNode *&t)
182 |     {
183 |         if (t == nullptr)
184 |             ;
185 |         else if (x < t->ele)
186 |             erase(x, t->left);
187 |         else if (t->ele < x)
188 |             erase(x, t->right);
189 |         else if (t->left != nullptr && t->right != nullptr) { //2 children
190 |             BinaryNode *tmp = t->right;
191 |             while (tmp->left != nullptr)
192 |                 tmp = tmp->left;
193 |             t->ele = tmp->ele; //用右子树的最小值替代当前值
194 |             erase(t->ele, t->right); //删掉右子树的最小值
195 |         } else {
196 |             BinaryNode *old = t;
197 |             t = (t->left != nullptr) ? t->left : t->right;
198 |             if (t != nullptr)
199 |                 t->parent = old->parent;
200 |             delete old;
201 |             --theSize;
202 |         }
203 |     }
204 | 
205 | private:
206 |     int theSize;
207 |     BinaryNode *root;
208 | };
209 | 
210 | #endif // DS_CH04_EXERCISE04_H
211 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 | 


--------------------------------------------------------------------------------
/Chapter04/AVLTree.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH04_AVLTREE_H
  2 | #define DS_CH04_AVLTREE_H
  3 | 
  4 | #include <algorithm>
  5 | #include <iostream>
  6 | using std::cout;
  7 | using std::endl;
  8 | 
  9 | template <typename T>
 10 | class AVLTree {
 11 | private:
 12 |     struct AVLNode {
 13 |         AVLNode (const T &element, AVLNode *lt, AVLNode *rt, int h = 0)
 14 |             : ele(element), left(lt), right(rt), height(h)
 15 |         {}
 16 |         T ele;
 17 |         AVLNode *left;
 18 |         AVLNode *right;
 19 |         int height;
 20 |     };
 21 | 
 22 | public:
 23 |     AVLTree() : root(nullptr) {}
 24 |     AVLTree(const AVLTree &rhs) { operator=(rhs); }
 25 |     ~AVLTree() { makeEmpty(); }
 26 | 
 27 | public:
 28 |     AVLTree &operator=(const AVLTree &rhs)
 29 |     {
 30 |         if (this != &rhs) {
 31 |             makeEmpty();
 32 |             root = clone(rhs.root);
 33 |         }
 34 |         return *this;
 35 |     }
 36 | 
 37 |     const T &findMin() const { return findMin(root)->ele; } //应保证非空调用
 38 |     const T &findMax() const { return findMax(root)->ele; } //应保证非空调用
 39 |     bool contains(const T &x) { return contains(x, root); }
 40 |     bool empty() const { return root == nullptr; }
 41 |     void printTree() const { printTree(root); }
 42 | 
 43 |     void makeEmpty() { makeEmpty(root); }
 44 |     void insert(const T &x) { insert(x, root); }
 45 |     void remove(const T &x) { remove(x, root); }
 46 | 
 47 | private:
 48 |     int height(AVLNode *t) const { return t == nullptr ? -1 : t->height; }
 49 | 
 50 |     AVLNode *clone(AVLNode *t) const
 51 |     {
 52 |         if (t == nullptr)
 53 |             return nullptr;
 54 | 
 55 |         return new AVLNode(t->ele, clone(t->left), clone(t->right), t->height);
 56 |     }
 57 |     AVLNode *findMin(AVLNode *t) const
 58 |     {
 59 |         if (t == nullptr)
 60 |             return nullptr;
 61 |         if (t->left == nullptr)
 62 |             return t;
 63 |         return findMin(t->left);
 64 |     }
 65 |     AVLNode *findMax(AVLNode *t) const
 66 |     {
 67 |         if (t != nullptr) {
 68 |             while (t->right != nullptr)
 69 |                 t = t->right;
 70 |         }
 71 |         return t;
 72 |     }
 73 |     bool contains(const T &x, AVLNode *t)
 74 |     {
 75 |         if (t == nullptr)
 76 |             return false;
 77 |         else if (x < t->ele)
 78 |             return contains(x, t->left);
 79 |         else if (t->ele < x)
 80 |             return contains(x, t->right);
 81 |         else
 82 |             return true;
 83 |     }
 84 |     void printDepth(const T &x, int depth = 0) const
 85 |     {
 86 |         while (depth--)
 87 |             cout << "\t";
 88 |         cout << "[" << x << "]" << endl;
 89 |     }
 90 |     void printTree(AVLNode *t, int depth = 0) const
 91 |     {
 92 |         if (t == nullptr)
 93 |             return; // do nothing
 94 |         printTree(t->left, depth + 1);
 95 |         printDepth(t->ele, depth); //这句放的位置决定了前中后序遍历
 96 |         printTree(t->right, depth + 1);
 97 |     }
 98 |     void makeEmpty(AVLNode *&t)
 99 |     {
100 |         if (t != nullptr) {
101 |             makeEmpty(t->left);
102 |             makeEmpty(t->right);
103 |             delete t;
104 |         }
105 |         t = nullptr;
106 |     }
107 | 
108 |     // 针对情况1左左，节点和左儿子一起顺时针旋转
109 |     void rotateWithLeft(AVLNode *&k2)
110 |     {
111 |         AVLNode *k1 = k2->left;
112 |         k2->left = k1->right;
113 |         k1->right = k2;
114 | 
115 |         k2->height = max(height(k2->left), height(k2->right)) + 1;
116 |         k1->height = max(height(k1->left), k2->height) + 1; // 右子树高度就是k2的高度
117 | 
118 |         k2 = k1; // 保证上一层节点链接到旋转后的节点
119 |     }
120 |     // 针对情况4右右，节点和右儿子一起逆时针旋转
121 |     void rotateWithRight(AVLNode *&k1)
122 |     {
123 |         AVLNode *k2 = k1->right;
124 |         k1->right = k2->left;
125 |         k2->left = k1;
126 | 
127 |         k1->height = max(height(k1->left), height(k1->right)) + 1;
128 |         k2->height = max(k1->height, height(k2->right)) + 1; // 左子树高度就是k2的高度
129 | 
130 |         k1 = k2; // 保证上一层节点链接到旋转后的节点
131 |     }
132 |     // 针对情况2左右，节点的左儿子先逆时针旋转，接着节点顺时针旋转
133 |     void doubleRotateWithLeft(AVLNode *&k3)
134 |     {
135 |         //rotateWithRight(k3->left);
136 |         //rotateWithLeft(k3);
137 | 
138 |         //ex 3.26 编写一个双旋转，效率高于两次单旋转
139 |         //分析旋转过程不难总结出来
140 |         AVLNode *k1 = k3->left;
141 |         AVLNode *k2 = k1->right;
142 | 
143 |         k1->right = k2->left;
144 |         k3->left = k2->right;
145 |         k2->left = k1;
146 |         k2->right = k3;
147 | 
148 |         k1->height = max(height(k1->left), height(k1->right)) + 1;
149 |         k3->height = max(height(k3->left), height(k3->right)) + 1;
150 |         k2->height = max(k1->height, k3->height) + 1;
151 | 
152 |         k3 = k2; // 保证上一层节点链接到旋转后的节点
153 |     }
154 |     // 针对情况3右左，节点的右儿子先顺时针旋转，接着节点逆时针旋转
155 |     void doubleRotateWithRight(AVLNode *&k1) 
156 |     {
157 |         //rotateWithLeft(k3->right);
158 |         //rotateWithRight(k3);
159 | 
160 |         //ex 3.26 编写一个双旋转，效率高于两次单旋转
161 |         //分析旋转过程不难总结出来
162 |         AVLNode *k3 = k1->right;
163 |         AVLNode *k2 = k3->left;
164 | 
165 |         k1->right = k2->left;
166 |         k3->left = k2->right;
167 |         k2->left = k1;
168 |         k2->right = k3;
169 | 
170 |         k1->height = max(height(k1->left), height(k1->right)) + 1;
171 |         k3->height = max(height(k3->left), height(k3->right)) + 1;
172 |         k2->height = max(k1->height, k3->height) + 1;
173 | 
174 |         k1 = k2; // 保证上一层节点链接到旋转后的节点
175 |     }
176 | 
177 |     void insert(const T &x, AVLNode *&t)
178 |     {
179 |         if (t == nullptr)
180 |             t = new AVLNode(x, nullptr, nullptr);
181 |         else if (x < t->ele) {
182 |             insert(x, t->left);
183 |             if (height(t->left) - height(t->right) == 2) {
184 |                 if (x < t->left->ele)
185 |                     rotateWithLeft(t);
186 |                 else
187 |                     doubleRotateWithLeft(t);
188 |             }
189 |         } else if (t->ele < x) {
190 |             insert(x, t->right);
191 |             if (height(t->right) - height(t->left) == 2) {
192 |                 if (t->right->ele < x)
193 |                     rotateWithRight(t);
194 |                 else
195 |                     doubleRotateWithRight(t);
196 |             }
197 |         } else
198 |             ; //do nothing
199 |         t->height = max(height(t->left), height(t->right)) + 1;
200 |     }
201 | 
202 |     //AVLTree删除节点的思路:
203 |     //1.像二叉查找树一样删除节点
204 |     //2.重新计算节点高度
205 |     //3.检查是否满足平衡条件，不满足需要调整
206 |     void remove(const T &x, AVLNode *&t)
207 |     {
208 |         if (t == nullptr)
209 |             return; //not found, do nothing
210 |         if (x < t->ele) {
211 |             remove(x, t->left);
212 | 
213 |             t->height = std::max(height(t->left), height(t->right)) + 1;
214 | 
215 |             //删了左子树一个节点，需要判断右＞左
216 |             if (height(t->right) - height(t->left) == 2) {
217 |                 if (height(t->right->right) >= height(t->right->left))
218 |                     rotateWithRight(t);
219 |                 else
220 |                     doubleRotateWithRight(t);
221 |             }
222 |         } else if (t->ele < x) {
223 |             remove(x, t->right);
224 | 
225 |             t->height = std::max(height(t->left), height(t->right)) + 1;
226 | 
227 |             //删了右子树一个节点，需要判断左＞右
228 |             if (height(t->left) - height(t->right) == 2) {
229 |                 if (height(t->left->left) >= height(t->left->right))
230 |                     rotateWithLeft(t);
231 |                 else
232 |                     doubleRotateWithLeft(t);
233 |             }
234 |         } else if (t->left != nullptr && t->right != nullptr) { //2 children
235 |             t->ele = findMin(t->right)->ele; //用右子树的最小值替代当前值
236 |             remove(t->ele, t->right); //删掉右子树的最小值
237 | 
238 |             t->height = std::max(height(t->left), height(t->right)) + 1;
239 | 
240 |             //删了右子树一个节点，需要判断左＞右
241 |             if (height(t->left) - height(t->right) == 2) {
242 |                 if (height(t->left->left) >= height(t->left->right))
243 |                     rotateWithLeft(t);
244 |                 else
245 |                     doubleRotateWithLeft(t);
246 |             }
247 |         } else {
248 |             AVLNode *old = t;
249 |             t = (t->left != nullptr) ? t->left : t->right;
250 |             delete old;
251 |         }
252 |     }
253 | 
254 | private:
255 |     AVLNode *root;
256 | };
257 | 
258 | #endif // DS_CH04_AVLTREE_H
259 | 


--------------------------------------------------------------------------------
/Chapter06/BinomialQueue.h:
--------------------------------------------------------------------------------
  1 | #ifndef DS_CH06_BINOMIALQUEUE_H
  2 | #define DS_CH06_BINOMIALQUEUE_H
  3 | 
  4 | #include <algorithm>
  5 | #include <vector>
  6 | #include <stdexcept>
  7 | 
  8 | using std::cout;
  9 | using std::endl;
 10 | 
 11 | template <typename T>
 12 | class BinomialQueue {
 13 |     enum { DEFAULT_TREES = 1 };
 14 | private:
 15 |     struct BinomialNode {
 16 |         BinomialNode(const T &theElement, BinomialNode *lt, BinomialNode *rt)
 17 |             : element(theElement), leftChild(lt), nextSibling(rt)
 18 |         {}
 19 |         T element;
 20 |         BinomialNode *leftChild;
 21 |         BinomialNode *nextSibling;
 22 |     };
 23 | 
 24 | public:
 25 |     BinomialQueue() : curSize(0), theTrees(DEFAULT_TREES) { init(); }
 26 |     explicit BinomialQueue(const T &x) : curSize(0), theTrees(DEFAULT_TREES)
 27 |     {
 28 |         init();
 29 |         ++curSize;
 30 |         theTrees[0] = new BinomialNode(x, nullptr, nullptr);
 31 |     }
 32 |     BinomialQueue(const BinomialQueue &rhs) { operator=(rhs); }
 33 |     ~BinomialQueue()
 34 |     {
 35 |         makeEmpty();
 36 |     }
 37 | 
 38 | public:
 39 |     BinomialQueue &operator=(const BinomialQueue &rhs)
 40 |     {
 41 |         if (this != &rhs) {
 42 |             makeEmpty();
 43 |             curSize = rhs.curSize;
 44 |             theTrees.resize(rhs.capacity());
 45 |             init();
 46 |             for (int i = 0; i < rhs.curSize; ++i) {
 47 |                 if (rhs.theTrees[i] != nullptr)
 48 |                     theTrees[i] = clone(rhs.theTrees[i]);
 49 |             }
 50 |         }
 51 |         return *this;
 52 |     }
 53 | 
 54 |     void printForest() const
 55 |     {
 56 |         for (const auto t : theTrees) {
 57 |             if (t != nullptr) {
 58 |                 printTree(t);
 59 |                 cout << "=============================================" << endl;
 60 |             }
 61 |         }
 62 |     }
 63 | 
 64 |     bool empty() const { return curSize == 0; }
 65 |     const T &findMin() const
 66 |     {
 67 |         if (empty())
 68 |             throw std::underflow_error("空二项队列");
 69 |         return theTrees[findMinIndex()]->element;
 70 |     }
 71 | 
 72 |     void insert(const T &x)
 73 |     {
 74 |         merge(BinomialQueue(x));
 75 |     }
 76 |     void deleteMin()
 77 |     {
 78 |         if (empty())
 79 |             throw std::underflow_error("空二项队列");
 80 | 
 81 |         int minIndex = findMinIndex();
 82 |         BinomialNode *oldRoot = theTrees[minIndex];
 83 |         BinomialNode *deletedTree = oldRoot->leftChild;
 84 |         delete oldRoot;
 85 | 
 86 |         // H'' 长度是min所在tree - 1（去掉min）
 87 |         BinomialQueue deletedQueue;
 88 |         deletedQueue.theTrees.resize(minIndex + 1);
 89 |         deletedQueue.curSize = (1 << minIndex) - 1;
 90 |         for (int j = minIndex - 1; j >= 0; --j) {
 91 |             deletedQueue.theTrees[j] = deletedTree;
 92 |             deletedTree = deletedTree->nextSibling;
 93 |             deletedQueue.theTrees[j]->nextSibling = nullptr;
 94 |         }
 95 | 
 96 |         // H' size是去掉H''和min
 97 |         theTrees[minIndex] = nullptr;
 98 |         curSize -= deletedQueue.curSize + 1;
 99 | 
100 |         merge(deletedQueue);
101 |     }
102 |     void deleteMin(T &minItem)
103 |     {
104 |         if (empty())
105 |             throw std::underflow_error("空二项队列");
106 | 
107 |         int minIndex = findMinIndex();
108 |         minItem = theTrees[minIndex]->element;
109 | 
110 |         BinomialNode *oldRoot = theTrees[minIndex];
111 |         BinomialNode *deletedTree = oldRoot->leftChild;
112 |         delete oldRoot;
113 | 
114 |         // H'' 长度是min所在tree - 1（去掉min）
115 |         BinomialQueue deletedQueue;
116 |         deletedQueue.theTrees.resize(minIndex + 1);
117 |         deletedQueue.curSize = (1 << minIndex) - 1;
118 |         for (int j = minIndex - 1; j >= 0; --j) {
119 |             deletedQueue.theTrees[j] = deletedTree;
120 |             deletedTree = deletedTree->nextSibling;
121 |             deletedQueue.theTrees[j]->nextSibling = nullptr;
122 |         }
123 | 
124 |         // H' size是去掉H''和min
125 |         theTrees[minIndex] = nullptr;
126 |         curSize -= deletedQueue.curSize + 1;
127 | 
128 |         merge(deletedQueue);
129 |     }
130 | 
131 |     void makeEmpty()
132 |     {
133 |         for (auto &t : theTrees) {
134 |             deleteTree(t);
135 |         }
136 |         curSize = 0;
137 |     }
138 |     void merge(BinomialQueue &rhs)
139 |     {
140 |         if (this == &rhs)
141 |             return;
142 | 
143 |         curSize += rhs.curSize;
144 | 
145 |         if (curSize > capacity()) {
146 |             auto oldNumTrees = theTrees.size();
147 |             auto newNumTrees = std::max(theTrees.size(), rhs.theTrees.size()) + 1;
148 |             theTrees.resize(newNumTrees);
149 |             for (auto i = oldNumTrees; i < newNumTrees; ++i)
150 |                 theTrees[i] = nullptr;
151 |         }
152 | 
153 |         BinomialNode *carry = nullptr; //用来进位
154 |         for (int i = 0, j = 1; j <= curSize; ++i, j <<= 1) {
155 |             BinomialNode *t1 = theTrees[i];
156 |             BinomialNode *t2 = i < rhs.theTrees.size() ? rhs.theTrees[i] : nullptr;
157 | 
158 |             int whichCase = t1 == nullptr ? 0 : 1;
159 |             whichCase += t2 == nullptr ? 0 : 2;
160 |             whichCase += carry == nullptr ? 0 : 4;
161 | 
162 |             switch (whichCase) {
163 |             case 0: //空树
164 |             case 1: //rhs空
165 |                 break;
166 |             case 2: //this空
167 |                 theTrees[i] = t2;
168 |                 break;
169 |             case 4: //只有carry
170 |                 theTrees[i] = carry;
171 |                 carry = nullptr;
172 |                 break;
173 |             case 3: //this和rhs
174 |                 carry = combineTrees(t1, t2);
175 |                 theTrees[i] = rhs.theTrees[i] = nullptr;
176 |                 break;
177 |             case 5: //this和carry
178 |                 carry = combineTrees(t1, carry);
179 |                 theTrees[i] = nullptr;
180 |                 break;
181 |             case 6: //rhs和carry
182 |                 carry = combineTrees(t2, carry);
183 |                 rhs.theTrees[i] = nullptr;
184 |                 break;
185 |             case 7: //都有
186 |                 theTrees[i] = carry;
187 |                 carry = combineTrees(t1, t2);
188 |                 rhs.theTrees[i] = nullptr;
189 |                 break;
190 |             }
191 |         }
192 | 
193 |         rhs.init();
194 |     }
195 | 
196 | private:
197 |     void printDepth(const T &x, int depth = 0) const
198 |     {
199 |         while (depth--)
200 |             cout << "\t";
201 |         cout << "[" << x << "]" << endl;
202 |     }
203 |     void printTree(BinomialNode *t, int depth = 0) const
204 |     {
205 |         if (t == nullptr)
206 |             return; // do nothing
207 |         printTree(t->leftChild, depth + 1);
208 |         printDepth(t->element, depth); //这句放的位置决定了前中后序遍历
209 |         printTree(t->nextSibling, depth + 1);
210 |     }
211 |     void init()
212 |     {
213 |         curSize = 0;
214 |         for (auto &t : theTrees)
215 |             t = nullptr;
216 |     }
217 |     void deleteTree(BinomialNode *&t)
218 |     {
219 |         if (t != nullptr) {
220 |             deleteTree(t->leftChild);
221 |             deleteTree(t->nextSibling);
222 |             delete t;
223 |             t = nullptr;
224 |         }
225 |     }
226 |     int findMinIndex() const
227 |     {
228 |         int i = 0, minIndex = 0;
229 |         while (theTrees[i] == nullptr)
230 |             ++i;
231 |         for (minIndex = i; i < theTrees.size(); ++i) {
232 |             if (theTrees[i] != nullptr &&
233 |                 theTrees[i]->element < theTrees[minIndex]->element) {
234 |                 minIndex = i;
235 |             }
236 |         }
237 |         return minIndex;
238 |     }
239 |     int capacity() const { return static_cast<int>(theTrees.capacity()); }
240 |     BinomialNode *combineTrees(BinomialNode *t1, BinomialNode *t2)
241 |     {
242 |         if (t2->element < t1->element)
243 |             return combineTrees(t2, t1);
244 |         t2->nextSibling = t1->leftChild;
245 |         t1->leftChild = t2;
246 |         return t1;
247 |     }
248 |     BinomialNode *clone(BinomialNode *t) const
249 |     {
250 |         if (t == nullptr)
251 |             return nullptr;
252 |         return new BinomialNode(t->element, clone(t->leftChild), clone(t->nextSibling));
253 |     }
254 | 
255 | private:
256 |     int curSize;
257 |     vector<BinomialNode *> theTrees; //若13个元素，则theTrees里是[0 0 0 0 1 1 0 1]存储
258 | };
259 | 
260 | #endif // DS_CH06_BINOMIALQUEUE_H
261 | 


--------------------------------------------------------------------------------