本文为PAT甲级分类汇编系列文章。
AVL树好难！（其实还好啦~）
我本来想着今天应该做不完树了，没想到电脑里有一份讲义，PPT和源代码都有，就一遍复习一遍抄码了一遍，更没想到的是编译一遍通过，再没想到的是运行也正常，最没想到的是一遍AC。
其实很多题都有数，std::set 之类用的是红黑树，据说很复杂，比AVL树还要复杂的那种。但是，用到这些设施的题，都不在这一分类下，这一分类下的题，因为题目要求自己建树，也就不用标准库设施了。
大多数题中，树在内存中都是连续存放的。不是像完全二叉树那样的连续，是物理上连续而逻辑上用数组下表代替指针。
| 题号 | 标题 | 分数 | 大意 |
| 1053 | Path of Equal Weight | 30 | 寻找树中一定权重的路径 |
| 1064 | Complete Binary Search Tree | 30 | 完全二叉搜索树 |
| 1066 | Root of AVL Tree | 25 | AVL树的根 |
| 1086 | Tree Traversals Again | 25 | 中序遍历逆推 |
| 1094 | The Largest Generation | 25 | 树中元素最多的层 |
| 1099 | Build A Binary Search Tree | 30 | 建立二叉搜索树 |
这一系列的题还是清一色地某姥姥出的。
学数据结构的时候做过1064和1086，遇到过1066，但跳过了。
这次除了1086和1094都写，毕竟不能放着30分题不管。30分题一遍AC，别提有多爽了。
1053：
要求按非升序输出权重，使其和为给定值。
一开始没看清题，以为是根节点到任意节点，就写了个有点像Dijkstra的东西，后来跑样例结果不对，才发现是根节点到叶节点，反而更简单了。
1 #include <iostream> 2 #include <vector> 3 #include <queue> 4 #include <algorithm> 5 6 struct Node 7 { 8 int index; 9 int weight; 10 std::vector<int> children; 11 std::vector<int> weights; 12 int total; 13 }; 14 15 int main() 16 { 17 int num_node, num_nonleaf, target; 18 std::cin >> num_node >> num_nonleaf >> target; 19 std::vector<Node> nodes(num_node); 20 for (auto& n : nodes) 21 std::cin >> n.weight; 22 for (int i = 0; i != num_node; ++i) 23 nodes[i].index = i; 24 for (int i = 0; i != num_nonleaf; ++i) 25 { 26 int index; 27 std::cin >> index; 28 auto& node = nodes[index]; 29 int count; 30 std::cin >> count; 31 node.children.resize(count); 32 for (auto& i : node.children) 33 std::cin >> i; 34 } 35 if (nodes.front().weight == target) 36 { 37 std::cout << target; 38 return 0; 39 } 40 nodes.front().total = nodes.front().weight; 41 nodes.front().weights.push_back(nodes.front().weight); 42 std::queue<int> queue; 43 std::vector<int> selected; 44 queue.push(0); 45 while (!queue.empty()) 46 { 47 auto& node = nodes[queue.front()]; 48 queue.pop(); 49 for (auto& i : node.children) 50 { 51 auto& n = nodes[i]; 52 n.weights = node.weights; 53 n.weights.push_back(n.weight); 54 n.total = node.total + n.weight; 55 if (n.total == target && n.children.empty()) 56 selected.push_back(n.index); 57 else if (n.total < target) 58 queue.push(n.index); 59 } 60 } 61 std::sort(selected.begin(), selected.end(), [&](int i, int j) { 62 return nodes[i].weights > nodes[j].weights; 63 }); 64 for (const auto& i : selected) 65 { 66 auto& node = nodes[i]; 67 auto end = node.weights.end() - 1; 68 for (auto iter = node.weights.begin(); iter != end; ++iter) 69 std::cout << *iter << ' '; 70 std::cout << *end; 71 std::cout << std::endl; 72 } 73 }
一个小坑是根节点权重就是要求的值，而我的算法总是处理当前节点的子节点，而根节点没有前驱节点，所以要加个特殊情况讨论。一个case而已，想了两分钟就发现了。
1064：
作为标准库的狂热爱好者，我写的数据结构最好也要有迭代器，这道题是绝佳的平台。层序遍历迭代器就用 std::vector 的迭代器就行，中序遍历迭代器得自己写。
1 #include <iostream> 2 #include <vector> 3 #include <algorithm> 4 #include <queue> 5 6 class InOrderIterator 7 { 8 public: 9 InOrderIterator(std::vector<int>& _rVector) 10 : data_(_rVector) 11 { 12 auto s = data_.size() - 1; 13 int count = 0; 14 while (s >>= 1) 15 ++count; 16 index_ = 1 << count; 17 } 18 int& operator*() 19 { 20 return data_[index_]; 21 } 22 InOrderIterator& operator++() 23 { 24 if (index_ * 2 + 1 < data_.size()) 25 { 26 index_ = index_ * 2 + 1; 27 while ((index_ *= 2) < data_.size()) 28 ; 29 index_ /= 2; 30 } 31 else 32 { 33 int count = 1, i = index_; 34 while (i % 2) 35 i >>= 1, ++count; 36 index_ >>= count; 37 } 38 return *this; 39 } 40 private: 41 std::vector<int>& data_; 42 int index_; 43 }; 44 45 int main(int argc, char const *argv[]) 46 { 47 int n; 48 std::cin >> n; 49 std::vector<int> data(n); 50 for (int i = 0; i != n; ++i) 51 std::cin >> data[i]; 52 53 std::sort(data.begin(), data.end()); 54 std::vector<int> tree(n + 1); 55 InOrderIterator iter(tree); 56 for (auto i : data) 57 *iter = i, ++iter; 58 59 auto size = tree.size() - 1; 60 for (auto i = 1; i != size; ++i) 61 std::cout << tree[i] << ' '; 62 std::cout << tree[size]; 63 64 return 0; 65 }
这个迭代算法我想了好久，当时觉得很优雅。现在自己都看不懂，好像是什么位操作吧。
然而，同样是迭代，1099题中的算法就比这个简单得多，后面会讲。
1066：
这道题我一直不敢做。实际上，左旋右旋什么的在我的脑海中一直都只是名词——我从未实现过一个AVL树，直到今天。在PPT与代码的帮助下，我顺利地写了一个AvlTree类模板，实现了一部分接口。
AVL树的4种旋转，学的时候听得懂，写的时候觉得烦，真的写完了也不过如此，其实没什么复杂的。
1 #include <iostream> 2 #include <utility> 3 #include <functional> 4 5 template <typename T, typename Comp = std::less<T>> 6 class AvlTree 7 { 8 public: 9 AvlTree(); 10 void insert(T _key); 11 void root(T& _target); 12 private: 13 struct Node 14 { 15 Node(T&& _key); 16 T key_; 17 Node* left_ = nullptr; 18 Node* right_ = nullptr; 19 int height_; 20 static int height(Node* _node); 21 }; 22 Node* node_ = nullptr; 23 static void insert(Node*& _node, T&& _key); 24 static void single_left(Node*& _node); 25 static void single_right(Node*& _node); 26 static void double_left_right(Node*& _node); 27 static void double_right_left(Node*& _node); 28 }; 29 30 template<typename T, typename Comp> 31 AvlTree<T, Comp>::AvlTree() = default; 32 template<typename T, typename Comp> 33 void AvlTree<T, Comp>::insert(T _key) 34 { 35 insert(node_, std::move(_key)); 36 } 37 38 template<typename T, typename Comp> 39 void AvlTree<T, Comp>::root(T& _target) 40 { 41 if (node_) 42 _target = node_->key_; 43 } 44 45 template<typename T, typename Comp> 46 void AvlTree<T, Comp>::insert(Node*& _node, T&& _key) 47 { 48 if (!_node) 49 _node = new Node(std::move(_key)); 50 else if (Comp()(_key, _node->key_)) 51 { 52 insert(_node->left_, std::move(_key)); 53 if (Node::height(_node->left_) - Node::height(_node->right_) == 2) 54 if (Comp()(_key, _node->left_->key_)) 55 single_left(_node); 56 else 57 double_left_right(_node); 58 } 59 else if (Comp()(_node->key_, _key)) 60 { 61 insert(_node->right_, std::move(_key)); 62 if (Node::height(_node->right_) - Node::height(_node->left_) == 2) 63 if (Comp()(_node->right_->key_, _key)) 64 single_right(_node); 65 else 66 double_right_left(_node); 67 } 68 Node::height(_node); 69 } 70 71 template<typename T, typename Comp> 72 void AvlTree<T, Comp>::single_left(Node*& _node) 73 { 74 auto temp = _node->left_; 75 _node->left_ = temp->right_; 76 temp->right_ = _node; 77 Node::height(_node); 78 Node::height(temp); 79 _node = temp; 80 } 81 82 template<typename T, typename Comp> 83 void AvlTree<T, Comp>::single_right(Node*& _node) 84 { 85 auto temp = _node->right_; 86 _node->right_ = temp->left_; 87 temp->left_ = _node; 88 Node::height(_node); 89 Node::height(temp); 90 _node = temp; 91 } 92 93 template<typename T, typename Comp> 94 void AvlTree<T, Comp>::double_left_right(Node*& _node) 95 { 96 single_right(_node->left_); 97 single_left(_node); 98 } 99 100 template<typename T, typename Comp> 101 void AvlTree<T, Comp>::double_right_left(Node*& _node) 102 { 103 single_left(_node->right_); 104 single_right(_node); 105 } 106 107 template<typename T, typename Comp> 108 AvlTree<T, Comp>::Node::Node(T&& _key) 109 : key_(std::move(_key)) 110 { 111 ; 112 } 113 114 template<typename T, typename Comp> 115 int AvlTree<T, Comp>::Node::height(Node* _node) 116 { 117 if (!_node) 118 return 0; 119 auto left = _node->left_ ? height(_node->left_) : 0; 120 auto right = _node->right_ ? height(_node->right_) : 0; 121 _node->height_ = (left > right ? left : right) + 1; 122 return _node->height_; 123 } 124 125 int main() 126 { 127 AvlTree<int> tree; 128 int num; 129 std::cin >> num; 130 for (int i = 0; i != num; ++i) 131 { 132 int t; 133 std::cin >> t; 134 tree.insert(t); 135 } 136 int root; 137 tree.root(root); 138 std::cout << root; 139 }
1099：
给定一个二叉搜索树结构和一系列数据，让你往里填，然后层序输出。
只要可以递归，前中后序遍历都不是问题。这道题讲明了N小于等于100，就算100级递归也OK，那就当然没有必要避免递归。
等等，我不是标准库的狂热爱好者吗？都用起递归了，还怎么写迭代器啊？用递归就一定不是迭代器吗？不然。
迭代是什么？数学上，迭代表现为a=f(a)；程序设计中，迭代可以是 i = i + 1; ，这是很数学的写法。C/C++提供了前缀++运算符以代替这一语句，《设计模式》中的迭代器用 Next() 方法来移动到下一个位置。久而久之，迭代器的数学意义上的“迭代”已经不明显了，以至于迭代器在程序设计中似乎就是指那些能遍历容器的对象。由此，《设计模式》提出了内部迭代器与外部迭代器的概念。
内部迭代器不对外开放，由类本身控制移动，接受谓词参数。优点是实现比较方便，缺点是在那个C++98都没有的年代，C++根本不支持这个，除非紧耦合——你在《设计模式》里紧耦合？
外部迭代器是交给客户使用的，有客户控制。优点是可由客户来控制，可以同时存在多个迭代器等，缺点是实现可能很复杂，比如前面那道题的中序迭代器。
分析完这些概念后，我想在这道题中，最适合的应该是内部迭代器了吧。
1 #include <iostream> 2 #include <vector> 3 #include <queue> 4 #include <algorithm> 5 6 struct Node 7 { 8 int key; 9 int left; 10 int right; 11 int parent; 12 }; 13 14 template <typename F> 15 void traverse(std::vector<Node>& nodes, int index, F functor) 16 { 17 auto& n = nodes[index]; 18 if (n.left != -1) 19 traverse(nodes, n.left, functor); 20 functor(n.key); 21 if (n.right != -1) 22 traverse(nodes, n.right, functor); 23 } 24 25 int main() 26 { 27 int num; 28 std::cin >> num; 29 std::vector<Node> nodes(num); 30 for (int i = 0; i != num; ++i) 31 { 32 auto& n = nodes[i]; 33 std::cin >> n.left >> n.right; 34 if (n.left != -1) 35 nodes[n.left].parent = i; 36 if (n.right != -1) 37 nodes[n.right].parent = i; 38 } 39 std::vector<int> keys(num); 40 for (auto& i : keys) 41 std::cin >> i; 42 std::sort(keys.begin(), keys.end()); 43 auto iter = keys.begin(); 44 traverse(nodes, 0, [&](int& key) { key = *iter++; }); 45 std::queue<int> queue; 46 queue.push(0); 47 int count = 0; 48 while (!queue.empty()) 49 { 50 if (count++) 51 std::cout << ' '; 52 auto i = queue.front(); 53 queue.pop(); 54 auto& n = nodes[i]; 55 std::cout << n.key; 56 if (n.left != -1) 57 queue.push(n.left); 58 if (n.right != -1) 59 queue.push(n.right); 60 } 61 }
我没法准确指明到底哪个东西是所谓内部迭代器。迭代器用于遍历，我只能说，函数模板 traverse 提供一个遍历的接口。和递归版本的树的遍历一样，它也会调用自身。
相比于之前复杂到看不懂的中序迭代器逻辑，这里的迭代器的功能与实现都简洁明了。既用上了递归，使实现简化，又降低了耦合，真是两全其美。