diff --git a/src/MyTinySTL-master/MyTinySTL/map.h b/src/MyTinySTL-master/MyTinySTL/map.h index da61c59..e49789c 100644 --- a/src/MyTinySTL-master/MyTinySTL/map.h +++ b/src/MyTinySTL-master/MyTinySTL/map.h @@ -1,549 +1,549 @@ -#ifndef MYTINYSTL_MAP_H_ -#define MYTINYSTL_MAP_H_ - -// 这个头文件包含了两个模板类 map 和 multimap -// map : 映射，元素具有键值和实值，会根据键值大小自动排序，键值不允许重复 -// multimap : 映射，元素具有键值和实值，会根据键值大小自动排序，键值允许重复 - -// notes: -// -// 异常保证： -// mystl::map / mystl::multimap 满足基本异常保证，对以下等函数做强异常安全保证： -// * emplace -// * emplace_hint -// * insert - -#include "rb_tree.h" - -namespace mystl -{ - -// 模板类 map，键值不允许重复 -// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less -template > -class map -{ -public: - // map 的嵌套型别定义 - typedef Key key_type; - typedef T mapped_type; - typedef mystl::pair value_type; - typedef Compare key_compare; - - // 定义一个 functor，用来进行元素比较 - class value_compare : public binary_function - { - friend class map; - private: - Compare comp; - value_compare(Compare c) : comp(c) {} - public: - bool operator()(const value_type& lhs, const value_type& rhs) const - { - return comp(lhs.first, rhs.first); // 比较键值的大小 - } - }; - -private: - // 以 mystl::rb_tree 作为底层机制 - typedef mystl::rb_tree base_type; - base_type tree_; - -public: - // 使用 rb_tree 的型别 - typedef typename base_type::node_type node_type; - typedef typename base_type::pointer pointer; - typedef typename base_type::const_pointer const_pointer; - typedef typename base_type::reference reference; - typedef typename base_type::const_reference const_reference; - typedef typename base_type::iterator iterator; - typedef typename base_type::const_iterator const_iterator; - typedef typename base_type::reverse_iterator reverse_iterator; - typedef typename base_type::const_reverse_iterator const_reverse_iterator; - typedef typename base_type::size_type size_type; - typedef typename base_type::difference_type difference_type; - typedef typename base_type::allocator_type allocator_type; - -public: - // 构造、复制、移动、赋值函数 - - map() = default; - - template - map(InputIterator first, InputIterator last) - :tree_() - { tree_.insert_unique(first, last); } - - map(std::initializer_list ilist) - :tree_() - { tree_.insert_unique(ilist.begin(), ilist.end()); } - - map(const map& rhs) - :tree_(rhs.tree_) - { - } - map(map&& rhs) noexcept - :tree_(mystl::move(rhs.tree_)) - { - } - - map& operator=(const map& rhs) - { - tree_ = rhs.tree_; - return *this; - } - map& operator=(map&& rhs) - { - tree_ = mystl::move(rhs.tree_); - return *this; - } - - map& operator=(std::initializer_list ilist) - { - tree_.clear(); - tree_.insert_unique(ilist.begin(), ilist.end()); - return *this; - } - - // 相关接口 - - key_compare key_comp() const { return tree_.key_comp(); } - value_compare value_comp() const { return value_compare(tree_.key_comp()); } - allocator_type get_allocator() const { return tree_.get_allocator(); } - - // 迭代器相关 - - iterator begin() noexcept - { return tree_.begin(); } - const_iterator begin() const noexcept - { return tree_.begin(); } - iterator end() noexcept - { return tree_.end(); } - const_iterator end() const noexcept - { return tree_.end(); } - - reverse_iterator rbegin() noexcept - { return reverse_iterator(end()); } - const_reverse_iterator rbegin() const noexcept - { return const_reverse_iterator(end()); } - reverse_iterator rend() noexcept - { return reverse_iterator(begin()); } - const_reverse_iterator rend() const noexcept - { return const_reverse_iterator(begin()); } - - const_iterator cbegin() const noexcept - { return begin(); } - const_iterator cend() const noexcept - { return end(); } - const_reverse_iterator crbegin() const noexcept - { return rbegin(); } - const_reverse_iterator crend() const noexcept - { return rend(); } - - // 容量相关 - bool empty() const noexcept { return tree_.empty(); } - size_type size() const noexcept { return tree_.size(); } - size_type max_size() const noexcept { return tree_.max_size(); } - - // 访问元素相关 - - // 若键值不存在，at 会抛出一个异常 - mapped_type& at(const key_type& key) - { - iterator it = lower_bound(key); - // it->first >= key - THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), - "map no such element exists"); - return it->second; - } - const mapped_type& at(const key_type& key) const - { - const_iterator it = lower_bound(key); - // it->first >= key - THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), - "map no such element exists"); - return it->second; - } - - mapped_type& operator[](const key_type& key) - { - iterator it = lower_bound(key); - // it->first >= key - if (it == end() || key_comp()(key, it->first)) - it = emplace_hint(it, key, T{}); - return it->second; - } - mapped_type& operator[](key_type&& key) - { - iterator it = lower_bound(key); - // it->first >= key - if (it == end() || key_comp()(key, it->first)) - it = emplace_hint(it, mystl::move(key), T{}); - return it->second; - } - - // 插入删除相关 - - template - pair emplace(Args&& ...args) - { - return tree_.emplace_unique(mystl::forward(args)...); - } - - template - iterator emplace_hint(iterator hint, Args&& ...args) - { - return tree_.emplace_unique_use_hint(hint, mystl::forward(args)...); - } - - pair insert(const value_type& value) - { - return tree_.insert_unique(value); - } - pair insert(value_type&& value) - { - return tree_.insert_unique(mystl::move(value)); - } - - iterator insert(iterator hint, const value_type& value) - { - return tree_.insert_unique(hint, value); - } - iterator insert(iterator hint, value_type&& value) - { - return tree_.insert_unique(hint, mystl::move(value)); - } - - template - void insert(InputIterator first, InputIterator last) - { - tree_.insert_unique(first, last); - } - - void erase(iterator position) { tree_.erase(position); } - size_type erase(const key_type& key) { return tree_.erase_unique(key); } - void erase(iterator first, iterator last) { tree_.erase(first, last); } - - void clear() { tree_.clear(); } - - // map 相关操作 - - iterator find(const key_type& key) { return tree_.find(key); } - const_iterator find(const key_type& key) const { return tree_.find(key); } - - size_type count(const key_type& key) const { return tree_.count_unique(key); } - - iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } - const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } - - iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } - const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } - - pair - equal_range(const key_type& key) - { return tree_.equal_range_unique(key); } - - pair - equal_range(const key_type& key) const - { return tree_.equal_range_unique(key); } - - void swap(map& rhs) noexcept - { tree_.swap(rhs.tree_); } - -public: - friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; } - friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; } -}; - -// 重载比较操作符 -template -bool operator==(const map& lhs, const map& rhs) -{ - return lhs == rhs; -} - -template -bool operator<(const map& lhs, const map& rhs) -{ - return lhs < rhs; -} - -template -bool operator!=(const map& lhs, const map& rhs) -{ - return !(lhs == rhs); -} - -template -bool operator>(const map& lhs, const map& rhs) -{ - return rhs < lhs; -} - -template -bool operator<=(const map& lhs, const map& rhs) -{ - return !(rhs < lhs); -} - -template -bool operator>=(const map& lhs, const map& rhs) -{ - return !(lhs < rhs); -} - -// 重载 mystl 的 swap -template -void swap(map& lhs, map& rhs) noexcept -{ - lhs.swap(rhs); -} - -/*****************************************************************************************/ - -// 模板类 multimap，键值允许重复 -// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less -template > -class multimap -{ -public: - // multimap 的型别定义 - typedef Key key_type; - typedef T mapped_type; - typedef mystl::pair value_type; - typedef Compare key_compare; - - // 定义一个 functor，用来进行元素比较 - class value_compare : public binary_function - { - friend class multimap; - private: - Compare comp; - value_compare(Compare c) : comp(c) {} - public: - bool operator()(const value_type& lhs, const value_type& rhs) const - { - return comp(lhs.first, rhs.first); - } - }; - -private: - // 用 mystl::rb_tree 作为底层机制 - typedef mystl::rb_tree base_type; - base_type tree_; - -public: - // 使用 rb_tree 的型别 - typedef typename base_type::node_type node_type; - typedef typename base_type::pointer pointer; - typedef typename base_type::const_pointer const_pointer; - typedef typename base_type::reference reference; - typedef typename base_type::const_reference const_reference; - typedef typename base_type::iterator iterator; - typedef typename base_type::const_iterator const_iterator; - typedef typename base_type::reverse_iterator reverse_iterator; - typedef typename base_type::const_reverse_iterator const_reverse_iterator; - typedef typename base_type::size_type size_type; - typedef typename base_type::difference_type difference_type; - typedef typename base_type::allocator_type allocator_type; - -public: - // 构造、复制、移动函数 - - multimap() = default; - - template - multimap(InputIterator first, InputIterator last) - :tree_() - { tree_.insert_multi(first, last); } - multimap(std::initializer_list ilist) - :tree_() - { tree_.insert_multi(ilist.begin(), ilist.end()); } - - multimap(const multimap& rhs) - :tree_(rhs.tree_) - { - } - multimap(multimap&& rhs) noexcept - :tree_(mystl::move(rhs.tree_)) - { - } - - multimap& operator=(const multimap& rhs) - { - tree_ = rhs.tree_; - return *this; - } - multimap& operator=(multimap&& rhs) - { - tree_ = mystl::move(rhs.tree_); - return *this; - } - - multimap& operator=(std::initializer_list ilist) - { - tree_.clear(); - tree_.insert_multi(ilist.begin(), ilist.end()); - return *this; - } - - // 相关接口 - - key_compare key_comp() const { return tree_.key_comp(); } - value_compare value_comp() const { return value_compare(tree_.key_comp()); } - allocator_type get_allocator() const { return tree_.get_allocator(); } - - // 迭代器相关 - - iterator begin() noexcept - { return tree_.begin(); } - const_iterator begin() const noexcept - { return tree_.begin(); } - iterator end() noexcept - { return tree_.end(); } - const_iterator end() const noexcept - { return tree_.end(); } - - reverse_iterator rbegin() noexcept - { return reverse_iterator(end()); } - const_reverse_iterator rbegin() const noexcept - { return const_reverse_iterator(end()); } - reverse_iterator rend() noexcept - { return reverse_iterator(begin()); } - const_reverse_iterator rend() const noexcept - { return const_reverse_iterator(begin()); } - - const_iterator cbegin() const noexcept - { return begin(); } - const_iterator cend() const noexcept - { return end(); } - const_reverse_iterator crbegin() const noexcept - { return rbegin(); } - const_reverse_iterator crend() const noexcept - { return rend(); } - - // 容量相关 - bool empty() const noexcept { return tree_.empty(); } - size_type size() const noexcept { return tree_.size(); } - size_type max_size() const noexcept { return tree_.max_size(); } - - // 插入删除操作 - - template - iterator emplace(Args&& ...args) - { - return tree_.emplace_multi(mystl::forward(args)...); - } - - template - iterator emplace_hint(iterator hint, Args&& ...args) - { - return tree_.emplace_multi_use_hint(hint, mystl::forward(args)...); - } - - iterator insert(const value_type& value) - { - return tree_.insert_multi(value); - } - iterator insert(value_type&& value) - { - return tree_.insert_multi(mystl::move(value)); - } - - iterator insert(iterator hint, const value_type& value) - { - return tree_.insert_multi(hint, value); - } - iterator insert(iterator hint, value_type&& value) - { - return tree_.insert_multi(hint, mystl::move(value)); - } - - template - void insert(InputIterator first, InputIterator last) - { - tree_.insert_multi(first, last); - } - - void erase(iterator position) { tree_.erase(position); } - size_type erase(const key_type& key) { return tree_.erase_multi(key); } - void erase(iterator first, iterator last) { tree_.erase(first, last); } - - void clear() { tree_.clear(); } - - // multimap 相关操作 - - iterator find(const key_type& key) { return tree_.find(key); } - const_iterator find(const key_type& key) const { return tree_.find(key); } - - size_type count(const key_type& key) const { return tree_.count_multi(key); } - - iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } - const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } - - iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } - const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } - - pair - equal_range(const key_type& key) - { return tree_.equal_range_multi(key); } - - pair - equal_range(const key_type& key) const - { return tree_.equal_range_multi(key); } - - void swap(multimap& rhs) noexcept - { tree_.swap(rhs.tree_); } - -public: - friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; } - friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; } -}; - -// 重载比较操作符 -template -bool operator==(const multimap& lhs, const multimap& rhs) -{ - return lhs == rhs; -} - -template -bool operator<(const multimap& lhs, const multimap& rhs) -{ - return lhs < rhs; -} - -template -bool operator!=(const multimap& lhs, const multimap& rhs) -{ - return !(lhs == rhs); -} - -template -bool operator>(const multimap& lhs, const multimap& rhs) -{ - return rhs < lhs; -} - -template -bool operator<=(const multimap& lhs, const multimap& rhs) -{ - return !(rhs < lhs); -} - -template -bool operator>=(const multimap& lhs, const multimap& rhs) -{ - return !(lhs < rhs); -} - -// 重载 mystl 的 swap -template -void swap(multimap& lhs, multimap& rhs) noexcept -{ - lhs.swap(rhs); -} - -} // namespace mystl -#endif // !MYTINYSTL_MAP_H_ - +#ifndef MYTINYSTL_MAP_H_ // +#define MYTINYSTL_MAP_H_ + // +// 这个头文件包含了两个模板类 map 和 multimap +// map : 映射，元素具有键值和实值，会根据键值大小自动排序，键值不允许重复 +// multimap : 映射，元素具有键值和实值，会根据键值大小自动排序，键值允许重复 + +// notes: +// +// 异常保证： // +// mystl::map / mystl::multimap 满足基本异常保证，对以下等函数做强异常安全保证： +// * emplace +// * emplace_hint // +// * insert + // +#include "rb_tree.h" // + // +namespace mystl +{ + +// 模板类 map，键值不允许重复 +// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less +template > +class map +{ // +public: + // map 的嵌套型别定义 + typedef Key key_type; // + typedef T mapped_type; + typedef mystl::pair value_type; + typedef Compare key_compare; // + + // 定义一个 functor，用来进行元素比较 // + class value_compare : public binary_function + { + friend class map; + private: + Compare comp; + value_compare(Compare c) : comp(c) {} + public: + bool operator()(const value_type& lhs, const value_type& rhs) const // + { + return comp(lhs.first, rhs.first); // 比较键值的大小 + } + }; // + +private: + // 以 mystl::rb_tree 作为底层机制 + typedef mystl::rb_tree base_type; // + base_type tree_; + +public: // + // 使用 rb_tree 的型别 // + typedef typename base_type::node_type node_type; + typedef typename base_type::pointer pointer; // + typedef typename base_type::const_pointer const_pointer; + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; // + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::size_type size_type; // + typedef typename base_type::difference_type difference_type; + typedef typename base_type::allocator_type allocator_type; + +public: + // 构造、复制、移动、赋值函数 + + map() = default; + // + template + map(InputIterator first, InputIterator last) // + :tree_() + { tree_.insert_unique(first, last); } // + + map(std::initializer_list ilist) // + :tree_() + { tree_.insert_unique(ilist.begin(), ilist.end()); } // + + map(const map& rhs) // + :tree_(rhs.tree_) + { + } + map(map&& rhs) noexcept // + :tree_(mystl::move(rhs.tree_)) // + { + } + + map& operator=(const map& rhs) + { + tree_ = rhs.tree_; + return *this; + } + map& operator=(map&& rhs) // + { // + tree_ = mystl::move(rhs.tree_); // + return *this; + } + + map& operator=(std::initializer_list ilist) // + { + tree_.clear(); // + tree_.insert_unique(ilist.begin(), ilist.end()); + return *this; // + } // + + // 相关接口 + // + key_compare key_comp() const { return tree_.key_comp(); } + value_compare value_comp() const { return value_compare(tree_.key_comp()); } // + allocator_type get_allocator() const { return tree_.get_allocator(); } + // + // 迭代器相关 + // + iterator begin() noexcept // + { return tree_.begin(); } // + const_iterator begin() const noexcept + { return tree_.begin(); } + iterator end() noexcept + { return tree_.end(); } // + const_iterator end() const noexcept + { return tree_.end(); } + // + reverse_iterator rbegin() noexcept // + { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const noexcept + { return const_reverse_iterator(end()); } + reverse_iterator rend() noexcept // + { return reverse_iterator(begin()); } + const_reverse_iterator rend() const noexcept + { return const_reverse_iterator(begin()); } + // + const_iterator cbegin() const noexcept + { return begin(); } + const_iterator cend() const noexcept // + { return end(); } // + const_reverse_iterator crbegin() const noexcept + { return rbegin(); } + const_reverse_iterator crend() const noexcept + { return rend(); } // + + // 容量相关 + bool empty() const noexcept { return tree_.empty(); } + size_type size() const noexcept { return tree_.size(); } + size_type max_size() const noexcept { return tree_.max_size(); } + + // 访问元素相关 + // + // 若键值不存在，at 会抛出一个异常 + mapped_type& at(const key_type& key) // + { + iterator it = lower_bound(key); + // it->first >= key + THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), // + "map no such element exists"); + return it->second; // + } + const mapped_type& at(const key_type& key) const // + { // + const_iterator it = lower_bound(key); + // it->first >= key + THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), + "map no such element exists"); + return it->second; + } + + mapped_type& operator[](const key_type& key) + { // + iterator it = lower_bound(key); + // it->first >= key // + if (it == end() || key_comp()(key, it->first)) + it = emplace_hint(it, key, T{}); + return it->second; + } + mapped_type& operator[](key_type&& key) + { // + iterator it = lower_bound(key); + // it->first >= key + if (it == end() || key_comp()(key, it->first)) + it = emplace_hint(it, mystl::move(key), T{}); // + return it->second; + } + + // 插入删除相关 + + template // + pair emplace(Args&& ...args) + { // + return tree_.emplace_unique(mystl::forward(args)...); // + } // + + template // + iterator emplace_hint(iterator hint, Args&& ...args) + { + return tree_.emplace_unique_use_hint(hint, mystl::forward(args)...); // + } + + pair insert(const value_type& value) + { + return tree_.insert_unique(value); // + } + pair insert(value_type&& value) + { + return tree_.insert_unique(mystl::move(value)); // + } + + iterator insert(iterator hint, const value_type& value) // + { // + return tree_.insert_unique(hint, value); + } // + iterator insert(iterator hint, value_type&& value) + { // + return tree_.insert_unique(hint, mystl::move(value)); + } + // + template // + void insert(InputIterator first, InputIterator last) + { + tree_.insert_unique(first, last); + } // + + void erase(iterator position) { tree_.erase(position); } + size_type erase(const key_type& key) { return tree_.erase_unique(key); } + void erase(iterator first, iterator last) { tree_.erase(first, last); } // + + void clear() { tree_.clear(); } + + // map 相关操作 // + + iterator find(const key_type& key) { return tree_.find(key); } // + const_iterator find(const key_type& key) const { return tree_.find(key); } + + size_type count(const key_type& key) const { return tree_.count_unique(key); } + + iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } // + const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } + + iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } + const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } + // + pair + equal_range(const key_type& key) + { return tree_.equal_range_unique(key); } // + + pair + equal_range(const key_type& key) const // + { return tree_.equal_range_unique(key); } + // + void swap(map& rhs) noexcept + { tree_.swap(rhs.tree_); } // + +public: // + friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; } + friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; } +}; + +// 重载比较操作符 +template // +bool operator==(const map& lhs, const map& rhs) +{ // + return lhs == rhs; +} + +template // +bool operator<(const map& lhs, const map& rhs) // +{ + return lhs < rhs; // +} // + +template // +bool operator!=(const map& lhs, const map& rhs) +{ + return !(lhs == rhs); // +} + // +template // +bool operator>(const map& lhs, const map& rhs) +{ // + return rhs < lhs; // +} // + +template +bool operator<=(const map& lhs, const map& rhs) +{ // + return !(rhs < lhs); // +} + +template // +bool operator>=(const map& lhs, const map& rhs) +{ + return !(lhs < rhs); +} // + +// 重载 mystl 的 swap +template +void swap(map& lhs, map& rhs) noexcept +{ // + lhs.swap(rhs); +} + // +/*****************************************************************************************/ + +// 模板类 multimap，键值允许重复 // +// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less // +template > // +class multimap // +{ +public: // + // multimap 的型别定义 + typedef Key key_type; + typedef T mapped_type; + typedef mystl::pair value_type; + typedef Compare key_compare; + + // 定义一个 functor，用来进行元素比较 + class value_compare : public binary_function + { + friend class multimap; + private: + Compare comp; + value_compare(Compare c) : comp(c) {} + public: + bool operator()(const value_type& lhs, const value_type& rhs) const + { // + return comp(lhs.first, rhs.first); + } + }; + +private: + // 用 mystl::rb_tree 作为底层机制 // + typedef mystl::rb_tree base_type; + base_type tree_; + +public: + // 使用 rb_tree 的型别 + typedef typename base_type::node_type node_type; // + typedef typename base_type::pointer pointer; + typedef typename base_type::const_pointer const_pointer; + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; // + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; // + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::size_type size_type; + typedef typename base_type::difference_type difference_type; + typedef typename base_type::allocator_type allocator_type; + // +public: + // 构造、复制、移动函数 + // + multimap() = default; + + template + multimap(InputIterator first, InputIterator last) + :tree_() + { tree_.insert_multi(first, last); } + multimap(std::initializer_list ilist) + :tree_() + { tree_.insert_multi(ilist.begin(), ilist.end()); } // + + multimap(const multimap& rhs) + :tree_(rhs.tree_) + { + } + multimap(multimap&& rhs) noexcept + :tree_(mystl::move(rhs.tree_)) + { + } // + // + multimap& operator=(const multimap& rhs) + { // + tree_ = rhs.tree_; + return *this; + } + multimap& operator=(multimap&& rhs) + { + tree_ = mystl::move(rhs.tree_); // + return *this; + } // + + multimap& operator=(std::initializer_list ilist) // + { + tree_.clear(); // + tree_.insert_multi(ilist.begin(), ilist.end()); // + return *this; + } // + + // 相关接口 + + key_compare key_comp() const { return tree_.key_comp(); } + value_compare value_comp() const { return value_compare(tree_.key_comp()); } + allocator_type get_allocator() const { return tree_.get_allocator(); } + // + // 迭代器相关 + // + iterator begin() noexcept + { return tree_.begin(); } + const_iterator begin() const noexcept // + { return tree_.begin(); } + iterator end() noexcept + { return tree_.end(); } // + const_iterator end() const noexcept + { return tree_.end(); } + + reverse_iterator rbegin() noexcept + { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const noexcept // + { return const_reverse_iterator(end()); } + reverse_iterator rend() noexcept + { return reverse_iterator(begin()); } + const_reverse_iterator rend() const noexcept // + { return const_reverse_iterator(begin()); } + + const_iterator cbegin() const noexcept + { return begin(); } // + const_iterator cend() const noexcept + { return end(); } // + const_reverse_iterator crbegin() const noexcept + { return rbegin(); } // + const_reverse_iterator crend() const noexcept + { return rend(); } + + // 容量相关 + bool empty() const noexcept { return tree_.empty(); } + size_type size() const noexcept { return tree_.size(); } // + size_type max_size() const noexcept { return tree_.max_size(); } + // + // 插入删除操作 + // + template + iterator emplace(Args&& ...args) // + { + return tree_.emplace_multi(mystl::forward(args)...); + } + // + template + iterator emplace_hint(iterator hint, Args&& ...args) // + { + return tree_.emplace_multi_use_hint(hint, mystl::forward(args)...); // + } + + iterator insert(const value_type& value) + { + return tree_.insert_multi(value); + } + iterator insert(value_type&& value) + { // + return tree_.insert_multi(mystl::move(value)); + } // + + iterator insert(iterator hint, const value_type& value) + { + return tree_.insert_multi(hint, value); + } + iterator insert(iterator hint, value_type&& value) + { + return tree_.insert_multi(hint, mystl::move(value)); // + } + + template + void insert(InputIterator first, InputIterator last) // + { + tree_.insert_multi(first, last); // + } + + void erase(iterator position) { tree_.erase(position); } + size_type erase(const key_type& key) { return tree_.erase_multi(key); } // + void erase(iterator first, iterator last) { tree_.erase(first, last); } + // + void clear() { tree_.clear(); } + + // multimap 相关操作 + + iterator find(const key_type& key) { return tree_.find(key); } + const_iterator find(const key_type& key) const { return tree_.find(key); } // + + size_type count(const key_type& key) const { return tree_.count_multi(key); } + + iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } // + const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } + + iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } // + const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } // + + pair + equal_range(const key_type& key) + { return tree_.equal_range_multi(key); } + // + pair + equal_range(const key_type& key) const + { return tree_.equal_range_multi(key); } + + void swap(multimap& rhs) noexcept + { tree_.swap(rhs.tree_); } + // +public: + friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; } + friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; } +}; + +// 重载比较操作符 +template +bool operator==(const multimap& lhs, const multimap& rhs) // +{ + return lhs == rhs; +} + +template +bool operator<(const multimap& lhs, const multimap& rhs) +{ + return lhs < rhs; // +} // + +template +bool operator!=(const multimap& lhs, const multimap& rhs) // +{ + return !(lhs == rhs); +} + // +template +bool operator>(const multimap& lhs, const multimap& rhs) +{ + return rhs < lhs; +} + // +template +bool operator<=(const multimap& lhs, const multimap& rhs) // +{ + return !(rhs < lhs); +} // + // +template +bool operator>=(const multimap& lhs, const multimap& rhs) +{ // + return !(lhs < rhs); // +} + // +// 重载 mystl 的 swap +template // +void swap(multimap& lhs, multimap& rhs) noexcept +{ + lhs.swap(rhs); +} // + +} // namespace mystl +#endif // !MYTINYSTL_MAP_H_ + // diff --git a/src/MyTinySTL-master/MyTinySTL/memory.h b/src/MyTinySTL-master/MyTinySTL/memory.h index c24e42c..1cf7caf 100644 --- a/src/MyTinySTL-master/MyTinySTL/memory.h +++ b/src/MyTinySTL-master/MyTinySTL/memory.h @@ -1,208 +1,208 @@ -#ifndef MYTINYSTL_MEMORY_H_ -#define MYTINYSTL_MEMORY_H_ - -// 这个头文件负责更高级的动态内存管理 -// 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr - -#include -#include -#include - -#include "algobase.h" -#include "allocator.h" -#include "construct.h" -#include "uninitialized.h" - -namespace mystl -{ - -// 获取对象地址 -template -constexpr Tp* address_of(Tp& value) noexcept -{ - return &value; -} - -// 获取 / 释放 临时缓冲区 - -template -pair get_buffer_helper(ptrdiff_t len, T*) -{ - if (len > static_cast(INT_MAX / sizeof(T))) - len = INT_MAX / sizeof(T); - while (len > 0) - { - T* tmp = static_cast(malloc(static_cast(len) * sizeof(T))); - if (tmp) - return pair(tmp, len); - len /= 2; // 申请失败时减少 len 的大小 - } - return pair(nullptr, 0); -} - -template -pair get_temporary_buffer(ptrdiff_t len) -{ - return get_buffer_helper(len, static_cast(0)); -} - -template -pair get_temporary_buffer(ptrdiff_t len, T*) -{ - return get_buffer_helper(len, static_cast(0)); -} - -template -void release_temporary_buffer(T* ptr) -{ - free(ptr); -} - -// -------------------------------------------------------------------------------------- -// 类模板 : temporary_buffer -// 进行临时缓冲区的申请与释放 -template -class temporary_buffer -{ -private: - ptrdiff_t original_len; // 缓冲区申请的大小 - ptrdiff_t len; // 缓冲区实际的大小 - T* buffer; // 指向缓冲区的指针 - -public: - // 构造、析构函数 - temporary_buffer(ForwardIterator first, ForwardIterator last); - - ~temporary_buffer() - { - mystl::destroy(buffer, buffer + len); - free(buffer); - } - -public: - - ptrdiff_t size() const noexcept { return len; } - ptrdiff_t requested_size() const noexcept { return original_len; } - T* begin() noexcept { return buffer; } - T* end() noexcept { return buffer + len; } - -private: - void allocate_buffer(); - void initialize_buffer(const T&, std::true_type) {} - void initialize_buffer(const T& value, std::false_type) - { mystl::uninitialized_fill_n(buffer, len, value); } - -private: - temporary_buffer(const temporary_buffer&); - void operator=(const temporary_buffer&); -}; - -// 构造函数 -template -temporary_buffer:: -temporary_buffer(ForwardIterator first, ForwardIterator last) -{ - try - { - len = mystl::distance(first, last); - allocate_buffer(); - if (len > 0) - { - initialize_buffer(*first, std::is_trivially_default_constructible()); - } - } - catch (...) - { - free(buffer); - buffer = nullptr; - len = 0; - } -} - -// allocate_buffer 函数 -template -void temporary_buffer::allocate_buffer() -{ - original_len = len; - if (len > static_cast(INT_MAX / sizeof(T))) - len = INT_MAX / sizeof(T); - while (len > 0) - { - buffer = static_cast(malloc(len * sizeof(T))); - if (buffer) - break; - len /= 2; // 申请失败时减少申请空间大小 - } -} - -// -------------------------------------------------------------------------------------- -// 模板类: auto_ptr -// 一个具有严格对象所有权的小型智能指针 -template -class auto_ptr -{ -public: - typedef T elem_type; - -private: - T* m_ptr; // 实际指针 - -public: - // 构造、复制、析构函数 - explicit auto_ptr(T* p = nullptr) :m_ptr(p) {} - auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {} - template - auto_ptr(auto_ptr& rhs) : m_ptr(rhs.release()) {} - - auto_ptr& operator=(auto_ptr& rhs) - { - if (this != &rhs) - { - delete m_ptr; - m_ptr = rhs.release(); - } - return *this; - } - template - auto_ptr& operator=(auto_ptr& rhs) - { - if (this->get() != rhs.get()) - { - delete m_ptr; - m_ptr = rhs.release(); - } - return *this; - } - - ~auto_ptr() { delete m_ptr; } - -public: - // 重载 operator* 和 operator-> - T& operator*() const { return *m_ptr; } - T* operator->() const { return m_ptr; } - - // 获得指针 - T* get() const { return m_ptr; } - - // 释放指针 - T* release() - { - T* tmp = m_ptr; - m_ptr = nullptr; - return tmp; - } - - // 重置指针 - void reset(T* p = nullptr) - { - if (m_ptr != p) - { - delete m_ptr; - m_ptr = p; - } - } -}; - -} // namespace mystl -#endif // !MYTINYSTL_MEMORY_H_ - +#ifndef MYTINYSTL_MEMORY_H_ // +#define MYTINYSTL_MEMORY_H_ + +// 这个头文件负责更高级的动态内存管理 // +// 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr + +#include +#include +#include + +#include "algobase.h" +#include "allocator.h" +#include "construct.h" // +#include "uninitialized.h" + // +namespace mystl +{ + +// 获取对象地址 +template +constexpr Tp* address_of(Tp& value) noexcept // +{ + return &value; +} + // +// 获取 / 释放 临时缓冲区 // + // +template +pair get_buffer_helper(ptrdiff_t len, T*) +{ + if (len > static_cast(INT_MAX / sizeof(T))) // + len = INT_MAX / sizeof(T); + while (len > 0) + { + T* tmp = static_cast(malloc(static_cast(len) * sizeof(T))); + if (tmp) + return pair(tmp, len); // + len /= 2; // 申请失败时减少 len 的大小 + } + return pair(nullptr, 0); // +} // + +template +pair get_temporary_buffer(ptrdiff_t len) +{ + return get_buffer_helper(len, static_cast(0)); +} + +template // +pair get_temporary_buffer(ptrdiff_t len, T*) +{ // + return get_buffer_helper(len, static_cast(0)); +} + +template // +void release_temporary_buffer(T* ptr) +{ + free(ptr); // +} + +// -------------------------------------------------------------------------------------- // +// 类模板 : temporary_buffer +// 进行临时缓冲区的申请与释放 +template // +class temporary_buffer // +{ +private: + ptrdiff_t original_len; // 缓冲区申请的大小 + ptrdiff_t len; // 缓冲区实际的大小 + T* buffer; // 指向缓冲区的指针 + +public: + // 构造、析构函数 // + temporary_buffer(ForwardIterator first, ForwardIterator last); + // + ~temporary_buffer() // + { // + mystl::destroy(buffer, buffer + len); + free(buffer); + } + // +public: + + ptrdiff_t size() const noexcept { return len; } + ptrdiff_t requested_size() const noexcept { return original_len; } // + T* begin() noexcept { return buffer; } + T* end() noexcept { return buffer + len; } // + +private: // + void allocate_buffer(); + void initialize_buffer(const T&, std::true_type) {} // + void initialize_buffer(const T& value, std::false_type) + { mystl::uninitialized_fill_n(buffer, len, value); } // + +private: + temporary_buffer(const temporary_buffer&); // + void operator=(const temporary_buffer&); // +}; + // +// 构造函数 +template +temporary_buffer:: +temporary_buffer(ForwardIterator first, ForwardIterator last) +{ + try // + { + len = mystl::distance(first, last); + allocate_buffer(); + if (len > 0) + { + initialize_buffer(*first, std::is_trivially_default_constructible()); // + } + } + catch (...) + { + free(buffer); + buffer = nullptr; // + len = 0; // + } +} + // +// allocate_buffer 函数 +template +void temporary_buffer::allocate_buffer() +{ // + original_len = len; + if (len > static_cast(INT_MAX / sizeof(T))) // + len = INT_MAX / sizeof(T); + while (len > 0) // + { + buffer = static_cast(malloc(len * sizeof(T))); // + if (buffer) + break; // + len /= 2; // 申请失败时减少申请空间大小 + } // +} // + // +// -------------------------------------------------------------------------------------- +// 模板类: auto_ptr // +// 一个具有严格对象所有权的小型智能指针 +template // +class auto_ptr // +{ +public: + typedef T elem_type; // + // +private: + T* m_ptr; // 实际指针 + // +public: + // 构造、复制、析构函数 // + explicit auto_ptr(T* p = nullptr) :m_ptr(p) {} + auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {} // + template + auto_ptr(auto_ptr& rhs) : m_ptr(rhs.release()) {} + // + auto_ptr& operator=(auto_ptr& rhs) // + { + if (this != &rhs) + { + delete m_ptr; // + m_ptr = rhs.release(); + } + return *this; + } + template // + auto_ptr& operator=(auto_ptr& rhs) // + { + if (this->get() != rhs.get()) + { + delete m_ptr; + m_ptr = rhs.release(); // + } // + return *this; + } // + // + ~auto_ptr() { delete m_ptr; } + // +public: + // 重载 operator* 和 operator-> + T& operator*() const { return *m_ptr; } // + T* operator->() const { return m_ptr; } + + // 获得指针 // + T* get() const { return m_ptr; } + + // 释放指针 // + T* release() + { + T* tmp = m_ptr; + m_ptr = nullptr; + return tmp; + } // + + // 重置指针 + void reset(T* p = nullptr) + { + if (m_ptr != p) + { // + delete m_ptr; + m_ptr = p; // + } + } +}; + // +} // namespace mystl +#endif // !MYTINYSTL_MEMORY_H_ // + diff --git a/src/MyTinySTL-master/MyTinySTL/numeric.h b/src/MyTinySTL-master/MyTinySTL/numeric.h index 8d6cbb6..0afad08 100644 --- a/src/MyTinySTL-master/MyTinySTL/numeric.h +++ b/src/MyTinySTL-master/MyTinySTL/numeric.h @@ -1,155 +1,155 @@ -#ifndef MYTINYSTL_NUMERIC_H_ -#define MYTINYSTL_NUMERIC_H_ - -// 这个头文件包含了 mystl 的数值算法 - -#include "iterator.h" - -namespace mystl -{ - -/*****************************************************************************************/ -// accumulate -// 版本1：以初值 init 对每个元素进行累加 -// 版本2：以初值 init 对每个元素进行二元操作 -/*****************************************************************************************/ -// 版本1 -template -T accumulate(InputIter first, InputIter last, T init) -{ - for (; first != last; ++first) - { - init += *first; - } - return init; -} - -// 版本2 -template -T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op) -{ - for (; first != last; ++first) - { - init = binary_op(init, *first); - } - return init; -} - -/*****************************************************************************************/ -// adjacent_difference -// 版本1：计算相邻元素的差值，结果保存到以 result 为起始的区间上 -// 版本2：自定义相邻元素的二元操作 -/*****************************************************************************************/ -// 版本1 -template -OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result) -{ - if (first == last) return result; - *result = *first; // 记录第一个元素 - auto value = *first; - while (++first != last) - { - auto tmp = *first; - *++result = tmp - value; - value = tmp; - } - return ++result; -} - -// 版本2 -template -OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result, - BinaryOp binary_op) -{ - if (first == last) return result; - *result = *first; // 记录第一个元素 - auto value = *first; - while (++first != last) - { - auto tmp = *first; - *++result = binary_op(tmp, value); - value = tmp; - } - return ++result; -} - -/*****************************************************************************************/ -// inner_product -// 版本1：以 init 为初值，计算两个区间的内积 -// 版本2：自定义 operator+ 和 operator* -/*****************************************************************************************/ -// 版本1 -template -T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) -{ - for (; first1 != last1; ++first1, ++first2) - { - init = init + (*first1 * *first2); - } - return init; -} - -// 版本2 -template -T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init, - BinaryOp1 binary_op1, BinaryOp2 binary_op2) -{ - for (; first1 != last1; ++first1, ++first2) - { - init = binary_op1(init, binary_op2(*first1, *first2)); - } - return init; -} - -/*****************************************************************************************/ -// iota -// 填充[first, last)，以 value 为初值开始递增 -/*****************************************************************************************/ -template -void iota(ForwardIter first, ForwardIter last, T value) -{ - while (first != last) - { - *first++ = value; - ++value; - } -} - -/*****************************************************************************************/ -// partial_sum -// 版本1：计算局部累计求和，结果保存到以 result 为起始的区间上 -// 版本2：进行局部进行自定义二元操作 -/*****************************************************************************************/ -template -OutputIter partial_sum(InputIter first, InputIter last, OutputIter result) -{ - if (first == last) return result; - *result = *first; // 记录第一个元素 - auto value = *first; - while (++first != last) - { - value = value + *first; - *++result = value; - } - return ++result; -} - -// 版本2 -template -OutputIter partial_sum(InputIter first, InputIter last, OutputIter result, - BinaryOp binary_op) -{ - if (first == last) return result; - *result = *first; //记录第一个元素 - auto value = *first; - while (++first != last) - { - value = binary_op(value, *first); - *++result = value; - } - return ++result; -} - -} // namespace mystl -#endif // !MYTINYSTL_NUMERIC_H_ - +#ifndef MYTINYSTL_NUMERIC_H_ // +#define MYTINYSTL_NUMERIC_H_ + +// 这个头文件包含了 mystl 的数值算法 + +#include "iterator.h" + +namespace mystl +{ // + +/*****************************************************************************************/ // +// accumulate +// 版本1：以初值 init 对每个元素进行累加 // +// 版本2：以初值 init 对每个元素进行二元操作 +/*****************************************************************************************/ +// 版本1 // +template +T accumulate(InputIter first, InputIter last, T init) +{ // + for (; first != last; ++first) + { // + init += *first; + } + return init; +} // + +// 版本2 +template +T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op) +{ + for (; first != last; ++first) // + { + init = binary_op(init, *first); + } // + return init; // +} // + // +/*****************************************************************************************/ +// adjacent_difference +// 版本1：计算相邻元素的差值，结果保存到以 result 为起始的区间上 // +// 版本2：自定义相邻元素的二元操作 // +/*****************************************************************************************/ +// 版本1 // +template +OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result) +{ + if (first == last) return result; + *result = *first; // 记录第一个元素 + auto value = *first; // + while (++first != last) + { // + auto tmp = *first; + *++result = tmp - value; // + value = tmp; + } + return ++result; +} // + +// 版本2 +template +OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result, // + BinaryOp binary_op) +{ + if (first == last) return result; // + *result = *first; // 记录第一个元素 // + auto value = *first; + while (++first != last) + { + auto tmp = *first; + *++result = binary_op(tmp, value); + value = tmp; + } + return ++result; // +} + +/*****************************************************************************************/ +// inner_product +// 版本1：以 init 为初值，计算两个区间的内积 +// 版本2：自定义 operator+ 和 operator* +/*****************************************************************************************/ +// 版本1 // +template +T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) // +{ + for (; first1 != last1; ++first1, ++first2) // + { + init = init + (*first1 * *first2); + } // + return init; +} + +// 版本2 +template +T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init, // + BinaryOp1 binary_op1, BinaryOp2 binary_op2) +{ + for (; first1 != last1; ++first1, ++first2) // + { + init = binary_op1(init, binary_op2(*first1, *first2)); // + } + return init; +} + // +/*****************************************************************************************/ +// iota // +// 填充[first, last)，以 value 为初值开始递增 // +/*****************************************************************************************/ +template +void iota(ForwardIter first, ForwardIter last, T value) // +{ + while (first != last) // + { + *first++ = value; // + ++value; + } // +} + // +/*****************************************************************************************/ +// partial_sum +// 版本1：计算局部累计求和，结果保存到以 result 为起始的区间上 +// 版本2：进行局部进行自定义二元操作 // +/*****************************************************************************************/ +template +OutputIter partial_sum(InputIter first, InputIter last, OutputIter result) // +{ + if (first == last) return result; + *result = *first; // 记录第一个元素 // + auto value = *first; + while (++first != last) // + { + value = value + *first; // + *++result = value; + } // + return ++result; +} // + // +// 版本2 // +template +OutputIter partial_sum(InputIter first, InputIter last, OutputIter result, // + BinaryOp binary_op) +{ // + if (first == last) return result; + *result = *first; //记录第一个元素 + auto value = *first; + while (++first != last) // + { + value = binary_op(value, *first); // + *++result = value; + } + return ++result; +} + +} // namespace mystl +#endif // !MYTINYSTL_NUMERIC_H_ // + diff --git a/src/MyTinySTL-master/MyTinySTL/queue.h b/src/MyTinySTL-master/MyTinySTL/queue.h index 6a4a939..2591715 100644 --- a/src/MyTinySTL-master/MyTinySTL/queue.h +++ b/src/MyTinySTL-master/MyTinySTL/queue.h @@ -1,364 +1,364 @@ -#ifndef MYTINYSTL_QUEUE_H_ -#define MYTINYSTL_QUEUE_H_ - -// 这个头文件包含了两个模板类 queue 和 priority_queue -// queue : 队列 -// priority_queue : 优先队列 - -#include "deque.h" -#include "vector.h" -#include "functional.h" -#include "heap_algo.h" - -namespace mystl -{ - -// 模板类 queue -// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 -template > -class queue -{ -public: - typedef Container container_type; - // 使用底层容器的型别 - typedef typename Container::value_type value_type; - typedef typename Container::size_type size_type; - typedef typename Container::reference reference; - typedef typename Container::const_reference const_reference; - - static_assert(std::is_same::value, - "the value_type of Container should be same with T"); -private: - container_type c_; // 用底层容器表现 queue - -public: - // 构造、复制、移动函数 - - queue() = default; - - explicit queue(size_type n) - :c_(n) - { - } - queue(size_type n, const value_type& value) - :c_(n, value) - { - } - - template - queue(IIter first, IIter last) - :c_(first, last) - { - } - - queue(std::initializer_list ilist) - :c_(ilist.begin(), ilist.end()) - { - } - - queue(const Container& c) - :c_(c) - { - } - queue(Container&& c) noexcept(std::is_nothrow_move_constructible::value) - :c_(mystl::move(c)) - { - } - - queue(const queue& rhs) - :c_(rhs.c_) - { - } - queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible::value) - :c_(mystl::move(rhs.c_)) - { - } - - queue& operator=(const queue& rhs) - { - c_ = rhs.c_; - return *this; - } - queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable::value) - { - c_ = mystl::move(rhs.c_); - return *this; - } - - queue& operator=(std::initializer_list ilist) - { - c_ = ilist; - return *this; - } - - ~queue() = default; - - // 访问元素相关操作 - reference front() { return c_.front(); } - const_reference front() const { return c_.front(); } - reference back() { return c_.back(); } - const_reference back() const { return c_.back(); } - - // 容量相关操作 - bool empty() const noexcept { return c_.empty(); } - size_type size() const noexcept { return c_.size(); } - - // 修改容器相关操作 - template - void emplace(Args&& ...args) - { c_.emplace_back(mystl::forward(args)...); } - - void push(const value_type& value) - { c_.push_back(value); } - void push(value_type&& value) - { c_.emplace_back(mystl::move(value)); } - - void pop() - { c_.pop_front(); } - - void clear() - { - while (!empty()) - pop(); - } - - void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) - { mystl::swap(c_, rhs.c_); } - -public: - friend bool operator==(const queue& lhs, const queue& rhs) { return lhs.c_ == rhs.c_; } - friend bool operator< (const queue& lhs, const queue& rhs) { return lhs.c_ < rhs.c_; } -}; - -// 重载比较操作符 -template -bool operator==(const queue& lhs, const queue& rhs) -{ - return lhs == rhs; -} - -template -bool operator!=(const queue& lhs, const queue& rhs) -{ - return !(lhs == rhs); -} - -template -bool operator<(const queue& lhs, const queue& rhs) -{ - return lhs < rhs; -} - -template -bool operator>(const queue& lhs, const queue& rhs) -{ - return rhs < lhs; -} - -template -bool operator<=(const queue& lhs, const queue& rhs) -{ - return !(rhs < lhs); -} - -template -bool operator>=(const queue& lhs, const queue& rhs) -{ - return !(lhs < rhs); -} - -// 重载 mystl 的 swap -template -void swap(queue& lhs, queue& rhs) noexcept(noexcept(lhs.swap(rhs))) -{ - lhs.swap(rhs); -} - -/*****************************************************************************************/ - -// 模板类 priority_queue -// 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器 -// 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式 -template , - class Compare = mystl::less> -class priority_queue -{ -public: - typedef Container container_type; - typedef Compare value_compare; - // 使用底层容器的型别 - typedef typename Container::value_type value_type; - typedef typename Container::size_type size_type; - typedef typename Container::reference reference; - typedef typename Container::const_reference const_reference; - - static_assert(std::is_same::value, - "the value_type of Container should be same with T"); - -private: - container_type c_; // 用底层容器来表现 priority_queue - value_compare comp_; // 权值比较的标准 - -public: - // 构造、复制、移动函数 - priority_queue() = default; - - priority_queue(const Compare& c) - :c_(), comp_(c) - { - } - - explicit priority_queue(size_type n) - :c_(n) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - priority_queue(size_type n, const value_type& value) - :c_(n, value) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - - template - priority_queue(IIter first, IIter last) - :c_(first, last) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - - priority_queue(std::initializer_list ilist) - :c_(ilist) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - - priority_queue(const Container& s) - :c_(s) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - priority_queue(Container&& s) - :c_(mystl::move(s)) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - - priority_queue(const priority_queue& rhs) - :c_(rhs.c_), comp_(rhs.comp_) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - priority_queue(priority_queue&& rhs) - :c_(mystl::move(rhs.c_)), comp_(rhs.comp_) - { - mystl::make_heap(c_.begin(), c_.end(), comp_); - } - - priority_queue& operator=(const priority_queue& rhs) - { - c_ = rhs.c_; - comp_ = rhs.comp_; - mystl::make_heap(c_.begin(), c_.end(), comp_); - return *this; - } - priority_queue& operator=(priority_queue&& rhs) - { - c_ = mystl::move(rhs.c_); - comp_ = rhs.comp_; - mystl::make_heap(c_.begin(), c_.end(), comp_); - return *this; - } - priority_queue& operator=(std::initializer_list ilist) - { - c_ = ilist; - comp_ = value_compare(); - mystl::make_heap(c_.begin(), c_.end(), comp_); - return *this; - } - - ~priority_queue() = default; - -public: - - // 访问元素相关操作 - const_reference top() const { return c_.front(); } - - // 容量相关操作 - bool empty() const noexcept { return c_.empty(); } - size_type size() const noexcept { return c_.size(); } - - // 修改容器相关操作 - template - void emplace(Args&& ...args) - { - c_.emplace_back(mystl::forward(args)...); - mystl::push_heap(c_.begin(), c_.end(), comp_); - } - - void push(const value_type& value) - { - c_.push_back(value); - mystl::push_heap(c_.begin(), c_.end(), comp_); - } - void push(value_type&& value) - { - c_.push_back(mystl::move(value)); - mystl::push_heap(c_.begin(), c_.end(), comp_); - } - - void pop() - { - mystl::pop_heap(c_.begin(), c_.end(), comp_); - c_.pop_back(); - } - - void clear() - { - while (!empty()) - pop(); - } - - void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) && - noexcept(mystl::swap(comp_, rhs.comp_))) - { - mystl::swap(c_, rhs.c_); - mystl::swap(comp_, rhs.comp_); - } - -public: - friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) - { - return lhs.c_ == rhs.c_; - } - friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) - { - return lhs.c_ != rhs.c_; - } -}; - -// 重载比较操作符 -template -bool operator==(priority_queue& lhs, - priority_queue& rhs) -{ - return lhs == rhs; -} - -template -bool operator!=(priority_queue& lhs, - priority_queue& rhs) -{ - return lhs != rhs; -} - -// 重载 mystl 的 swap -template -void swap(priority_queue& lhs, - priority_queue& rhs) noexcept(noexcept(lhs.swap(rhs))) -{ - lhs.swap(rhs); -} - -} // namespace mystl -#endif // !MYTINYSTL_QUEUE_H_ - +#ifndef MYTINYSTL_QUEUE_H_ // +#define MYTINYSTL_QUEUE_H_ + +// 这个头文件包含了两个模板类 queue 和 priority_queue // +// queue : 队列 +// priority_queue : 优先队列 + +#include "deque.h" +#include "vector.h" // +#include "functional.h" +#include "heap_algo.h" + +namespace mystl // +{ + +// 模板类 queue // +// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 // +template > +class queue // +{ +public: + typedef Container container_type; + // 使用底层容器的型别 + typedef typename Container::value_type value_type; + typedef typename Container::size_type size_type; // + typedef typename Container::reference reference; + typedef typename Container::const_reference const_reference; // + // + static_assert(std::is_same::value, + "the value_type of Container should be same with T"); +private: // + container_type c_; // 用底层容器表现 queue + +public: + // 构造、复制、移动函数 + + queue() = default; // + + explicit queue(size_type n) // + :c_(n) // + { // + } + queue(size_type n, const value_type& value) // + :c_(n, value) + { // + } + + template + queue(IIter first, IIter last) // + :c_(first, last) + { + } + + queue(std::initializer_list ilist) + :c_(ilist.begin(), ilist.end()) + { // + } // + + queue(const Container& c) + :c_(c) + { // + } + queue(Container&& c) noexcept(std::is_nothrow_move_constructible::value) // + :c_(mystl::move(c)) + { + } + // + queue(const queue& rhs) + :c_(rhs.c_) + { + } // + queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible::value) + :c_(mystl::move(rhs.c_)) // + { + } + // + queue& operator=(const queue& rhs) // + { + c_ = rhs.c_; // + return *this; + } // + queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable::value) // + { + c_ = mystl::move(rhs.c_); + return *this; // + } + // + queue& operator=(std::initializer_list ilist) + { // + c_ = ilist; + return *this; // + } + // + ~queue() = default; + + // 访问元素相关操作 + reference front() { return c_.front(); } // + const_reference front() const { return c_.front(); } + reference back() { return c_.back(); } + const_reference back() const { return c_.back(); } + // + // 容量相关操作 + bool empty() const noexcept { return c_.empty(); } // + size_type size() const noexcept { return c_.size(); } + + // 修改容器相关操作 // + template + void emplace(Args&& ...args) + { c_.emplace_back(mystl::forward(args)...); } // + + void push(const value_type& value) + { c_.push_back(value); } // + void push(value_type&& value) + { c_.emplace_back(mystl::move(value)); } + // + void pop() // + { c_.pop_front(); } + + void clear() + { + while (!empty()) // + pop(); + } + + void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) // + { mystl::swap(c_, rhs.c_); } + // +public: + friend bool operator==(const queue& lhs, const queue& rhs) { return lhs.c_ == rhs.c_; } + friend bool operator< (const queue& lhs, const queue& rhs) { return lhs.c_ < rhs.c_; } +}; + +// 重载比较操作符 // +template +bool operator==(const queue& lhs, const queue& rhs) +{ // + return lhs == rhs; +} + +template +bool operator!=(const queue& lhs, const queue& rhs) // +{ // + return !(lhs == rhs); // +} + +template +bool operator<(const queue& lhs, const queue& rhs) +{ + return lhs < rhs; // +} + // +template +bool operator>(const queue& lhs, const queue& rhs) +{ + return rhs < lhs; +} + // +template +bool operator<=(const queue& lhs, const queue& rhs) +{ // + return !(rhs < lhs); +} + // +template +bool operator>=(const queue& lhs, const queue& rhs) // +{ + return !(lhs < rhs); // +} + // +// 重载 mystl 的 swap +template +void swap(queue& lhs, queue& rhs) noexcept(noexcept(lhs.swap(rhs))) +{ + lhs.swap(rhs); +} // + +/*****************************************************************************************/ + +// 模板类 priority_queue +// 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器 +// 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式 // +template , + class Compare = mystl::less> +class priority_queue +{ // +public: // + typedef Container container_type; + typedef Compare value_compare; + // 使用底层容器的型别 + typedef typename Container::value_type value_type; + typedef typename Container::size_type size_type; // + typedef typename Container::reference reference; + typedef typename Container::const_reference const_reference; // + + static_assert(std::is_same::value, + "the value_type of Container should be same with T"); // + // +private: + container_type c_; // 用底层容器来表现 priority_queue // + value_compare comp_; // 权值比较的标准 + // +public: + // 构造、复制、移动函数 + priority_queue() = default; + // + priority_queue(const Compare& c) // + :c_(), comp_(c) + { // + } + + explicit priority_queue(size_type n) // + :c_(n) + { + mystl::make_heap(c_.begin(), c_.end(), comp_); + } + priority_queue(size_type n, const value_type& value) + :c_(n, value) // + { + mystl::make_heap(c_.begin(), c_.end(), comp_); + } // + // + template + priority_queue(IIter first, IIter last) + :c_(first, last) + { // + mystl::make_heap(c_.begin(), c_.end(), comp_); // + } // + + priority_queue(std::initializer_list ilist) // + :c_(ilist) + { + mystl::make_heap(c_.begin(), c_.end(), comp_); + } // + + priority_queue(const Container& s) + :c_(s) + { // + mystl::make_heap(c_.begin(), c_.end(), comp_); + } + priority_queue(Container&& s) + :c_(mystl::move(s)) // + { + mystl::make_heap(c_.begin(), c_.end(), comp_); // + } // + + priority_queue(const priority_queue& rhs) + :c_(rhs.c_), comp_(rhs.comp_) + { + mystl::make_heap(c_.begin(), c_.end(), comp_); + } + priority_queue(priority_queue&& rhs) + :c_(mystl::move(rhs.c_)), comp_(rhs.comp_) + { // + mystl::make_heap(c_.begin(), c_.end(), comp_); + } + // + priority_queue& operator=(const priority_queue& rhs) + { + c_ = rhs.c_; + comp_ = rhs.comp_; + mystl::make_heap(c_.begin(), c_.end(), comp_); // + return *this; + } + priority_queue& operator=(priority_queue&& rhs) + { + c_ = mystl::move(rhs.c_); // + comp_ = rhs.comp_; + mystl::make_heap(c_.begin(), c_.end(), comp_); + return *this; // + } + priority_queue& operator=(std::initializer_list ilist) // + { + c_ = ilist; // + comp_ = value_compare(); + mystl::make_heap(c_.begin(), c_.end(), comp_); + return *this; + } + + ~priority_queue() = default; // + +public: + + // 访问元素相关操作 + const_reference top() const { return c_.front(); } + // + // 容量相关操作 + bool empty() const noexcept { return c_.empty(); } + size_type size() const noexcept { return c_.size(); } + // + // 修改容器相关操作 + template // + void emplace(Args&& ...args) // + { // + c_.emplace_back(mystl::forward(args)...); + mystl::push_heap(c_.begin(), c_.end(), comp_); + } + + void push(const value_type& value) + { + c_.push_back(value); + mystl::push_heap(c_.begin(), c_.end(), comp_); // + } + void push(value_type&& value) // + { + c_.push_back(mystl::move(value)); + mystl::push_heap(c_.begin(), c_.end(), comp_); + } + + void pop() + { + mystl::pop_heap(c_.begin(), c_.end(), comp_); + c_.pop_back(); + } // + + void clear() + { // + while (!empty()) // + pop(); + } // + + void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) && + noexcept(mystl::swap(comp_, rhs.comp_))) + { + mystl::swap(c_, rhs.c_); + mystl::swap(comp_, rhs.comp_); // + } // + +public: + friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) // + { + return lhs.c_ == rhs.c_; + } + friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) // + { + return lhs.c_ != rhs.c_; + } +}; + +// 重载比较操作符 // +template +bool operator==(priority_queue& lhs, // + priority_queue& rhs) +{ // + return lhs == rhs; +} // + // +template +bool operator!=(priority_queue& lhs, + priority_queue& rhs) // +{ + return lhs != rhs; +} + // +// 重载 mystl 的 swap +template +void swap(priority_queue& lhs, + priority_queue& rhs) noexcept(noexcept(lhs.swap(rhs))) +{ + lhs.swap(rhs); +} + // +} // namespace mystl +#endif // !MYTINYSTL_QUEUE_H_ + diff --git a/src/MyTinySTL-master/MyTinySTL/rb_tree.h b/src/MyTinySTL-master/MyTinySTL/rb_tree.h index 908e778..1b55e6a 100644 --- a/src/MyTinySTL-master/MyTinySTL/rb_tree.h +++ b/src/MyTinySTL-master/MyTinySTL/rb_tree.h @@ -1,1738 +1,1738 @@ -#ifndef MYTINYSTL_RB_TREE_H_ -#define MYTINYSTL_RB_TREE_H_ - -// 这个头文件包含一个模板类 rb_tree -// rb_tree : 红黑树 - -#include - -#include - -#include "functional.h" -#include "iterator.h" -#include "memory.h" -#include "type_traits.h" -#include "exceptdef.h" - -namespace mystl -{ - -// rb tree 节点颜色的类型 - -typedef bool rb_tree_color_type; - -static constexpr rb_tree_color_type rb_tree_red = false; -static constexpr rb_tree_color_type rb_tree_black = true; - -// forward declaration - -template struct rb_tree_node_base; -template struct rb_tree_node; - -template struct rb_tree_iterator; -template struct rb_tree_const_iterator; - -// rb tree value traits - -template -struct rb_tree_value_traits_imp -{ - typedef T key_type; - typedef T mapped_type; - typedef T value_type; - - template - static const key_type& get_key(const Ty& value) - { - return value; - } - - template - static const value_type& get_value(const Ty& value) - { - return value; - } -}; - -template -struct rb_tree_value_traits_imp -{ - typedef typename std::remove_cv::type key_type; - typedef typename T::second_type mapped_type; - typedef T value_type; - - template - static const key_type& get_key(const Ty& value) - { - return value.first; - } - - template - static const value_type& get_value(const Ty& value) - { - return value; - } -}; - -template -struct rb_tree_value_traits -{ - static constexpr bool is_map = mystl::is_pair::value; - - typedef rb_tree_value_traits_imp value_traits_type; - - typedef typename value_traits_type::key_type key_type; - typedef typename value_traits_type::mapped_type mapped_type; - typedef typename value_traits_type::value_type value_type; - - template - static const key_type& get_key(const Ty& value) - { - return value_traits_type::get_key(value); - } - - template - static const value_type& get_value(const Ty& value) - { - return value_traits_type::get_value(value); - } -}; - -// rb tree node traits - -template -struct rb_tree_node_traits -{ - typedef rb_tree_color_type color_type; - - typedef rb_tree_value_traits value_traits; - typedef typename value_traits::key_type key_type; - typedef typename value_traits::mapped_type mapped_type; - typedef typename value_traits::value_type value_type; - - typedef rb_tree_node_base* base_ptr; - typedef rb_tree_node* node_ptr; -}; - -// rb tree 的节点设计 - -template -struct rb_tree_node_base -{ - typedef rb_tree_color_type color_type; - typedef rb_tree_node_base* base_ptr; - typedef rb_tree_node* node_ptr; - - base_ptr parent; // 父节点 - base_ptr left; // 左子节点 - base_ptr right; // 右子节点 - color_type color; // 节点颜色 - - base_ptr get_base_ptr() - { - return &*this; - } - - node_ptr get_node_ptr() - { - return reinterpret_cast(&*this); - } - - node_ptr& get_node_ref() - { - return reinterpret_cast(*this); - } -}; - -template -struct rb_tree_node :public rb_tree_node_base -{ - typedef rb_tree_node_base* base_ptr; - typedef rb_tree_node* node_ptr; - - T value; // 节点值 - - base_ptr get_base_ptr() - { - return static_cast(&*this); - } - - node_ptr get_node_ptr() - { - return &*this; - } -}; - -// rb tree traits - -template -struct rb_tree_traits -{ - typedef rb_tree_value_traits value_traits; - - typedef typename value_traits::key_type key_type; - typedef typename value_traits::mapped_type mapped_type; - typedef typename value_traits::value_type value_type; - - typedef value_type* pointer; - typedef value_type& reference; - typedef const value_type* const_pointer; - typedef const value_type& const_reference; - - typedef rb_tree_node_base base_type; - typedef rb_tree_node node_type; - - typedef base_type* base_ptr; - typedef node_type* node_ptr; -}; - -// rb tree 的迭代器设计 - -template -struct rb_tree_iterator_base :public mystl::iterator -{ - typedef typename rb_tree_traits::base_ptr base_ptr; - - base_ptr node; // 指向节点本身 - - rb_tree_iterator_base() :node(nullptr) {} - - // 使迭代器前进 - void inc() - { - if (node->right != nullptr) - { - node = rb_tree_min(node->right); - } - else - { // 如果没有右子节点 - auto y = node->parent; - while (y->right == node) - { - node = y; - y = y->parent; - } - if (node->right != y) // 应对“寻找根节点的下一节点，而根节点没有右子节点”的特殊情况 - node = y; - } - } - - // 使迭代器后退 - void dec() - { - if (node->parent->parent == node && rb_tree_is_red(node)) - { // 如果 node 为 header - node = node->right; // 指向整棵树的 max 节点 - } - else if (node->left != nullptr) - { - node = rb_tree_max(node->left); - } - else - { // 非 header 节点，也无左子节点 - auto y = node->parent; - while (node == y->left) - { - node = y; - y = y->parent; - } - node = y; - } - } - - bool operator==(const rb_tree_iterator_base& rhs) { return node == rhs.node; } - bool operator!=(const rb_tree_iterator_base& rhs) { return node != rhs.node; } -}; - -template -struct rb_tree_iterator :public rb_tree_iterator_base -{ - typedef rb_tree_traits tree_traits; - - typedef typename tree_traits::value_type value_type; - typedef typename tree_traits::pointer pointer; - typedef typename tree_traits::reference reference; - typedef typename tree_traits::base_ptr base_ptr; - typedef typename tree_traits::node_ptr node_ptr; - - typedef rb_tree_iterator iterator; - typedef rb_tree_const_iterator const_iterator; - typedef iterator self; - - using rb_tree_iterator_base::node; - - // 构造函数 - rb_tree_iterator() {} - rb_tree_iterator(base_ptr x) { node = x; } - rb_tree_iterator(node_ptr x) { node = x; } - rb_tree_iterator(const iterator& rhs) { node = rhs.node; } - rb_tree_iterator(const const_iterator& rhs) { node = rhs.node; } - - // 重载操作符 - reference operator*() const { return node->get_node_ptr()->value; } - pointer operator->() const { return &(operator*()); } - - self& operator++() - { - this->inc(); - return *this; - } - self operator++(int) - { - self tmp(*this); - this->inc(); - return tmp; - } - self& operator--() - { - this->dec(); - return *this; - } - self operator--(int) - { - self tmp(*this); - this->dec(); - return tmp; - } -}; - -template -struct rb_tree_const_iterator :public rb_tree_iterator_base -{ - typedef rb_tree_traits tree_traits; - - typedef typename tree_traits::value_type value_type; - typedef typename tree_traits::const_pointer pointer; - typedef typename tree_traits::const_reference reference; - typedef typename tree_traits::base_ptr base_ptr; - typedef typename tree_traits::node_ptr node_ptr; - - typedef rb_tree_iterator iterator; - typedef rb_tree_const_iterator const_iterator; - typedef const_iterator self; - - using rb_tree_iterator_base::node; - - // 构造函数 - rb_tree_const_iterator() {} - rb_tree_const_iterator(base_ptr x) { node = x; } - rb_tree_const_iterator(node_ptr x) { node = x; } - rb_tree_const_iterator(const iterator& rhs) { node = rhs.node; } - rb_tree_const_iterator(const const_iterator& rhs) { node = rhs.node; } - - // 重载操作符 - reference operator*() const { return node->get_node_ptr()->value; } - pointer operator->() const { return &(operator*()); } - - self& operator++() - { - this->inc(); - return *this; - } - self operator++(int) - { - self tmp(*this); - this->inc(); - return tmp; - } - self& operator--() - { - this->dec(); - return *this; - } - self operator--(int) - { - self tmp(*this); - this->dec(); - return tmp; - } -}; - -// tree algorithm - -template -NodePtr rb_tree_min(NodePtr x) noexcept -{ - while (x->left != nullptr) - x = x->left; - return x; -} - -template -NodePtr rb_tree_max(NodePtr x) noexcept -{ - while (x->right != nullptr) - x = x->right; - return x; -} - -template -bool rb_tree_is_lchild(NodePtr node) noexcept -{ - return node == node->parent->left; -} - -template -bool rb_tree_is_red(NodePtr node) noexcept -{ - return node->color == rb_tree_red; -} - -template -void rb_tree_set_black(NodePtr& node) noexcept -{ - node->color = rb_tree_black; -} - -template -void rb_tree_set_red(NodePtr& node) noexcept -{ - node->color = rb_tree_red; -} - -template -NodePtr rb_tree_next(NodePtr node) noexcept -{ - if (node->right != nullptr) - return rb_tree_min(node->right); - while (!rb_tree_is_lchild(node)) - node = node->parent; - return node->parent; -} - -/*---------------------------------------*\ -| p p | -| / \ / \ | -| x d rotate left y d | -| / \ ===========> / \ | -| a y x c | -| / \ / \ | -| b c a b | -\*---------------------------------------*/ -// 左旋，参数一为左旋点，参数二为根节点 -template -void rb_tree_rotate_left(NodePtr x, NodePtr& root) noexcept -{ - auto y = x->right; // y 为 x 的右子节点 - x->right = y->left; - if (y->left != nullptr) - y->left->parent = x; - y->parent = x->parent; - - if (x == root) - { // 如果 x 为根节点，让 y 顶替 x 成为根节点 - root = y; - } - else if (rb_tree_is_lchild(x)) - { // 如果 x 是左子节点 - x->parent->left = y; - } - else - { // 如果 x 是右子节点 - x->parent->right = y; - } - // 调整 x 与 y 的关系 - y->left = x; - x->parent = y; -} - -/*----------------------------------------*\ -| p p | -| / \ / \ | -| d x rotate right d y | -| / \ ===========> / \ | -| y a b x | -| / \ / \ | -| b c c a | -\*----------------------------------------*/ -// 右旋，参数一为右旋点，参数二为根节点 -template -void rb_tree_rotate_right(NodePtr x, NodePtr& root) noexcept -{ - auto y = x->left; - x->left = y->right; - if (y->right) - y->right->parent = x; - y->parent = x->parent; - - if (x == root) - { // 如果 x 为根节点，让 y 顶替 x 成为根节点 - root = y; - } - else if (rb_tree_is_lchild(x)) - { // 如果 x 是右子节点 - x->parent->left = y; - } - else - { // 如果 x 是左子节点 - x->parent->right = y; - } - // 调整 x 与 y 的关系 - y->right = x; - x->parent = y; -} - -// 插入节点后使 rb tree 重新平衡，参数一为新增节点，参数二为根节点 -// -// case 1: 新增节点位于根节点，令新增节点为黑 -// case 2: 新增节点的父节点为黑，没有破坏平衡，直接返回 -// case 3: 父节点和叔叔节点都为红，令父节点和叔叔节点为黑，祖父节点为红， -// 然后令祖父节点为当前节点，继续处理 -// case 4: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为右（左）孩子， -// 让父节点成为当前节点，再以当前节点为支点左（右）旋 -// case 5: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为左（右）孩子， -// 让父节点变为黑色，祖父节点变为红色，以祖父节点为支点右（左）旋 -// -// 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 -// http://blog.csdn.net/v_JULY_v/article/details/6109153 -template -void rb_tree_insert_rebalance(NodePtr x, NodePtr& root) noexcept -{ - rb_tree_set_red(x); // 新增节点为红色 - while (x != root && rb_tree_is_red(x->parent)) - { - if (rb_tree_is_lchild(x->parent)) - { // 如果父节点是左子节点 - auto uncle = x->parent->parent->right; - if (uncle != nullptr && rb_tree_is_red(uncle)) - { // case 3: 父节点和叔叔节点都为红 - rb_tree_set_black(x->parent); - rb_tree_set_black(uncle); - x = x->parent->parent; - rb_tree_set_red(x); - } - else - { // 无叔叔节点或叔叔节点为黑 - if (!rb_tree_is_lchild(x)) - { // case 4: 当前节点 x 为右子节点 - x = x->parent; - rb_tree_rotate_left(x, root); - } - // 都转换成 case 5： 当前节点为左子节点 - rb_tree_set_black(x->parent); - rb_tree_set_red(x->parent->parent); - rb_tree_rotate_right(x->parent->parent, root); - break; - } - } - else // 如果父节点是右子节点，对称处理 - { - auto uncle = x->parent->parent->left; - if (uncle != nullptr && rb_tree_is_red(uncle)) - { // case 3: 父节点和叔叔节点都为红 - rb_tree_set_black(x->parent); - rb_tree_set_black(uncle); - x = x->parent->parent; - rb_tree_set_red(x); - // 此时祖父节点为红，可能会破坏红黑树的性质，令当前节点为祖父节点，继续处理 - } - else - { // 无叔叔节点或叔叔节点为黑 - if (rb_tree_is_lchild(x)) - { // case 4: 当前节点 x 为左子节点 - x = x->parent; - rb_tree_rotate_right(x, root); - } - // 都转换成 case 5： 当前节点为左子节点 - rb_tree_set_black(x->parent); - rb_tree_set_red(x->parent->parent); - rb_tree_rotate_left(x->parent->parent, root); - break; - } - } - } - rb_tree_set_black(root); // 根节点永远为黑 -} - -// 删除节点后使 rb tree 重新平衡，参数一为要删除的节点，参数二为根节点，参数三为最小节点，参数四为最大节点 -// -// 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 -// http://blog.csdn.net/v_JULY_v/article/details/6109153 -template -NodePtr rb_tree_erase_rebalance(NodePtr z, NodePtr& root, NodePtr& leftmost, NodePtr& rightmost) -{ - // y 是可能的替换节点，指向最终要删除的节点 - auto y = (z->left == nullptr || z->right == nullptr) ? z : rb_tree_next(z); - // x 是 y 的一个独子节点或 NIL 节点 - auto x = y->left != nullptr ? y->left : y->right; - // xp 为 x 的父节点 - NodePtr xp = nullptr; - - // y != z 说明 z 有两个非空子节点，此时 y 指向 z 右子树的最左节点，x 指向 y 的右子节点。 - // 用 y 顶替 z 的位置，用 x 顶替 y 的位置，最后用 y 指向 z - if (y != z) - { - z->left->parent = y; - y->left = z->left; - - // 如果 y 不是 z 的右子节点，那么 z 的右子节点一定有左孩子 - if (y != z->right) - { // x 替换 y 的位置 - xp = y->parent; - if (x != nullptr) - x->parent = y->parent; - - y->parent->left = x; - y->right = z->right; - z->right->parent = y; - } - else - { - xp = y; - } - - // 连接 y 与 z 的父节点 - if (root == z) - root = y; - else if (rb_tree_is_lchild(z)) - z->parent->left = y; - else - z->parent->right = y; - y->parent = z->parent; - mystl::swap(y->color, z->color); - y = z; - } - // y == z 说明 z 至多只有一个孩子 - else - { - xp = y->parent; - if (x) - x->parent = y->parent; - - // 连接 x 与 z 的父节点 - if (root == z) - root = x; - else if (rb_tree_is_lchild(z)) - z->parent->left = x; - else - z->parent->right = x; - - // 此时 z 有可能是最左节点或最右节点，更新数据 - if (leftmost == z) - leftmost = x == nullptr ? xp : rb_tree_min(x); - if (rightmost == z) - rightmost = x == nullptr ? xp : rb_tree_max(x); - } - - // 此时，y 指向要删除的节点，x 为替代节点，从 x 节点开始调整。 - // 如果删除的节点为红色，树的性质没有被破坏，否则按照以下情况调整（x 为左子节点为例）： - // case 1: 兄弟节点为红色，令父节点为红，兄弟节点为黑，进行左（右）旋，继续处理 - // case 2: 兄弟节点为黑色，且两个子节点都为黑色或 NIL，令兄弟节点为红，父节点成为当前节点，继续处理 - // case 3: 兄弟节点为黑色，左子节点为红色或 NIL，右子节点为黑色或 NIL， - // 令兄弟节点为红，兄弟节点的左子节点为黑，以兄弟节点为支点右（左）旋，继续处理 - // case 4: 兄弟节点为黑色，右子节点为红色，令兄弟节点为父节点的颜色，父节点为黑色，兄弟节点的右子节点 - // 为黑色，以父节点为支点左（右）旋，树的性质调整完成，算法结束 - if (!rb_tree_is_red(y)) - { // x 为黑色时，调整，否则直接将 x 变为黑色即可 - while (x != root && (x == nullptr || !rb_tree_is_red(x))) - { - if (x == xp->left) - { // 如果 x 为左子节点 - auto brother = xp->right; - if (rb_tree_is_red(brother)) - { // case 1 - rb_tree_set_black(brother); - rb_tree_set_red(xp); - rb_tree_rotate_left(xp, root); - brother = xp->right; - } - // case 1 转为为了 case 2、3、4 中的一种 - if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && - (brother->right == nullptr || !rb_tree_is_red(brother->right))) - { // case 2 - rb_tree_set_red(brother); - x = xp; - xp = xp->parent; - } - else - { - if (brother->right == nullptr || !rb_tree_is_red(brother->right)) - { // case 3 - if (brother->left != nullptr) - rb_tree_set_black(brother->left); - rb_tree_set_red(brother); - rb_tree_rotate_right(brother, root); - brother = xp->right; - } - // 转为 case 4 - brother->color = xp->color; - rb_tree_set_black(xp); - if (brother->right != nullptr) - rb_tree_set_black(brother->right); - rb_tree_rotate_left(xp, root); - break; - } - } - else // x 为右子节点，对称处理 - { - auto brother = xp->left; - if (rb_tree_is_red(brother)) - { // case 1 - rb_tree_set_black(brother); - rb_tree_set_red(xp); - rb_tree_rotate_right(xp, root); - brother = xp->left; - } - if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && - (brother->right == nullptr || !rb_tree_is_red(brother->right))) - { // case 2 - rb_tree_set_red(brother); - x = xp; - xp = xp->parent; - } - else - { - if (brother->left == nullptr || !rb_tree_is_red(brother->left)) - { // case 3 - if (brother->right != nullptr) - rb_tree_set_black(brother->right); - rb_tree_set_red(brother); - rb_tree_rotate_left(brother, root); - brother = xp->left; - } - // 转为 case 4 - brother->color = xp->color; - rb_tree_set_black(xp); - if (brother->left != nullptr) - rb_tree_set_black(brother->left); - rb_tree_rotate_right(xp, root); - break; - } - } - } - if (x != nullptr) - rb_tree_set_black(x); - } - return y; -} - -// 模板类 rb_tree -// 参数一代表数据类型，参数二代表键值比较类型 -template -class rb_tree -{ -public: - // rb_tree 的嵌套型别定义 - - typedef rb_tree_traits tree_traits; - typedef rb_tree_value_traits value_traits; - - typedef typename tree_traits::base_type base_type; - typedef typename tree_traits::base_ptr base_ptr; - typedef typename tree_traits::node_type node_type; - typedef typename tree_traits::node_ptr node_ptr; - typedef typename tree_traits::key_type key_type; - typedef typename tree_traits::mapped_type mapped_type; - typedef typename tree_traits::value_type value_type; - typedef Compare key_compare; - - typedef mystl::allocator allocator_type; - typedef mystl::allocator data_allocator; - typedef mystl::allocator base_allocator; - typedef mystl::allocator node_allocator; - - typedef typename allocator_type::pointer pointer; - typedef typename allocator_type::const_pointer const_pointer; - typedef typename allocator_type::reference reference; - typedef typename allocator_type::const_reference const_reference; - typedef typename allocator_type::size_type size_type; - typedef typename allocator_type::difference_type difference_type; - - typedef rb_tree_iterator iterator; - typedef rb_tree_const_iterator const_iterator; - typedef mystl::reverse_iterator reverse_iterator; - typedef mystl::reverse_iterator const_reverse_iterator; - - allocator_type get_allocator() const { return node_allocator(); } - key_compare key_comp() const { return key_comp_; } - -private: - // 用以下三个数据表现 rb tree - base_ptr header_; // 特殊节点，与根节点互为对方的父节点 - size_type node_count_; // 节点数 - key_compare key_comp_; // 节点键值比较的准则 - -private: - // 以下三个函数用于取得根节点，最小节点和最大节点 - base_ptr& root() const { return header_->parent; } - base_ptr& leftmost() const { return header_->left; } - base_ptr& rightmost() const { return header_->right; } - -public: - // 构造、复制、析构函数 - rb_tree() { rb_tree_init(); } - - rb_tree(const rb_tree& rhs); - rb_tree(rb_tree&& rhs) noexcept; - - rb_tree& operator=(const rb_tree& rhs); - rb_tree& operator=(rb_tree&& rhs); - - ~rb_tree() { clear(); } - -public: - // 迭代器相关操作 - - iterator begin() noexcept - { return leftmost(); } - const_iterator begin() const noexcept - { return leftmost(); } - iterator end() noexcept - { return header_; } - const_iterator end() const noexcept - { return header_; } - - reverse_iterator rbegin() noexcept - { return reverse_iterator(end()); } - const_reverse_iterator rbegin() const noexcept - { return const_reverse_iterator(end()); } - reverse_iterator rend() noexcept - { return reverse_iterator(begin()); } - const_reverse_iterator rend() const noexcept - { return const_reverse_iterator(begin()); } - - const_iterator cbegin() const noexcept - { return begin(); } - const_iterator cend() const noexcept - { return end(); } - const_reverse_iterator crbegin() const noexcept - { return rbegin(); } - const_reverse_iterator crend() const noexcept - { return rend(); } - - // 容量相关操作 - - bool empty() const noexcept { return node_count_ == 0; } - size_type size() const noexcept { return node_count_; } - size_type max_size() const noexcept { return static_cast(-1); } - - // 插入删除相关操作 - - // emplace - - template - iterator emplace_multi(Args&& ...args); - - template - mystl::pair emplace_unique(Args&& ...args); - - template - iterator emplace_multi_use_hint(iterator hint, Args&& ...args); - - template - iterator emplace_unique_use_hint(iterator hint, Args&& ...args); - - // insert - - iterator insert_multi(const value_type& value); - iterator insert_multi(value_type&& value) - { - return emplace_multi(mystl::move(value)); - } - - iterator insert_multi(iterator hint, const value_type& value) - { - return emplace_multi_use_hint(hint, value); - } - iterator insert_multi(iterator hint, value_type&& value) - { - return emplace_multi_use_hint(hint, mystl::move(value)); - } - - template - void insert_multi(InputIterator first, InputIterator last) - { - size_type n = mystl::distance(first, last); - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); - for (; n > 0; --n, ++first) - insert_multi(end(), *first); - } - - mystl::pair insert_unique(const value_type& value); - mystl::pair insert_unique(value_type&& value) - { - return emplace_unique(mystl::move(value)); - } - - iterator insert_unique(iterator hint, const value_type& value) - { - return emplace_unique_use_hint(hint, value); - } - iterator insert_unique(iterator hint, value_type&& value) - { - return emplace_unique_use_hint(hint, mystl::move(value)); - } - - template - void insert_unique(InputIterator first, InputIterator last) - { - size_type n = mystl::distance(first, last); - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); - for (; n > 0; --n, ++first) - insert_unique(end(), *first); - } - - // erase - - iterator erase(iterator hint); - - size_type erase_multi(const key_type& key); - size_type erase_unique(const key_type& key); - - void erase(iterator first, iterator last); - - void clear(); - - // rb_tree 相关操作 - - iterator find(const key_type& key); - const_iterator find(const key_type& key) const; - - size_type count_multi(const key_type& key) const - { - auto p = equal_range_multi(key); - return static_cast(mystl::distance(p.first, p.second)); - } - size_type count_unique(const key_type& key) const - { - return find(key) != end() ? 1 : 0; - } - - iterator lower_bound(const key_type& key); - const_iterator lower_bound(const key_type& key) const; - - iterator upper_bound(const key_type& key); - const_iterator upper_bound(const key_type& key) const; - - mystl::pair - equal_range_multi(const key_type& key) - { - return mystl::pair(lower_bound(key), upper_bound(key)); - } - mystl::pair - equal_range_multi(const key_type& key) const - { - return mystl::pair(lower_bound(key), upper_bound(key)); - } - - mystl::pair - equal_range_unique(const key_type& key) - { - iterator it = find(key); - auto next = it; - return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); - } - mystl::pair - equal_range_unique(const key_type& key) const - { - const_iterator it = find(key); - auto next = it; - return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); - } - - void swap(rb_tree& rhs) noexcept; - -private: - - // node related - template - node_ptr create_node(Args&&... args); - node_ptr clone_node(base_ptr x); - void destroy_node(node_ptr p); - - // init / reset - void rb_tree_init(); - void reset(); - - // get insert pos - mystl::pair - get_insert_multi_pos(const key_type& key); - mystl::pair, bool> - get_insert_unique_pos(const key_type& key); - - // insert value / insert node - iterator insert_value_at(base_ptr x, const value_type& value, bool add_to_left); - iterator insert_node_at(base_ptr x, node_ptr node, bool add_to_left); - - // insert use hint - iterator insert_multi_use_hint(iterator hint, key_type key, node_ptr node); - iterator insert_unique_use_hint(iterator hint, key_type key, node_ptr node); - - // copy tree / erase tree - base_ptr copy_from(base_ptr x, base_ptr p); - void erase_since(base_ptr x); -}; - -/*****************************************************************************************/ - -// 复制构造函数 -template -rb_tree:: -rb_tree(const rb_tree& rhs) -{ - rb_tree_init(); - if (rhs.node_count_ != 0) - { - root() = copy_from(rhs.root(), header_); - leftmost() = rb_tree_min(root()); - rightmost() = rb_tree_max(root()); - } - node_count_ = rhs.node_count_; - key_comp_ = rhs.key_comp_; -} - -// 移动构造函数 -template -rb_tree:: -rb_tree(rb_tree&& rhs) noexcept - :header_(mystl::move(rhs.header_)), - node_count_(rhs.node_count_), - key_comp_(rhs.key_comp_) -{ - rhs.reset(); -} - -// 复制赋值操作符 -template -rb_tree& -rb_tree:: -operator=(const rb_tree& rhs) -{ - if (this != &rhs) - { - clear(); - - if (rhs.node_count_ != 0) - { - root() = copy_from(rhs.root(), header_); - leftmost() = rb_tree_min(root()); - rightmost() = rb_tree_max(root()); - } - - node_count_ = rhs.node_count_; - key_comp_ = rhs.key_comp_; - } - return *this; -} - -// 移动赋值操作符 -template -rb_tree& -rb_tree:: -operator=(rb_tree&& rhs) -{ - clear(); - header_ = mystl::move(rhs.header_); - node_count_ = rhs.node_count_; - key_comp_ = rhs.key_comp_; - rhs.reset(); - return *this; -} - -// 就地插入元素，键值允许重复 -template -template -typename rb_tree::iterator -rb_tree:: -emplace_multi(Args&& ...args) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - node_ptr np = create_node(mystl::forward(args)...); - auto res = get_insert_multi_pos(value_traits::get_key(np->value)); - return insert_node_at(res.first, np, res.second); -} - -// 就地插入元素，键值不允许重复 -template -template -mystl::pair::iterator, bool> -rb_tree:: -emplace_unique(Args&& ...args) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - node_ptr np = create_node(mystl::forward(args)...); - auto res = get_insert_unique_pos(value_traits::get_key(np->value)); - if (res.second) - { // 插入成功 - return mystl::make_pair(insert_node_at(res.first.first, np, res.first.second), true); - } - destroy_node(np); - return mystl::make_pair(iterator(res.first.first), false); -} - -// 就地插入元素，键值允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 -template -template -typename rb_tree::iterator -rb_tree:: -emplace_multi_use_hint(iterator hint, Args&& ...args) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - node_ptr np = create_node(mystl::forward(args)...); - if (node_count_ == 0) - { - return insert_node_at(header_, np, true); - } - key_type key = value_traits::get_key(np->value); - if (hint == begin()) - { // 位于 begin 处 - if (key_comp_(key, value_traits::get_key(*hint))) - { - return insert_node_at(hint.node, np, true); - } - else - { - auto pos = get_insert_multi_pos(key); - return insert_node_at(pos.first, np, pos.second); - } - } - else if (hint == end()) - { // 位于 end 处 - if (!key_comp_(key, value_traits::get_key(rightmost()->get_node_ptr()->value))) - { - return insert_node_at(rightmost(), np, false); - } - else - { - auto pos = get_insert_multi_pos(key); - return insert_node_at(pos.first, np, pos.second); - } - } - return insert_multi_use_hint(hint, key, np); -} - -// 就地插入元素，键值不允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 -template -template -typename rb_tree::iterator -rb_tree:: -emplace_unique_use_hint(iterator hint, Args&& ...args) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - node_ptr np = create_node(mystl::forward(args)...); - if (node_count_ == 0) - { - return insert_node_at(header_, np, true); - } - key_type key = value_traits::get_key(np->value); - if (hint == begin()) - { // 位于 begin 处 - if (key_comp_(key, value_traits::get_key(*hint))) - { - return insert_node_at(hint.node, np, true); - } - else - { - auto pos = get_insert_unique_pos(key); - if (!pos.second) - { - destroy_node(np); - return pos.first.first; - } - return insert_node_at(pos.first.first, np, pos.first.second); - } - } - else if (hint == end()) - { // 位于 end 处 - if (key_comp_(value_traits::get_key(rightmost()->get_node_ptr()->value), key)) - { - return insert_node_at(rightmost(), np, false); - } - else - { - auto pos = get_insert_unique_pos(key); - if (!pos.second) - { - destroy_node(np); - return pos.first.first; - } - return insert_node_at(pos.first.first, np, pos.first.second); - } - } - return insert_unique_use_hint(hint, key, np); -} - -// 插入元素，节点键值允许重复 -template -typename rb_tree::iterator -rb_tree:: -insert_multi(const value_type& value) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - auto res = get_insert_multi_pos(value_traits::get_key(value)); - return insert_value_at(res.first, value, res.second); -} - -// 插入新值，节点键值不允许重复，返回一个 pair，若插入成功，pair 的第二参数为 true，否则为 false -template -mystl::pair::iterator, bool> -rb_tree:: -insert_unique(const value_type& value) -{ - THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); - auto res = get_insert_unique_pos(value_traits::get_key(value)); - if (res.second) - { // 插入成功 - return mystl::make_pair(insert_value_at(res.first.first, value, res.first.second), true); - } - return mystl::make_pair(res.first.first, false); -} - -// 删除 hint 位置的节点 -template -typename rb_tree::iterator -rb_tree:: -erase(iterator hint) -{ - auto node = hint.node->get_node_ptr(); - iterator next(node); - ++next; - - rb_tree_erase_rebalance(hint.node, root(), leftmost(), rightmost()); - destroy_node(node); - --node_count_; - return next; -} - -// 删除键值等于 key 的元素，返回删除的个数 -template -typename rb_tree::size_type -rb_tree:: -erase_multi(const key_type& key) -{ - auto p = equal_range_multi(key); - size_type n = mystl::distance(p.first, p.second); - erase(p.first, p.second); - return n; -} - -// 删除键值等于 key 的元素，返回删除的个数 -template -typename rb_tree::size_type -rb_tree:: -erase_unique(const key_type& key) -{ - auto it = find(key); - if (it != end()) - { - erase(it); - return 1; - } - return 0; -} - -// 删除[first, last)区间内的元素 -template -void rb_tree:: -erase(iterator first, iterator last) -{ - if (first == begin() && last == end()) - { - clear(); - } - else - { - while (first != last) - erase(first++); - } -} - -// 清空 rb tree -template -void rb_tree:: -clear() -{ - if (node_count_ != 0) - { - erase_since(root()); - leftmost() = header_; - root() = nullptr; - rightmost() = header_; - node_count_ = 0; - } -} - -// 查找键值为 k 的节点，返回指向它的迭代器 -template -typename rb_tree::iterator -rb_tree:: -find(const key_type& key) -{ - auto y = header_; // 最后一个不小于 key 的节点 - auto x = root(); - while (x != nullptr) - { - if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) - { // key 小于等于 x 键值，向左走 - y = x, x = x->left; - } - else - { // key 大于 x 键值，向右走 - x = x->right; - } - } - iterator j = iterator(y); - return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; -} - -template -typename rb_tree::const_iterator -rb_tree:: -find(const key_type& key) const -{ - auto y = header_; // 最后一个不小于 key 的节点 - auto x = root(); - while (x != nullptr) - { - if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) - { // key 小于等于 x 键值，向左走 - y = x, x = x->left; - } - else - { // key 大于 x 键值，向右走 - x = x->right; - } - } - const_iterator j = const_iterator(y); - return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; -} - -// 键值不小于 key 的第一个位置 -template -typename rb_tree::iterator -rb_tree:: -lower_bound(const key_type& key) -{ - auto y = header_; - auto x = root(); - while (x != nullptr) - { - if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) - { // key <= x - y = x, x = x->left; - } - else - { - x = x->right; - } - } - return iterator(y); -} - -template -typename rb_tree::const_iterator -rb_tree:: -lower_bound(const key_type& key) const -{ - auto y = header_; - auto x = root(); - while (x != nullptr) - { - if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) - { // key <= x - y = x, x = x->left; - } - else - { - x = x->right; - } - } - return const_iterator(y); -} - -// 键值不小于 key 的最后一个位置 -template -typename rb_tree::iterator -rb_tree:: -upper_bound(const key_type& key) -{ - auto y = header_; - auto x = root(); - while (x != nullptr) - { - if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) - { // key < x - y = x, x = x->left; - } - else - { - x = x->right; - } - } - return iterator(y); -} - -template -typename rb_tree::const_iterator -rb_tree:: -upper_bound(const key_type& key) const -{ - auto y = header_; - auto x = root(); - while (x != nullptr) - { - if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) - { // key < x - y = x, x = x->left; - } - else - { - x = x->right; - } - } - return const_iterator(y); -} - -// 交换 rb tree -template -void rb_tree:: -swap(rb_tree& rhs) noexcept -{ - if (this != &rhs) - { - mystl::swap(header_, rhs.header_); - mystl::swap(node_count_, rhs.node_count_); - mystl::swap(key_comp_, rhs.key_comp_); - } -} - -/*****************************************************************************************/ -// helper function - -// 创建一个结点 -template -template -typename rb_tree::node_ptr -rb_tree:: -create_node(Args&&... args) -{ - auto tmp = node_allocator::allocate(1); - try - { - data_allocator::construct(mystl::address_of(tmp->value), mystl::forward(args)...); - tmp->left = nullptr; - tmp->right = nullptr; - tmp->parent = nullptr; - } - catch (...) - { - node_allocator::deallocate(tmp); - throw; - } - return tmp; -} - -// 复制一个结点 -template -typename rb_tree::node_ptr -rb_tree:: -clone_node(base_ptr x) -{ - node_ptr tmp = create_node(x->get_node_ptr()->value); - tmp->color = x->color; - tmp->left = nullptr; - tmp->right = nullptr; - return tmp; -} - -// 销毁一个结点 -template -void rb_tree:: -destroy_node(node_ptr p) -{ - data_allocator::destroy(&p->value); - node_allocator::deallocate(p); -} - -// 初始化容器 -template -void rb_tree:: -rb_tree_init() -{ - header_ = base_allocator::allocate(1); - header_->color = rb_tree_red; // header_ 节点颜色为红，与 root 区分 - root() = nullptr; - leftmost() = header_; - rightmost() = header_; - node_count_ = 0; -} - -// reset 函数 -template -void rb_tree::reset() -{ - header_ = nullptr; - node_count_ = 0; -} - -// get_insert_multi_pos 函数 -template -mystl::pair::base_ptr, bool> -rb_tree::get_insert_multi_pos(const key_type& key) -{ - auto x = root(); - auto y = header_; - bool add_to_left = true; - while (x != nullptr) - { - y = x; - add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); - x = add_to_left ? x->left : x->right; - } - return mystl::make_pair(y, add_to_left); -} - -// get_insert_unique_pos 函数 -template -mystl::pair::base_ptr, bool>, bool> -rb_tree::get_insert_unique_pos(const key_type& key) -{ // 返回一个 pair，第一个值为一个 pair，包含插入点的父节点和一个 bool 表示是否在左边插入， - // 第二个值为一个 bool，表示是否插入成功 - auto x = root(); - auto y = header_; - bool add_to_left = true; // 树为空时也在 header_ 左边插入 - while (x != nullptr) - { - y = x; - add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); - x = add_to_left ? x->left : x->right; - } - iterator j = iterator(y); // 此时 y 为插入点的父节点 - if (add_to_left) - { - if (y == header_ || j == begin()) - { // 如果树为空树或插入点在最左节点处，肯定可以插入新的节点 - return mystl::make_pair(mystl::make_pair(y, true), true); - } - else - { // 否则，如果存在重复节点，那么 --j 就是重复的值 - --j; - } - } - if (key_comp_(value_traits::get_key(*j), key)) - { // 表明新节点没有重复 - return mystl::make_pair(mystl::make_pair(y, add_to_left), true); - } - // 进行至此，表示新节点与现有节点键值重复 - return mystl::make_pair(mystl::make_pair(y, add_to_left), false); -} - -// insert_value_at 函数 -// x 为插入点的父节点， value 为要插入的值，add_to_left 表示是否在左边插入 -template -typename rb_tree::iterator -rb_tree:: -insert_value_at(base_ptr x, const value_type& value, bool add_to_left) -{ - node_ptr node = create_node(value); - node->parent = x; - auto base_node = node->get_base_ptr(); - if (x == header_) - { - root() = base_node; - leftmost() = base_node; - rightmost() = base_node; - } - else if (add_to_left) - { - x->left = base_node; - if (leftmost() == x) - leftmost() = base_node; - } - else - { - x->right = base_node; - if (rightmost() == x) - rightmost() = base_node; - } - rb_tree_insert_rebalance(base_node, root()); - ++node_count_; - return iterator(node); -} - -// 在 x 节点处插入新的节点 -// x 为插入点的父节点， node 为要插入的节点，add_to_left 表示是否在左边插入 -template -typename rb_tree::iterator -rb_tree:: -insert_node_at(base_ptr x, node_ptr node, bool add_to_left) -{ - node->parent = x; - auto base_node = node->get_base_ptr(); - if (x == header_) - { - root() = base_node; - leftmost() = base_node; - rightmost() = base_node; - } - else if (add_to_left) - { - x->left = base_node; - if (leftmost() == x) - leftmost() = base_node; - } - else - { - x->right = base_node; - if (rightmost() == x) - rightmost() = base_node; - } - rb_tree_insert_rebalance(base_node, root()); - ++node_count_; - return iterator(node); -} - -// 插入元素，键值允许重复，使用 hint -template -typename rb_tree::iterator -rb_tree:: -insert_multi_use_hint(iterator hint, key_type key, node_ptr node) -{ - // 在 hint 附近寻找可插入的位置 - auto np = hint.node; - auto before = hint; - --before; - auto bnp = before.node; - if (!key_comp_(key, value_traits::get_key(*before)) && - !key_comp_(value_traits::get_key(*hint), key)) - { // before <= node <= hint - if (bnp->right == nullptr) - { - return insert_node_at(bnp, node, false); - } - else if (np->left == nullptr) - { - return insert_node_at(np, node, true); - } - } - auto pos = get_insert_multi_pos(key); - return insert_node_at(pos.first, node, pos.second); -} - -// 插入元素，键值不允许重复，使用 hint -template -typename rb_tree::iterator -rb_tree:: -insert_unique_use_hint(iterator hint, key_type key, node_ptr node) -{ - // 在 hint 附近寻找可插入的位置 - auto np = hint.node; - auto before = hint; - --before; - auto bnp = before.node; - if (key_comp_(value_traits::get_key(*before), key) && - key_comp_(key, value_traits::get_key(*hint))) - { // before < node < hint - if (bnp->right == nullptr) - { - return insert_node_at(bnp, node, false); - } - else if (np->left == nullptr) - { - return insert_node_at(np, node, true); - } - } - auto pos = get_insert_unique_pos(key); - if (!pos.second) - { - destroy_node(node); - return pos.first.first; - } - return insert_node_at(pos.first.first, node, pos.first.second); -} - -// copy_from 函数 -// 递归复制一颗树，节点从 x 开始，p 为 x 的父节点 -template -typename rb_tree::base_ptr -rb_tree::copy_from(base_ptr x, base_ptr p) -{ - auto top = clone_node(x); - top->parent = p; - try - { - if (x->right) - top->right = copy_from(x->right, top); - p = top; - x = x->left; - while (x != nullptr) - { - auto y = clone_node(x); - p->left = y; - y->parent = p; - if (x->right) - y->right = copy_from(x->right, y); - p = y; - x = x->left; - } - } - catch (...) - { - erase_since(top); - throw; - } - return top; -} - -// erase_since 函数 -// 从 x 节点开始删除该节点及其子树 -template -void rb_tree:: -erase_since(base_ptr x) -{ - while (x != nullptr) - { - erase_since(x->right); - auto y = x->left; - destroy_node(x->get_node_ptr()); - x = y; - } -} - -// 重载比较操作符 -template -bool operator==(const rb_tree& lhs, const rb_tree& rhs) -{ - return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); -} - -template -bool operator<(const rb_tree& lhs, const rb_tree& rhs) -{ - return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); -} - -template -bool operator!=(const rb_tree& lhs, const rb_tree& rhs) -{ - return !(lhs == rhs); -} - -template -bool operator>(const rb_tree& lhs, const rb_tree& rhs) -{ - return rhs < lhs; -} - -template -bool operator<=(const rb_tree& lhs, const rb_tree& rhs) -{ - return !(rhs < lhs); -} - -template -bool operator>=(const rb_tree& lhs, const rb_tree& rhs) -{ - return !(lhs < rhs); -} - -// 重载 mystl 的 swap -template -void swap(rb_tree& lhs, rb_tree& rhs) noexcept -{ - lhs.swap(rhs); -} - -} // namespace mystl -#endif // !MYTINYSTL_RB_TREE_H_ - +#ifndef MYTINYSTL_RB_TREE_H_ // +#define MYTINYSTL_RB_TREE_H_ + +// 这个头文件包含一个模板类 rb_tree +// rb_tree : 红黑树 // + +#include + +#include + +#include "functional.h" // +#include "iterator.h" +#include "memory.h" // +#include "type_traits.h" +#include "exceptdef.h" + +namespace mystl +{ + // +// rb tree 节点颜色的类型 + +typedef bool rb_tree_color_type; // + +static constexpr rb_tree_color_type rb_tree_red = false; +static constexpr rb_tree_color_type rb_tree_black = true; // + +// forward declaration // + +template struct rb_tree_node_base; +template struct rb_tree_node; + +template struct rb_tree_iterator; +template struct rb_tree_const_iterator; // + +// rb tree value traits // + +template // +struct rb_tree_value_traits_imp +{ + typedef T key_type; + typedef T mapped_type; // + typedef T value_type; + // + template + static const key_type& get_key(const Ty& value) // + { // + return value; // + } + + template + static const value_type& get_value(const Ty& value) // + { // + return value; // + } +}; + +template +struct rb_tree_value_traits_imp +{ + typedef typename std::remove_cv::type key_type; + typedef typename T::second_type mapped_type; // + typedef T value_type; + + template + static const key_type& get_key(const Ty& value) + { // + return value.first; // + } + + template + static const value_type& get_value(const Ty& value) + { + return value; // + } +}; + +template +struct rb_tree_value_traits +{ + static constexpr bool is_map = mystl::is_pair::value; + // + typedef rb_tree_value_traits_imp value_traits_type; // + + typedef typename value_traits_type::key_type key_type; + typedef typename value_traits_type::mapped_type mapped_type; // + typedef typename value_traits_type::value_type value_type; + + template + static const key_type& get_key(const Ty& value) + { + return value_traits_type::get_key(value); + } + + template // + static const value_type& get_value(const Ty& value) + { + return value_traits_type::get_value(value); + } +}; + // +// rb tree node traits + +template +struct rb_tree_node_traits +{ + typedef rb_tree_color_type color_type; // + + typedef rb_tree_value_traits value_traits; + typedef typename value_traits::key_type key_type; // + typedef typename value_traits::mapped_type mapped_type; + typedef typename value_traits::value_type value_type; + + typedef rb_tree_node_base* base_ptr; // + typedef rb_tree_node* node_ptr; +}; + +// rb tree 的节点设计 // + // +template +struct rb_tree_node_base +{ // + typedef rb_tree_color_type color_type; + typedef rb_tree_node_base* base_ptr; + typedef rb_tree_node* node_ptr; + + base_ptr parent; // 父节点 + base_ptr left; // 左子节点 // + base_ptr right; // 右子节点 + color_type color; // 节点颜色 + // + base_ptr get_base_ptr() + { + return &*this; // + } + + node_ptr get_node_ptr() + { // + return reinterpret_cast(&*this); + } // + + node_ptr& get_node_ref() + { + return reinterpret_cast(*this); + } +}; + +template // +struct rb_tree_node :public rb_tree_node_base +{ // + typedef rb_tree_node_base* base_ptr; + typedef rb_tree_node* node_ptr; // + + T value; // 节点值 // + + base_ptr get_base_ptr() // + { // + return static_cast(&*this); // + } + + node_ptr get_node_ptr() + { + return &*this; + } // +}; + // +// rb tree traits + // +template +struct rb_tree_traits +{ + typedef rb_tree_value_traits value_traits; // + + typedef typename value_traits::key_type key_type; // + typedef typename value_traits::mapped_type mapped_type; + typedef typename value_traits::value_type value_type; // + + typedef value_type* pointer; // + typedef value_type& reference; + typedef const value_type* const_pointer; + typedef const value_type& const_reference; + // + typedef rb_tree_node_base base_type; + typedef rb_tree_node node_type; + + typedef base_type* base_ptr; // + typedef node_type* node_ptr; +}; // + +// rb tree 的迭代器设计 + +template // +struct rb_tree_iterator_base :public mystl::iterator +{ + typedef typename rb_tree_traits::base_ptr base_ptr; + // + base_ptr node; // 指向节点本身 + // + rb_tree_iterator_base() :node(nullptr) {} + // + // 使迭代器前进 + void inc() // + { + if (node->right != nullptr) // + { + node = rb_tree_min(node->right); // + } + else + { // 如果没有右子节点 // + auto y = node->parent; + while (y->right == node) + { + node = y; + y = y->parent; // + } + if (node->right != y) // 应对“寻找根节点的下一节点，而根节点没有右子节点”的特殊情况 + node = y; + } + } + // + // 使迭代器后退 + void dec() // + { + if (node->parent->parent == node && rb_tree_is_red(node)) // + { // 如果 node 为 header + node = node->right; // 指向整棵树的 max 节点 // + } // + else if (node->left != nullptr) + { + node = rb_tree_max(node->left); // + } + else + { // 非 header 节点，也无左子节点 + auto y = node->parent; // + while (node == y->left) + { // + node = y; + y = y->parent; // + } + node = y; + } + } // + + bool operator==(const rb_tree_iterator_base& rhs) { return node == rhs.node; } + bool operator!=(const rb_tree_iterator_base& rhs) { return node != rhs.node; } // +}; // + +template // +struct rb_tree_iterator :public rb_tree_iterator_base +{ + typedef rb_tree_traits tree_traits; + // + typedef typename tree_traits::value_type value_type; + typedef typename tree_traits::pointer pointer; // + typedef typename tree_traits::reference reference; + typedef typename tree_traits::base_ptr base_ptr; + typedef typename tree_traits::node_ptr node_ptr; // + // + typedef rb_tree_iterator iterator; + typedef rb_tree_const_iterator const_iterator; + typedef iterator self; + + using rb_tree_iterator_base::node; + // + // 构造函数 + rb_tree_iterator() {} // + rb_tree_iterator(base_ptr x) { node = x; } + rb_tree_iterator(node_ptr x) { node = x; } + rb_tree_iterator(const iterator& rhs) { node = rhs.node; } + rb_tree_iterator(const const_iterator& rhs) { node = rhs.node; } // + + // 重载操作符 + reference operator*() const { return node->get_node_ptr()->value; } + pointer operator->() const { return &(operator*()); } + + self& operator++() // + { // + this->inc(); // + return *this; + } + self operator++(int) + { + self tmp(*this); + this->inc(); // + return tmp; + } + self& operator--() + { + this->dec(); + return *this; // + } + self operator--(int) + { + self tmp(*this); // + this->dec(); + return tmp; + } +}; + +template +struct rb_tree_const_iterator :public rb_tree_iterator_base +{ // + typedef rb_tree_traits tree_traits; + + typedef typename tree_traits::value_type value_type; // + typedef typename tree_traits::const_pointer pointer; + typedef typename tree_traits::const_reference reference; + typedef typename tree_traits::base_ptr base_ptr; + typedef typename tree_traits::node_ptr node_ptr; + // + typedef rb_tree_iterator iterator; + typedef rb_tree_const_iterator const_iterator; + typedef const_iterator self; + // + using rb_tree_iterator_base::node; + + // 构造函数 + rb_tree_const_iterator() {} + rb_tree_const_iterator(base_ptr x) { node = x; } + rb_tree_const_iterator(node_ptr x) { node = x; } + rb_tree_const_iterator(const iterator& rhs) { node = rhs.node; } + rb_tree_const_iterator(const const_iterator& rhs) { node = rhs.node; } // + // + // 重载操作符 // + reference operator*() const { return node->get_node_ptr()->value; } + pointer operator->() const { return &(operator*()); } // + + self& operator++() + { + this->inc(); + return *this; + } // + self operator++(int) + { // + self tmp(*this); // + this->inc(); + return tmp; // + } // + self& operator--() + { // + this->dec(); + return *this; // + } + self operator--(int) + { + self tmp(*this); // + this->dec(); + return tmp; + } +}; // + +// tree algorithm // + +template // +NodePtr rb_tree_min(NodePtr x) noexcept +{ + while (x->left != nullptr) + x = x->left; + return x; +} // + +template // +NodePtr rb_tree_max(NodePtr x) noexcept +{ // + while (x->right != nullptr) + x = x->right; // + return x; // +} // + +template // +bool rb_tree_is_lchild(NodePtr node) noexcept +{ // + return node == node->parent->left; +} // + +template +bool rb_tree_is_red(NodePtr node) noexcept // +{ + return node->color == rb_tree_red; +} + +template +void rb_tree_set_black(NodePtr& node) noexcept // +{ // + node->color = rb_tree_black; +} // + +template // +void rb_tree_set_red(NodePtr& node) noexcept // +{ + node->color = rb_tree_red; +} // + +template // +NodePtr rb_tree_next(NodePtr node) noexcept +{ + if (node->right != nullptr) + return rb_tree_min(node->right); // + while (!rb_tree_is_lchild(node)) + node = node->parent; // + return node->parent; +} // + +/*---------------------------------------*\ // +| p p | +| / \ / \ | +| x d rotate left y d | +| / \ ===========> / \ | +| a y x c | +| / \ / \ | // +| b c a b | +\*---------------------------------------*/ // +// 左旋，参数一为左旋点，参数二为根节点 +template +void rb_tree_rotate_left(NodePtr x, NodePtr& root) noexcept +{ // + auto y = x->right; // y 为 x 的右子节点 // + x->right = y->left; // + if (y->left != nullptr) // + y->left->parent = x; + y->parent = x->parent; + // + if (x == root) + { // 如果 x 为根节点，让 y 顶替 x 成为根节点 + root = y; // + } + else if (rb_tree_is_lchild(x)) // + { // 如果 x 是左子节点 // + x->parent->left = y; + } // + else + { // 如果 x 是右子节点 // + x->parent->right = y; + } // + // 调整 x 与 y 的关系 + y->left = x; // + x->parent = y; +} // + +/*----------------------------------------*\ +| p p | +| / \ / \ | // +| d x rotate right d y | +| / \ ===========> / \ | +| y a b x | +| / \ / \ | // +| b c c a | // +\*----------------------------------------*/ +// 右旋，参数一为右旋点，参数二为根节点 +template +void rb_tree_rotate_right(NodePtr x, NodePtr& root) noexcept +{ // + auto y = x->left; + x->left = y->right; + if (y->right) + y->right->parent = x; // + y->parent = x->parent; + // + if (x == root) + { // 如果 x 为根节点，让 y 顶替 x 成为根节点 // + root = y; + } // + else if (rb_tree_is_lchild(x)) + { // 如果 x 是右子节点 + x->parent->left = y; + } + else + { // 如果 x 是左子节点 + x->parent->right = y; + } + // 调整 x 与 y 的关系 + y->right = x; + x->parent = y; // +} + +// 插入节点后使 rb tree 重新平衡，参数一为新增节点，参数二为根节点 +// +// case 1: 新增节点位于根节点，令新增节点为黑 // +// case 2: 新增节点的父节点为黑，没有破坏平衡，直接返回 +// case 3: 父节点和叔叔节点都为红，令父节点和叔叔节点为黑，祖父节点为红， +// 然后令祖父节点为当前节点，继续处理 +// case 4: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为右（左）孩子， // +// 让父节点成为当前节点，再以当前节点为支点左（右）旋 +// case 5: 父节点为红，叔叔节点为 NIL 或黑色，父节点为左（右）孩子，当前节点为左（右）孩子， // +// 让父节点变为黑色，祖父节点变为红色，以祖父节点为支点右（左）旋 +// +// 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 +// http://blog.csdn.net/v_JULY_v/article/details/6109153 +template +void rb_tree_insert_rebalance(NodePtr x, NodePtr& root) noexcept +{ // + rb_tree_set_red(x); // 新增节点为红色 // + while (x != root && rb_tree_is_red(x->parent)) + { // + if (rb_tree_is_lchild(x->parent)) + { // 如果父节点是左子节点 // + auto uncle = x->parent->parent->right; + if (uncle != nullptr && rb_tree_is_red(uncle)) // + { // case 3: 父节点和叔叔节点都为红 + rb_tree_set_black(x->parent); // + rb_tree_set_black(uncle); + x = x->parent->parent; // + rb_tree_set_red(x); + } + else + { // 无叔叔节点或叔叔节点为黑 // + if (!rb_tree_is_lchild(x)) + { // case 4: 当前节点 x 为右子节点 + x = x->parent; + rb_tree_rotate_left(x, root); // + } + // 都转换成 case 5： 当前节点为左子节点 // + rb_tree_set_black(x->parent); + rb_tree_set_red(x->parent->parent); + rb_tree_rotate_right(x->parent->parent, root); + break; + } + } // + else // 如果父节点是右子节点，对称处理 + { + auto uncle = x->parent->parent->left; // + if (uncle != nullptr && rb_tree_is_red(uncle)) // + { // case 3: 父节点和叔叔节点都为红 + rb_tree_set_black(x->parent); // + rb_tree_set_black(uncle); + x = x->parent->parent; // + rb_tree_set_red(x); // + // 此时祖父节点为红，可能会破坏红黑树的性质，令当前节点为祖父节点，继续处理 + } + else // + { // 无叔叔节点或叔叔节点为黑 + if (rb_tree_is_lchild(x)) + { // case 4: 当前节点 x 为左子节点 // + x = x->parent; + rb_tree_rotate_right(x, root); + } + // 都转换成 case 5： 当前节点为左子节点 + rb_tree_set_black(x->parent); + rb_tree_set_red(x->parent->parent); // + rb_tree_rotate_left(x->parent->parent, root); + break; + } // + } + } // + rb_tree_set_black(root); // 根节点永远为黑 +} + +// 删除节点后使 rb tree 重新平衡，参数一为要删除的节点，参数二为根节点，参数三为最小节点，参数四为最大节点 // +// +// 参考博客: http://blog.csdn.net/v_JULY_v/article/details/6105630 // +// http://blog.csdn.net/v_JULY_v/article/details/6109153 +template // +NodePtr rb_tree_erase_rebalance(NodePtr z, NodePtr& root, NodePtr& leftmost, NodePtr& rightmost) +{ // + // y 是可能的替换节点，指向最终要删除的节点 + auto y = (z->left == nullptr || z->right == nullptr) ? z : rb_tree_next(z); + // x 是 y 的一个独子节点或 NIL 节点 // + auto x = y->left != nullptr ? y->left : y->right; + // xp 为 x 的父节点 + NodePtr xp = nullptr; + + // y != z 说明 z 有两个非空子节点，此时 y 指向 z 右子树的最左节点，x 指向 y 的右子节点。 // + // 用 y 顶替 z 的位置，用 x 顶替 y 的位置，最后用 y 指向 z + if (y != z) + { + z->left->parent = y; // + y->left = z->left; + + // 如果 y 不是 z 的右子节点，那么 z 的右子节点一定有左孩子 // + if (y != z->right) + { // x 替换 y 的位置 + xp = y->parent; // + if (x != nullptr) + x->parent = y->parent; // + + y->parent->left = x; + y->right = z->right; // + z->right->parent = y; + } + else + { + xp = y; // + } + + // 连接 y 与 z 的父节点 + if (root == z) // + root = y; // + else if (rb_tree_is_lchild(z)) + z->parent->left = y; + else + z->parent->right = y; + y->parent = z->parent; + mystl::swap(y->color, z->color); // + y = z; // + } + // y == z 说明 z 至多只有一个孩子 + else // + { + xp = y->parent; + if (x) + x->parent = y->parent; + // + // 连接 x 与 z 的父节点 + if (root == z) // + root = x; + else if (rb_tree_is_lchild(z)) + z->parent->left = x; + else // + z->parent->right = x; + // + // 此时 z 有可能是最左节点或最右节点，更新数据 + if (leftmost == z) // + leftmost = x == nullptr ? xp : rb_tree_min(x); + if (rightmost == z) + rightmost = x == nullptr ? xp : rb_tree_max(x); + } + // + // 此时，y 指向要删除的节点，x 为替代节点，从 x 节点开始调整。 + // 如果删除的节点为红色，树的性质没有被破坏，否则按照以下情况调整（x 为左子节点为例）： + // case 1: 兄弟节点为红色，令父节点为红，兄弟节点为黑，进行左（右）旋，继续处理 // + // case 2: 兄弟节点为黑色，且两个子节点都为黑色或 NIL，令兄弟节点为红，父节点成为当前节点，继续处理 + // case 3: 兄弟节点为黑色，左子节点为红色或 NIL，右子节点为黑色或 NIL， // + // 令兄弟节点为红，兄弟节点的左子节点为黑，以兄弟节点为支点右（左）旋，继续处理 + // case 4: 兄弟节点为黑色，右子节点为红色，令兄弟节点为父节点的颜色，父节点为黑色，兄弟节点的右子节点 + // 为黑色，以父节点为支点左（右）旋，树的性质调整完成，算法结束 + if (!rb_tree_is_red(y)) // + { // x 为黑色时，调整，否则直接将 x 变为黑色即可 + while (x != root && (x == nullptr || !rb_tree_is_red(x))) + { + if (x == xp->left) // + { // 如果 x 为左子节点 + auto brother = xp->right; // + if (rb_tree_is_red(brother)) + { // case 1 // + rb_tree_set_black(brother); + rb_tree_set_red(xp); + rb_tree_rotate_left(xp, root); // + brother = xp->right; // + } + // case 1 转为为了 case 2、3、4 中的一种 // + if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && // + (brother->right == nullptr || !rb_tree_is_red(brother->right))) // + { // case 2 + rb_tree_set_red(brother); // + x = xp; + xp = xp->parent; // + } + else + { + if (brother->right == nullptr || !rb_tree_is_red(brother->right)) // + { // case 3 + if (brother->left != nullptr) // + rb_tree_set_black(brother->left); + rb_tree_set_red(brother); + rb_tree_rotate_right(brother, root); + brother = xp->right; + } + // 转为 case 4 // + brother->color = xp->color; + rb_tree_set_black(xp); + if (brother->right != nullptr) + rb_tree_set_black(brother->right); // + rb_tree_rotate_left(xp, root); + break; + } + } // + else // x 为右子节点，对称处理 // + { // + auto brother = xp->left; + if (rb_tree_is_red(brother)) // + { // case 1 + rb_tree_set_black(brother); // + rb_tree_set_red(xp); + rb_tree_rotate_right(xp, root); // + brother = xp->left; + } // + if ((brother->left == nullptr || !rb_tree_is_red(brother->left)) && + (brother->right == nullptr || !rb_tree_is_red(brother->right))) + { // case 2 + rb_tree_set_red(brother); // + x = xp; + xp = xp->parent; // + } + else // + { + if (brother->left == nullptr || !rb_tree_is_red(brother->left)) // + { // case 3 + if (brother->right != nullptr) + rb_tree_set_black(brother->right); + rb_tree_set_red(brother); // + rb_tree_rotate_left(brother, root); + brother = xp->left; + } + // 转为 case 4 // + brother->color = xp->color; // + rb_tree_set_black(xp); // + if (brother->left != nullptr) + rb_tree_set_black(brother->left); // + rb_tree_rotate_right(xp, root); + break; + } + } // + } + if (x != nullptr) // + rb_tree_set_black(x); + } + return y; +} + +// 模板类 rb_tree // +// 参数一代表数据类型，参数二代表键值比较类型 +template +class rb_tree +{ // +public: + // rb_tree 的嵌套型别定义 + // + typedef rb_tree_traits tree_traits; // + typedef rb_tree_value_traits value_traits; + // + typedef typename tree_traits::base_type base_type; + typedef typename tree_traits::base_ptr base_ptr; // + typedef typename tree_traits::node_type node_type; + typedef typename tree_traits::node_ptr node_ptr; + typedef typename tree_traits::key_type key_type; + typedef typename tree_traits::mapped_type mapped_type; // + typedef typename tree_traits::value_type value_type; + typedef Compare key_compare; // + + typedef mystl::allocator allocator_type; // + typedef mystl::allocator data_allocator; + typedef mystl::allocator base_allocator; // + typedef mystl::allocator node_allocator; + + typedef typename allocator_type::pointer pointer; + typedef typename allocator_type::const_pointer const_pointer; + typedef typename allocator_type::reference reference; // + typedef typename allocator_type::const_reference const_reference; // + typedef typename allocator_type::size_type size_type; + typedef typename allocator_type::difference_type difference_type; // + + typedef rb_tree_iterator iterator; // + typedef rb_tree_const_iterator const_iterator; + typedef mystl::reverse_iterator reverse_iterator; + typedef mystl::reverse_iterator const_reverse_iterator; + + allocator_type get_allocator() const { return node_allocator(); } + key_compare key_comp() const { return key_comp_; } + +private: // + // 用以下三个数据表现 rb tree + base_ptr header_; // 特殊节点，与根节点互为对方的父节点 // + size_type node_count_; // 节点数 + key_compare key_comp_; // 节点键值比较的准则 + +private: + // 以下三个函数用于取得根节点，最小节点和最大节点 + base_ptr& root() const { return header_->parent; } // + base_ptr& leftmost() const { return header_->left; } + base_ptr& rightmost() const { return header_->right; } // + +public: // + // 构造、复制、析构函数 + rb_tree() { rb_tree_init(); } // + + rb_tree(const rb_tree& rhs); // + rb_tree(rb_tree&& rhs) noexcept; + + rb_tree& operator=(const rb_tree& rhs); + rb_tree& operator=(rb_tree&& rhs); // + + ~rb_tree() { clear(); } + +public: + // 迭代器相关操作 + // + iterator begin() noexcept + { return leftmost(); } // + const_iterator begin() const noexcept + { return leftmost(); } + iterator end() noexcept + { return header_; } // + const_iterator end() const noexcept + { return header_; } // + + reverse_iterator rbegin() noexcept // + { return reverse_iterator(end()); } + const_reverse_iterator rbegin() const noexcept // + { return const_reverse_iterator(end()); } + reverse_iterator rend() noexcept + { return reverse_iterator(begin()); } // + const_reverse_iterator rend() const noexcept + { return const_reverse_iterator(begin()); } + // + const_iterator cbegin() const noexcept + { return begin(); } + const_iterator cend() const noexcept // + { return end(); } + const_reverse_iterator crbegin() const noexcept + { return rbegin(); } // + const_reverse_iterator crend() const noexcept + { return rend(); } // + // + // 容量相关操作 + + bool empty() const noexcept { return node_count_ == 0; } // + size_type size() const noexcept { return node_count_; } // + size_type max_size() const noexcept { return static_cast(-1); } + + // 插入删除相关操作 // + + // emplace // + + template // + iterator emplace_multi(Args&& ...args); + // + template + mystl::pair emplace_unique(Args&& ...args); // + + template + iterator emplace_multi_use_hint(iterator hint, Args&& ...args); + // + template + iterator emplace_unique_use_hint(iterator hint, Args&& ...args); + + // insert // + // + iterator insert_multi(const value_type& value); + iterator insert_multi(value_type&& value) + { // + return emplace_multi(mystl::move(value)); + } + + iterator insert_multi(iterator hint, const value_type& value) // + { + return emplace_multi_use_hint(hint, value); // + } + iterator insert_multi(iterator hint, value_type&& value) // + { // + return emplace_multi_use_hint(hint, mystl::move(value)); + } + // + template + void insert_multi(InputIterator first, InputIterator last) + { + size_type n = mystl::distance(first, last); + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); + for (; n > 0; --n, ++first) + insert_multi(end(), *first); + } + + mystl::pair insert_unique(const value_type& value); + mystl::pair insert_unique(value_type&& value) + { + return emplace_unique(mystl::move(value)); + } + // + iterator insert_unique(iterator hint, const value_type& value) + { + return emplace_unique_use_hint(hint, value); + } + iterator insert_unique(iterator hint, value_type&& value) // + { + return emplace_unique_use_hint(hint, mystl::move(value)); + } + // + template + void insert_unique(InputIterator first, InputIterator last) + { + size_type n = mystl::distance(first, last); + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - n, "rb_tree's size too big"); + for (; n > 0; --n, ++first) // + insert_unique(end(), *first); + } // + // + // erase + + iterator erase(iterator hint); // + + size_type erase_multi(const key_type& key); // + size_type erase_unique(const key_type& key); + // + void erase(iterator first, iterator last); + + void clear(); + + // rb_tree 相关操作 + // + iterator find(const key_type& key); + const_iterator find(const key_type& key) const; // + + size_type count_multi(const key_type& key) const + { // + auto p = equal_range_multi(key); + return static_cast(mystl::distance(p.first, p.second)); + } // + size_type count_unique(const key_type& key) const + { // + return find(key) != end() ? 1 : 0; + } + + iterator lower_bound(const key_type& key); // + const_iterator lower_bound(const key_type& key) const; + + iterator upper_bound(const key_type& key); + const_iterator upper_bound(const key_type& key) const; + + mystl::pair // + equal_range_multi(const key_type& key) + { + return mystl::pair(lower_bound(key), upper_bound(key)); + } // + mystl::pair + equal_range_multi(const key_type& key) const // + { + return mystl::pair(lower_bound(key), upper_bound(key)); + } // + + mystl::pair + equal_range_unique(const key_type& key) + { + iterator it = find(key); // + auto next = it; + return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); + } + mystl::pair // + equal_range_unique(const key_type& key) const + { + const_iterator it = find(key); + auto next = it; // + return it == end() ? mystl::make_pair(it, it) : mystl::make_pair(it, ++next); + } // + + void swap(rb_tree& rhs) noexcept; + +private: + + // node related // + template + node_ptr create_node(Args&&... args); + node_ptr clone_node(base_ptr x); + void destroy_node(node_ptr p); // + + // init / reset + void rb_tree_init(); + void reset(); // + // + // get insert pos // + mystl::pair + get_insert_multi_pos(const key_type& key); + mystl::pair, bool> + get_insert_unique_pos(const key_type& key); + + // insert value / insert node // + iterator insert_value_at(base_ptr x, const value_type& value, bool add_to_left); + iterator insert_node_at(base_ptr x, node_ptr node, bool add_to_left); // + + // insert use hint // + iterator insert_multi_use_hint(iterator hint, key_type key, node_ptr node); // + iterator insert_unique_use_hint(iterator hint, key_type key, node_ptr node); + + // copy tree / erase tree // + base_ptr copy_from(base_ptr x, base_ptr p); + void erase_since(base_ptr x); +}; + // +/*****************************************************************************************/ + // +// 复制构造函数 +template // +rb_tree:: // +rb_tree(const rb_tree& rhs) // +{ + rb_tree_init(); // + if (rhs.node_count_ != 0) + { // + root() = copy_from(rhs.root(), header_); // + leftmost() = rb_tree_min(root()); + rightmost() = rb_tree_max(root()); + } + node_count_ = rhs.node_count_; + key_comp_ = rhs.key_comp_; +} // + +// 移动构造函数 +template // +rb_tree:: +rb_tree(rb_tree&& rhs) noexcept + :header_(mystl::move(rhs.header_)), // + node_count_(rhs.node_count_), + key_comp_(rhs.key_comp_) +{ + rhs.reset(); +} // + +// 复制赋值操作符 // +template +rb_tree& +rb_tree:: +operator=(const rb_tree& rhs) +{ + if (this != &rhs) // + { + clear(); + + if (rhs.node_count_ != 0) + { // + root() = copy_from(rhs.root(), header_); + leftmost() = rb_tree_min(root()); + rightmost() = rb_tree_max(root()); // + } + + node_count_ = rhs.node_count_; // + key_comp_ = rhs.key_comp_; // + } + return *this; // +} + // +// 移动赋值操作符 // +template +rb_tree& +rb_tree:: // +operator=(rb_tree&& rhs) +{ + clear(); + header_ = mystl::move(rhs.header_); + node_count_ = rhs.node_count_; + key_comp_ = rhs.key_comp_; + rhs.reset(); + return *this; // +} // + +// 就地插入元素，键值允许重复 +template +template +typename rb_tree::iterator +rb_tree:: +emplace_multi(Args&& ...args) // +{ + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); // + node_ptr np = create_node(mystl::forward(args)...); + auto res = get_insert_multi_pos(value_traits::get_key(np->value)); + return insert_node_at(res.first, np, res.second); +} + +// 就地插入元素，键值不允许重复 // +template // +template // +mystl::pair::iterator, bool> +rb_tree:: // +emplace_unique(Args&& ...args) +{ + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); + node_ptr np = create_node(mystl::forward(args)...); // + auto res = get_insert_unique_pos(value_traits::get_key(np->value)); + if (res.second) // + { // 插入成功 + return mystl::make_pair(insert_node_at(res.first.first, np, res.first.second), true); // + } + destroy_node(np); // + return mystl::make_pair(iterator(res.first.first), false); +} // + +// 就地插入元素，键值允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 +template +template +typename rb_tree::iterator // +rb_tree:: +emplace_multi_use_hint(iterator hint, Args&& ...args) +{ // + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); + node_ptr np = create_node(mystl::forward(args)...); // + if (node_count_ == 0) + { // + return insert_node_at(header_, np, true); + } + key_type key = value_traits::get_key(np->value); + if (hint == begin()) // + { // 位于 begin 处 // + if (key_comp_(key, value_traits::get_key(*hint))) + { + return insert_node_at(hint.node, np, true); // + } + else // + { + auto pos = get_insert_multi_pos(key); // + return insert_node_at(pos.first, np, pos.second); + } + } + else if (hint == end()) // + { // 位于 end 处 // + if (!key_comp_(key, value_traits::get_key(rightmost()->get_node_ptr()->value))) + { + return insert_node_at(rightmost(), np, false); + } + else + { + auto pos = get_insert_multi_pos(key); + return insert_node_at(pos.first, np, pos.second); + } + } + return insert_multi_use_hint(hint, key, np); // +} + +// 就地插入元素，键值不允许重复，当 hint 位置与插入位置接近时，插入操作的时间复杂度可以降低 +template // +template +typename rb_tree::iterator +rb_tree:: +emplace_unique_use_hint(iterator hint, Args&& ...args) +{ + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); // + node_ptr np = create_node(mystl::forward(args)...); + if (node_count_ == 0) + { + return insert_node_at(header_, np, true); + } // + key_type key = value_traits::get_key(np->value); // + if (hint == begin()) + { // 位于 begin 处 + if (key_comp_(key, value_traits::get_key(*hint))) // + { + return insert_node_at(hint.node, np, true); + } // + else + { + auto pos = get_insert_unique_pos(key); // + if (!pos.second) + { + destroy_node(np); // + return pos.first.first; + } // + return insert_node_at(pos.first.first, np, pos.first.second); + } + } + else if (hint == end()) // + { // 位于 end 处 + if (key_comp_(value_traits::get_key(rightmost()->get_node_ptr()->value), key)) + { + return insert_node_at(rightmost(), np, false); + } + else // + { + auto pos = get_insert_unique_pos(key); + if (!pos.second) + { // + destroy_node(np); + return pos.first.first; + } + return insert_node_at(pos.first.first, np, pos.first.second); // + } // + } // + return insert_unique_use_hint(hint, key, np); +} // + +// 插入元素，节点键值允许重复 // +template // +typename rb_tree::iterator // +rb_tree:: +insert_multi(const value_type& value) // +{ + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); // + auto res = get_insert_multi_pos(value_traits::get_key(value)); // + return insert_value_at(res.first, value, res.second); +} + // +// 插入新值，节点键值不允许重复，返回一个 pair，若插入成功，pair 的第二参数为 true，否则为 false // +template +mystl::pair::iterator, bool> +rb_tree:: +insert_unique(const value_type& value) +{ + THROW_LENGTH_ERROR_IF(node_count_ > max_size() - 1, "rb_tree's size too big"); + auto res = get_insert_unique_pos(value_traits::get_key(value)); + if (res.second) + { // 插入成功 // + return mystl::make_pair(insert_value_at(res.first.first, value, res.first.second), true); // + } // + return mystl::make_pair(res.first.first, false); +} + +// 删除 hint 位置的节点 // +template +typename rb_tree::iterator // +rb_tree:: +erase(iterator hint) +{ // + auto node = hint.node->get_node_ptr(); + iterator next(node); + ++next; + + rb_tree_erase_rebalance(hint.node, root(), leftmost(), rightmost()); // + destroy_node(node); // + --node_count_; + return next; +} // + +// 删除键值等于 key 的元素，返回删除的个数 // +template +typename rb_tree::size_type +rb_tree:: +erase_multi(const key_type& key) // +{ + auto p = equal_range_multi(key); + size_type n = mystl::distance(p.first, p.second); // + erase(p.first, p.second); + return n; +} // + +// 删除键值等于 key 的元素，返回删除的个数 // +template // +typename rb_tree::size_type +rb_tree:: +erase_unique(const key_type& key) // +{ + auto it = find(key); + if (it != end()) // + { + erase(it); + return 1; // + } + return 0; +} // + +// 删除[first, last)区间内的元素 +template // +void rb_tree:: // +erase(iterator first, iterator last) +{ // + if (first == begin() && last == end()) // + { + clear(); // + } + else + { // + while (first != last) + erase(first++); + } +} + +// 清空 rb tree +template +void rb_tree:: +clear() // +{ + if (node_count_ != 0) // + { // + erase_since(root()); // + leftmost() = header_; + root() = nullptr; // + rightmost() = header_; + node_count_ = 0; // + } +} // + +// 查找键值为 k 的节点，返回指向它的迭代器 // +template +typename rb_tree::iterator +rb_tree:: // +find(const key_type& key) +{ + auto y = header_; // 最后一个不小于 key 的节点 // + auto x = root(); + while (x != nullptr) + { + if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) + { // key 小于等于 x 键值，向左走 // + y = x, x = x->left; + } + else + { // key 大于 x 键值，向右走 + x = x->right; // + } + } // + iterator j = iterator(y); + return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; +} // + // +template +typename rb_tree::const_iterator +rb_tree:: +find(const key_type& key) const // +{ + auto y = header_; // 最后一个不小于 key 的节点 + auto x = root(); + while (x != nullptr) // + { + if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) + { // key 小于等于 x 键值，向左走 + y = x, x = x->left; + } + else // + { // key 大于 x 键值，向右走 + x = x->right; + } + } + const_iterator j = const_iterator(y); + return (j == end() || key_comp_(key, value_traits::get_key(*j))) ? end() : j; +} + +// 键值不小于 key 的第一个位置 +template // +typename rb_tree::iterator +rb_tree:: // +lower_bound(const key_type& key) +{ + auto y = header_; + auto x = root(); + while (x != nullptr) + { // + if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) + { // key <= x // + y = x, x = x->left; + } + else + { // + x = x->right; // + } + } + return iterator(y); +} + // +template +typename rb_tree::const_iterator +rb_tree:: +lower_bound(const key_type& key) const // +{ + auto y = header_; + auto x = root(); + while (x != nullptr) + { + if (!key_comp_(value_traits::get_key(x->get_node_ptr()->value), key)) + { // key <= x + y = x, x = x->left; // + } + else + { // + x = x->right; + } + } // + return const_iterator(y); +} + +// 键值不小于 key 的最后一个位置 +template +typename rb_tree::iterator // +rb_tree:: +upper_bound(const key_type& key) +{ + auto y = header_; // + auto x = root(); + while (x != nullptr) // + { + if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) // + { // key < x + y = x, x = x->left; // + } + else // + { + x = x->right; + } + } // + return iterator(y); +} + +template +typename rb_tree::const_iterator +rb_tree:: +upper_bound(const key_type& key) const +{ + auto y = header_; + auto x = root(); // + while (x != nullptr) + { + if (key_comp_(key, value_traits::get_key(x->get_node_ptr()->value))) + { // key < x + y = x, x = x->left; + } + else + { // + x = x->right; + } // + } + return const_iterator(y); // +} + // +// 交换 rb tree +template +void rb_tree:: +swap(rb_tree& rhs) noexcept +{ + if (this != &rhs) // + { + mystl::swap(header_, rhs.header_); // + mystl::swap(node_count_, rhs.node_count_); + mystl::swap(key_comp_, rhs.key_comp_); + } // +} // + +/*****************************************************************************************/ +// helper function + // +// 创建一个结点 +template // +template +typename rb_tree::node_ptr +rb_tree:: +create_node(Args&&... args) +{ + auto tmp = node_allocator::allocate(1); // + try + { + data_allocator::construct(mystl::address_of(tmp->value), mystl::forward(args)...); + tmp->left = nullptr; // + tmp->right = nullptr; // + tmp->parent = nullptr; + } + catch (...) + { + node_allocator::deallocate(tmp); // + throw; + } // + return tmp; +} // + +// 复制一个结点 +template +typename rb_tree::node_ptr +rb_tree:: +clone_node(base_ptr x) // +{ + node_ptr tmp = create_node(x->get_node_ptr()->value); // + tmp->color = x->color; + tmp->left = nullptr; + tmp->right = nullptr; + return tmp; +} // + +// 销毁一个结点 +template +void rb_tree:: +destroy_node(node_ptr p) // +{ + data_allocator::destroy(&p->value); // + node_allocator::deallocate(p); +} // + // +// 初始化容器 +template +void rb_tree:: +rb_tree_init() +{ + header_ = base_allocator::allocate(1); + header_->color = rb_tree_red; // header_ 节点颜色为红，与 root 区分 // + root() = nullptr; + leftmost() = header_; + rightmost() = header_; + node_count_ = 0; // +} + +// reset 函数 +template // +void rb_tree::reset() +{ // + header_ = nullptr; + node_count_ = 0; // +} // + +// get_insert_multi_pos 函数 // +template +mystl::pair::base_ptr, bool> +rb_tree::get_insert_multi_pos(const key_type& key) // +{ + auto x = root(); // + auto y = header_; // + bool add_to_left = true; + while (x != nullptr) + { + y = x; + add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); + x = add_to_left ? x->left : x->right; // + } // + return mystl::make_pair(y, add_to_left); +} // + +// get_insert_unique_pos 函数 +template // +mystl::pair::base_ptr, bool>, bool> +rb_tree::get_insert_unique_pos(const key_type& key) +{ // 返回一个 pair，第一个值为一个 pair，包含插入点的父节点和一个 bool 表示是否在左边插入， // + // 第二个值为一个 bool，表示是否插入成功 + auto x = root(); // + auto y = header_; // + bool add_to_left = true; // 树为空时也在 header_ 左边插入 // + while (x != nullptr) + { + y = x; + add_to_left = key_comp_(key, value_traits::get_key(x->get_node_ptr()->value)); + x = add_to_left ? x->left : x->right; + } + iterator j = iterator(y); // 此时 y 为插入点的父节点 + if (add_to_left) // + { + if (y == header_ || j == begin()) + { // 如果树为空树或插入点在最左节点处，肯定可以插入新的节点 + return mystl::make_pair(mystl::make_pair(y, true), true); // + } + else // + { // 否则，如果存在重复节点，那么 --j 就是重复的值 + --j; + } + } // + if (key_comp_(value_traits::get_key(*j), key)) + { // 表明新节点没有重复 // + return mystl::make_pair(mystl::make_pair(y, add_to_left), true); + } + // 进行至此，表示新节点与现有节点键值重复 // + return mystl::make_pair(mystl::make_pair(y, add_to_left), false); // +} + +// insert_value_at 函数 +// x 为插入点的父节点， value 为要插入的值，add_to_left 表示是否在左边插入 +template +typename rb_tree::iterator +rb_tree:: +insert_value_at(base_ptr x, const value_type& value, bool add_to_left) // +{ + node_ptr node = create_node(value); // + node->parent = x; // + auto base_node = node->get_base_ptr(); // + if (x == header_) + { // + root() = base_node; + leftmost() = base_node; // + rightmost() = base_node; + } + else if (add_to_left) // + { // + x->left = base_node; + if (leftmost() == x) + leftmost() = base_node; + } // + else + { // + x->right = base_node; + if (rightmost() == x) + rightmost() = base_node; // + } + rb_tree_insert_rebalance(base_node, root()); + ++node_count_; // + return iterator(node); +} // + +// 在 x 节点处插入新的节点 // +// x 为插入点的父节点， node 为要插入的节点，add_to_left 表示是否在左边插入 +template // +typename rb_tree::iterator +rb_tree:: // +insert_node_at(base_ptr x, node_ptr node, bool add_to_left) +{ + node->parent = x; + auto base_node = node->get_base_ptr(); // + if (x == header_) + { // + root() = base_node; // + leftmost() = base_node; // + rightmost() = base_node; + } + else if (add_to_left) + { + x->left = base_node; + if (leftmost() == x) // + leftmost() = base_node; + } // + else + { + x->right = base_node; + if (rightmost() == x) + rightmost() = base_node; + } // + rb_tree_insert_rebalance(base_node, root()); + ++node_count_; + return iterator(node); +} + +// 插入元素，键值允许重复，使用 hint // +template // +typename rb_tree::iterator +rb_tree:: +insert_multi_use_hint(iterator hint, key_type key, node_ptr node) // +{ + // 在 hint 附近寻找可插入的位置 // + auto np = hint.node; + auto before = hint; + --before; // + auto bnp = before.node; + if (!key_comp_(key, value_traits::get_key(*before)) && + !key_comp_(value_traits::get_key(*hint), key)) // + { // before <= node <= hint + if (bnp->right == nullptr) // + { + return insert_node_at(bnp, node, false); + } + else if (np->left == nullptr) + { + return insert_node_at(np, node, true); // + } + } + auto pos = get_insert_multi_pos(key); + return insert_node_at(pos.first, node, pos.second); // +} + // +// 插入元素，键值不允许重复，使用 hint // +template // +typename rb_tree::iterator +rb_tree:: +insert_unique_use_hint(iterator hint, key_type key, node_ptr node) +{ + // 在 hint 附近寻找可插入的位置 + auto np = hint.node; + auto before = hint; + --before; // + auto bnp = before.node; + if (key_comp_(value_traits::get_key(*before), key) && + key_comp_(key, value_traits::get_key(*hint))) // + { // before < node < hint // + if (bnp->right == nullptr) + { + return insert_node_at(bnp, node, false); + } // + else if (np->left == nullptr) + { // + return insert_node_at(np, node, true); + } // + } + auto pos = get_insert_unique_pos(key); // + if (!pos.second) // + { // + destroy_node(node); + return pos.first.first; // + } + return insert_node_at(pos.first.first, node, pos.first.second); +} // + +// copy_from 函数 +// 递归复制一颗树，节点从 x 开始，p 为 x 的父节点 // +template +typename rb_tree::base_ptr +rb_tree::copy_from(base_ptr x, base_ptr p) // +{ // + auto top = clone_node(x); + top->parent = p; // + try + { + if (x->right) + top->right = copy_from(x->right, top); + p = top; // + x = x->left; + while (x != nullptr) + { + auto y = clone_node(x); // + p->left = y; // + y->parent = p; + if (x->right) + y->right = copy_from(x->right, y); + p = y; // + x = x->left; + } + } + catch (...) + { + erase_since(top); + throw; + } // + return top; +} + // +// erase_since 函数 +// 从 x 节点开始删除该节点及其子树 +template +void rb_tree:: +erase_since(base_ptr x) // +{ + while (x != nullptr) + { + erase_since(x->right); + auto y = x->left; // + destroy_node(x->get_node_ptr()); // + x = y; + } +} + +// 重载比较操作符 +template // +bool operator==(const rb_tree& lhs, const rb_tree& rhs) +{ + return lhs.size() == rhs.size() && mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); +} // + +template // +bool operator<(const rb_tree& lhs, const rb_tree& rhs) +{ + return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); // +} + +template // +bool operator!=(const rb_tree& lhs, const rb_tree& rhs) +{ + return !(lhs == rhs); +} // + +template +bool operator>(const rb_tree& lhs, const rb_tree& rhs) +{ // + return rhs < lhs; +} + // +template +bool operator<=(const rb_tree& lhs, const rb_tree& rhs) +{ + return !(rhs < lhs); +} + +template +bool operator>=(const rb_tree& lhs, const rb_tree& rhs) +{ // + return !(lhs < rhs); // +} // + +// 重载 mystl 的 swap // +template +void swap(rb_tree& lhs, rb_tree& rhs) noexcept // +{ + lhs.swap(rhs); +} + // +} // namespace mystl // +#endif // !MYTINYSTL_RB_TREE_H_ +