1e0dfd4d5Shanjiezhou // Copyright 2017-2018 By tickdream125@hotmail.com. 2e0dfd4d5Shanjiezhou // 3e0dfd4d5Shanjiezhou // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or 4e0dfd4d5Shanjiezhou // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 5e0dfd4d5Shanjiezhou // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your 6e0dfd4d5Shanjiezhou // option. This file may not be copied, modified, or distributed 7e0dfd4d5Shanjiezhou // except according to those terms. 8e0dfd4d5Shanjiezhou 9e0dfd4d5Shanjiezhou // This file brings from https://github.com/tickbh/rbtree-rs/blob/master/src/lib.rs 10e0dfd4d5Shanjiezhou // Thanks to the author tickbh 11e0dfd4d5Shanjiezhou 12e0dfd4d5Shanjiezhou #![allow(dead_code)] 13e0dfd4d5Shanjiezhou 14e0dfd4d5Shanjiezhou use core::cmp::Ord; 15e0dfd4d5Shanjiezhou use core::cmp::Ordering; 1678bf93f0SYJwu2023 use core::fmt::{self, Debug}; 1778bf93f0SYJwu2023 use core::iter::{FromIterator, IntoIterator}; 18e0dfd4d5Shanjiezhou use core::marker; 19e0dfd4d5Shanjiezhou use core::mem; 20e0dfd4d5Shanjiezhou use core::ops::Index; 2178bf93f0SYJwu2023 use core::ptr; 22e0dfd4d5Shanjiezhou 23e0dfd4d5Shanjiezhou use alloc::boxed::Box; 24e0dfd4d5Shanjiezhou 25e0dfd4d5Shanjiezhou use crate::kdebug; 26e0dfd4d5Shanjiezhou 27e0dfd4d5Shanjiezhou #[derive(Debug, Copy, Clone, PartialEq, Eq)] 28e0dfd4d5Shanjiezhou enum Color { 29e0dfd4d5Shanjiezhou Red, 30e0dfd4d5Shanjiezhou Black, 31e0dfd4d5Shanjiezhou } 32e0dfd4d5Shanjiezhou 33e0dfd4d5Shanjiezhou /*****************RBTreeNode***************************/ 34e0dfd4d5Shanjiezhou struct RBTreeNode<K: Ord, V> { 35e0dfd4d5Shanjiezhou color: Color, 36e0dfd4d5Shanjiezhou left: NodePtr<K, V>, 37e0dfd4d5Shanjiezhou right: NodePtr<K, V>, 38e0dfd4d5Shanjiezhou parent: NodePtr<K, V>, 39e0dfd4d5Shanjiezhou key: K, 40e0dfd4d5Shanjiezhou value: V, 41e0dfd4d5Shanjiezhou } 42e0dfd4d5Shanjiezhou 43e0dfd4d5Shanjiezhou impl<K: Ord, V> RBTreeNode<K, V> { 44e0dfd4d5Shanjiezhou #[inline] 45e0dfd4d5Shanjiezhou fn pair(self) -> (K, V) { 46e0dfd4d5Shanjiezhou (self.key, self.value) 47e0dfd4d5Shanjiezhou } 48e0dfd4d5Shanjiezhou } 49e0dfd4d5Shanjiezhou 50e0dfd4d5Shanjiezhou impl<K, V> Debug for RBTreeNode<K, V> 51e0dfd4d5Shanjiezhou where 52e0dfd4d5Shanjiezhou K: Ord + Debug, 53e0dfd4d5Shanjiezhou V: Debug, 54e0dfd4d5Shanjiezhou { 55e0dfd4d5Shanjiezhou fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 56e0dfd4d5Shanjiezhou write!(f, "k:{:?} v:{:?} c:{:?}", self.key, self.value, self.color) 57e0dfd4d5Shanjiezhou } 58e0dfd4d5Shanjiezhou } 59e0dfd4d5Shanjiezhou 60e0dfd4d5Shanjiezhou /*****************NodePtr***************************/ 61e0dfd4d5Shanjiezhou #[derive(Debug)] 62e0dfd4d5Shanjiezhou struct NodePtr<K: Ord, V>(*mut RBTreeNode<K, V>); 63e0dfd4d5Shanjiezhou 64e0dfd4d5Shanjiezhou impl<K: Ord, V> Clone for NodePtr<K, V> { 65e0dfd4d5Shanjiezhou fn clone(&self) -> NodePtr<K, V> { 66e0dfd4d5Shanjiezhou NodePtr(self.0) 67e0dfd4d5Shanjiezhou } 68e0dfd4d5Shanjiezhou } 69e0dfd4d5Shanjiezhou 70e0dfd4d5Shanjiezhou impl<K: Ord, V> Copy for NodePtr<K, V> {} 71e0dfd4d5Shanjiezhou 72e0dfd4d5Shanjiezhou impl<K: Ord, V> Ord for NodePtr<K, V> { 73e0dfd4d5Shanjiezhou fn cmp(&self, other: &NodePtr<K, V>) -> Ordering { 74e0dfd4d5Shanjiezhou unsafe { (*self.0).key.cmp(&(*other.0).key) } 75e0dfd4d5Shanjiezhou } 76e0dfd4d5Shanjiezhou } 77e0dfd4d5Shanjiezhou 78e0dfd4d5Shanjiezhou impl<K: Ord, V> PartialOrd for NodePtr<K, V> { 79e0dfd4d5Shanjiezhou fn partial_cmp(&self, other: &NodePtr<K, V>) -> Option<Ordering> { 80e0dfd4d5Shanjiezhou unsafe { Some((*self.0).key.cmp(&(*other.0).key)) } 81e0dfd4d5Shanjiezhou } 82e0dfd4d5Shanjiezhou } 83e0dfd4d5Shanjiezhou 84e0dfd4d5Shanjiezhou impl<K: Ord, V> PartialEq for NodePtr<K, V> { 85e0dfd4d5Shanjiezhou fn eq(&self, other: &NodePtr<K, V>) -> bool { 86e0dfd4d5Shanjiezhou self.0 == other.0 87e0dfd4d5Shanjiezhou } 88e0dfd4d5Shanjiezhou } 89e0dfd4d5Shanjiezhou 90e0dfd4d5Shanjiezhou impl<K: Ord, V> Eq for NodePtr<K, V> {} 91e0dfd4d5Shanjiezhou 92e0dfd4d5Shanjiezhou impl<K: Ord, V> NodePtr<K, V> { 93e0dfd4d5Shanjiezhou fn new(k: K, v: V) -> NodePtr<K, V> { 94e0dfd4d5Shanjiezhou let node = RBTreeNode { 95e0dfd4d5Shanjiezhou color: Color::Black, 96e0dfd4d5Shanjiezhou left: NodePtr::null(), 97e0dfd4d5Shanjiezhou right: NodePtr::null(), 98e0dfd4d5Shanjiezhou parent: NodePtr::null(), 99e0dfd4d5Shanjiezhou key: k, 100e0dfd4d5Shanjiezhou value: v, 101e0dfd4d5Shanjiezhou }; 102e0dfd4d5Shanjiezhou NodePtr(Box::into_raw(Box::new(node))) 103e0dfd4d5Shanjiezhou } 104e0dfd4d5Shanjiezhou 105e0dfd4d5Shanjiezhou #[inline] 106e0dfd4d5Shanjiezhou fn set_color(&mut self, color: Color) { 107e0dfd4d5Shanjiezhou if self.is_null() { 108e0dfd4d5Shanjiezhou return; 109e0dfd4d5Shanjiezhou } 110e0dfd4d5Shanjiezhou unsafe { 111e0dfd4d5Shanjiezhou (*self.0).color = color; 112e0dfd4d5Shanjiezhou } 113e0dfd4d5Shanjiezhou } 114e0dfd4d5Shanjiezhou 115e0dfd4d5Shanjiezhou #[inline] 116e0dfd4d5Shanjiezhou fn set_red_color(&mut self) { 117e0dfd4d5Shanjiezhou self.set_color(Color::Red); 118e0dfd4d5Shanjiezhou } 119e0dfd4d5Shanjiezhou 120e0dfd4d5Shanjiezhou #[inline] 121e0dfd4d5Shanjiezhou fn set_black_color(&mut self) { 122e0dfd4d5Shanjiezhou self.set_color(Color::Black); 123e0dfd4d5Shanjiezhou } 124e0dfd4d5Shanjiezhou 125e0dfd4d5Shanjiezhou #[inline] 126e0dfd4d5Shanjiezhou fn get_color(&self) -> Color { 127e0dfd4d5Shanjiezhou if self.is_null() { 128e0dfd4d5Shanjiezhou return Color::Black; 129e0dfd4d5Shanjiezhou } 130e0dfd4d5Shanjiezhou unsafe { (*self.0).color } 131e0dfd4d5Shanjiezhou } 132e0dfd4d5Shanjiezhou 133e0dfd4d5Shanjiezhou #[inline] 134e0dfd4d5Shanjiezhou fn is_red_color(&self) -> bool { 135e0dfd4d5Shanjiezhou if self.is_null() { 136e0dfd4d5Shanjiezhou return false; 137e0dfd4d5Shanjiezhou } 138e0dfd4d5Shanjiezhou unsafe { (*self.0).color == Color::Red } 139e0dfd4d5Shanjiezhou } 140e0dfd4d5Shanjiezhou 141e0dfd4d5Shanjiezhou #[inline] 142e0dfd4d5Shanjiezhou fn is_black_color(&self) -> bool { 143e0dfd4d5Shanjiezhou if self.is_null() { 144e0dfd4d5Shanjiezhou return true; 145e0dfd4d5Shanjiezhou } 146e0dfd4d5Shanjiezhou unsafe { (*self.0).color == Color::Black } 147e0dfd4d5Shanjiezhou } 148e0dfd4d5Shanjiezhou 149e0dfd4d5Shanjiezhou #[inline] 150e0dfd4d5Shanjiezhou fn is_left_child(&self) -> bool { 151e0dfd4d5Shanjiezhou self.parent().left() == *self 152e0dfd4d5Shanjiezhou } 153e0dfd4d5Shanjiezhou 154e0dfd4d5Shanjiezhou #[inline] 155e0dfd4d5Shanjiezhou fn is_right_child(&self) -> bool { 156e0dfd4d5Shanjiezhou self.parent().right() == *self 157e0dfd4d5Shanjiezhou } 158e0dfd4d5Shanjiezhou 159e0dfd4d5Shanjiezhou #[inline] 160e0dfd4d5Shanjiezhou fn min_node(self) -> NodePtr<K, V> { 161e0dfd4d5Shanjiezhou let mut temp = self.clone(); 162e0dfd4d5Shanjiezhou while !temp.left().is_null() { 163e0dfd4d5Shanjiezhou temp = temp.left(); 164e0dfd4d5Shanjiezhou } 165e0dfd4d5Shanjiezhou return temp; 166e0dfd4d5Shanjiezhou } 167e0dfd4d5Shanjiezhou 168e0dfd4d5Shanjiezhou #[inline] 169e0dfd4d5Shanjiezhou fn max_node(self) -> NodePtr<K, V> { 170e0dfd4d5Shanjiezhou let mut temp = self.clone(); 171e0dfd4d5Shanjiezhou while !temp.right().is_null() { 172e0dfd4d5Shanjiezhou temp = temp.right(); 173e0dfd4d5Shanjiezhou } 174e0dfd4d5Shanjiezhou return temp; 175e0dfd4d5Shanjiezhou } 176e0dfd4d5Shanjiezhou 177e0dfd4d5Shanjiezhou #[inline] 178e0dfd4d5Shanjiezhou fn next(self) -> NodePtr<K, V> { 179e0dfd4d5Shanjiezhou if !self.right().is_null() { 180e0dfd4d5Shanjiezhou self.right().min_node() 181e0dfd4d5Shanjiezhou } else { 182e0dfd4d5Shanjiezhou let mut temp = self; 183e0dfd4d5Shanjiezhou loop { 184e0dfd4d5Shanjiezhou if temp.parent().is_null() { 185e0dfd4d5Shanjiezhou return NodePtr::null(); 186e0dfd4d5Shanjiezhou } 187e0dfd4d5Shanjiezhou if temp.is_left_child() { 188e0dfd4d5Shanjiezhou return temp.parent(); 189e0dfd4d5Shanjiezhou } 190e0dfd4d5Shanjiezhou temp = temp.parent(); 191e0dfd4d5Shanjiezhou } 192e0dfd4d5Shanjiezhou } 193e0dfd4d5Shanjiezhou } 194e0dfd4d5Shanjiezhou 195e0dfd4d5Shanjiezhou #[inline] 196e0dfd4d5Shanjiezhou fn prev(self) -> NodePtr<K, V> { 197e0dfd4d5Shanjiezhou if !self.left().is_null() { 198e0dfd4d5Shanjiezhou self.left().max_node() 199e0dfd4d5Shanjiezhou } else { 200e0dfd4d5Shanjiezhou let mut temp = self; 201e0dfd4d5Shanjiezhou loop { 202e0dfd4d5Shanjiezhou if temp.parent().is_null() { 203e0dfd4d5Shanjiezhou return NodePtr::null(); 204e0dfd4d5Shanjiezhou } 205e0dfd4d5Shanjiezhou if temp.is_right_child() { 206e0dfd4d5Shanjiezhou return temp.parent(); 207e0dfd4d5Shanjiezhou } 208e0dfd4d5Shanjiezhou temp = temp.parent(); 209e0dfd4d5Shanjiezhou } 210e0dfd4d5Shanjiezhou } 211e0dfd4d5Shanjiezhou } 212e0dfd4d5Shanjiezhou 213e0dfd4d5Shanjiezhou #[inline] 214e0dfd4d5Shanjiezhou fn set_parent(&mut self, parent: NodePtr<K, V>) { 215e0dfd4d5Shanjiezhou if self.is_null() { 216e0dfd4d5Shanjiezhou return; 217e0dfd4d5Shanjiezhou } 218e0dfd4d5Shanjiezhou unsafe { (*self.0).parent = parent } 219e0dfd4d5Shanjiezhou } 220e0dfd4d5Shanjiezhou 221e0dfd4d5Shanjiezhou #[inline] 222e0dfd4d5Shanjiezhou fn set_left(&mut self, left: NodePtr<K, V>) { 223e0dfd4d5Shanjiezhou if self.is_null() { 224e0dfd4d5Shanjiezhou return; 225e0dfd4d5Shanjiezhou } 226e0dfd4d5Shanjiezhou unsafe { (*self.0).left = left } 227e0dfd4d5Shanjiezhou } 228e0dfd4d5Shanjiezhou 229e0dfd4d5Shanjiezhou #[inline] 230e0dfd4d5Shanjiezhou fn set_right(&mut self, right: NodePtr<K, V>) { 231e0dfd4d5Shanjiezhou if self.is_null() { 232e0dfd4d5Shanjiezhou return; 233e0dfd4d5Shanjiezhou } 234e0dfd4d5Shanjiezhou unsafe { (*self.0).right = right } 235e0dfd4d5Shanjiezhou } 236e0dfd4d5Shanjiezhou 237e0dfd4d5Shanjiezhou #[inline] 238e0dfd4d5Shanjiezhou fn parent(&self) -> NodePtr<K, V> { 239e0dfd4d5Shanjiezhou if self.is_null() { 240e0dfd4d5Shanjiezhou return NodePtr::null(); 241e0dfd4d5Shanjiezhou } 242e0dfd4d5Shanjiezhou unsafe { (*self.0).parent.clone() } 243e0dfd4d5Shanjiezhou } 244e0dfd4d5Shanjiezhou 245e0dfd4d5Shanjiezhou #[inline] 246e0dfd4d5Shanjiezhou fn left(&self) -> NodePtr<K, V> { 247e0dfd4d5Shanjiezhou if self.is_null() { 248e0dfd4d5Shanjiezhou return NodePtr::null(); 249e0dfd4d5Shanjiezhou } 250e0dfd4d5Shanjiezhou unsafe { (*self.0).left.clone() } 251e0dfd4d5Shanjiezhou } 252e0dfd4d5Shanjiezhou 253e0dfd4d5Shanjiezhou #[inline] 254e0dfd4d5Shanjiezhou fn right(&self) -> NodePtr<K, V> { 255e0dfd4d5Shanjiezhou if self.is_null() { 256e0dfd4d5Shanjiezhou return NodePtr::null(); 257e0dfd4d5Shanjiezhou } 258e0dfd4d5Shanjiezhou unsafe { (*self.0).right.clone() } 259e0dfd4d5Shanjiezhou } 260e0dfd4d5Shanjiezhou 261e0dfd4d5Shanjiezhou #[inline] 262e0dfd4d5Shanjiezhou fn null() -> NodePtr<K, V> { 263e0dfd4d5Shanjiezhou NodePtr(ptr::null_mut()) 264e0dfd4d5Shanjiezhou } 265e0dfd4d5Shanjiezhou 266e0dfd4d5Shanjiezhou #[inline] 267e0dfd4d5Shanjiezhou fn is_null(&self) -> bool { 268e0dfd4d5Shanjiezhou self.0.is_null() 269e0dfd4d5Shanjiezhou } 270e0dfd4d5Shanjiezhou } 271e0dfd4d5Shanjiezhou 272e0dfd4d5Shanjiezhou impl<K: Ord + Clone, V: Clone> NodePtr<K, V> { 273e0dfd4d5Shanjiezhou unsafe fn deep_clone(&self) -> NodePtr<K, V> { 274e0dfd4d5Shanjiezhou let mut node = NodePtr::new((*self.0).key.clone(), (*self.0).value.clone()); 275e0dfd4d5Shanjiezhou if !self.left().is_null() { 276e0dfd4d5Shanjiezhou node.set_left(self.left().deep_clone()); 277e0dfd4d5Shanjiezhou node.left().set_parent(node); 278e0dfd4d5Shanjiezhou } 279e0dfd4d5Shanjiezhou if !self.right().is_null() { 280e0dfd4d5Shanjiezhou node.set_right(self.right().deep_clone()); 281e0dfd4d5Shanjiezhou node.right().set_parent(node); 282e0dfd4d5Shanjiezhou } 283e0dfd4d5Shanjiezhou node 284e0dfd4d5Shanjiezhou } 285e0dfd4d5Shanjiezhou } 286e0dfd4d5Shanjiezhou 287e0dfd4d5Shanjiezhou /// A red black tree implemented with Rust 288e0dfd4d5Shanjiezhou /// It is required that the keys implement the [`Ord`] traits. 289e0dfd4d5Shanjiezhou 290e0dfd4d5Shanjiezhou /// # Examples 291e0dfd4d5Shanjiezhou /// ```rust 292e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 293e0dfd4d5Shanjiezhou /// // type inference lets us omit an explicit type signature (which 294e0dfd4d5Shanjiezhou /// // would be `RBTree<&str, &str>` in this example). 295e0dfd4d5Shanjiezhou /// let mut book_reviews = RBTree::new(); 296e0dfd4d5Shanjiezhou /// 297e0dfd4d5Shanjiezhou /// // review some books. 298e0dfd4d5Shanjiezhou /// book_reviews.insert("Adventures of Huckleberry Finn", "My favorite book."); 299e0dfd4d5Shanjiezhou /// book_reviews.insert("Grimms' Fairy Tales", "Masterpiece."); 300e0dfd4d5Shanjiezhou /// book_reviews.insert("Pride and Prejudice", "Very enjoyable."); 301e0dfd4d5Shanjiezhou /// book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot."); 302e0dfd4d5Shanjiezhou /// 303e0dfd4d5Shanjiezhou /// // check for a specific one. 304e0dfd4d5Shanjiezhou /// if !book_reviews.contains_key(&"Les Misérables") { 305e0dfd4d5Shanjiezhou /// kdebug!( 306e0dfd4d5Shanjiezhou /// "We've got {} reviews, but Les Misérables ain't one.", 307e0dfd4d5Shanjiezhou /// book_reviews.len() 308e0dfd4d5Shanjiezhou /// ); 309e0dfd4d5Shanjiezhou /// } 310e0dfd4d5Shanjiezhou /// 311e0dfd4d5Shanjiezhou /// // oops, this review has a lot of spelling mistakes, let's delete it. 312e0dfd4d5Shanjiezhou /// book_reviews.remove(&"The Adventures of Sherlock Holmes"); 313e0dfd4d5Shanjiezhou /// 314e0dfd4d5Shanjiezhou /// // look up the values associated with some keys. 315e0dfd4d5Shanjiezhou /// let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"]; 316e0dfd4d5Shanjiezhou /// for book in &to_find { 317e0dfd4d5Shanjiezhou /// match book_reviews.get(book) { 318e0dfd4d5Shanjiezhou /// Some(review) => kdebug!("{}: {}", book, review), 319e0dfd4d5Shanjiezhou /// None => kdebug!("{} is unreviewed.", book), 320e0dfd4d5Shanjiezhou /// } 321e0dfd4d5Shanjiezhou /// } 322e0dfd4d5Shanjiezhou /// 323e0dfd4d5Shanjiezhou /// // iterate over everything. 324e0dfd4d5Shanjiezhou /// for (book, review) in book_reviews.iter() { 325e0dfd4d5Shanjiezhou /// kdebug!("{}: \"{}\"", book, review); 326e0dfd4d5Shanjiezhou /// } 327e0dfd4d5Shanjiezhou /// 328e0dfd4d5Shanjiezhou /// book_reviews.print_tree(); 329e0dfd4d5Shanjiezhou /// ``` 330e0dfd4d5Shanjiezhou /// 331e0dfd4d5Shanjiezhou /// // A `RBTree` with fixed list of elements can be initialized from an array: 332e0dfd4d5Shanjiezhou /// ``` 333e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 334e0dfd4d5Shanjiezhou /// let timber_resources: RBTree<&str, i32> = 335e0dfd4d5Shanjiezhou /// [("Norway", 100), 336e0dfd4d5Shanjiezhou /// ("Denmark", 50), 337e0dfd4d5Shanjiezhou /// ("Iceland", 10)] 338e0dfd4d5Shanjiezhou /// .iter().cloned().collect(); 339e0dfd4d5Shanjiezhou /// // use the values stored in rbtree 340e0dfd4d5Shanjiezhou /// ``` 341e0dfd4d5Shanjiezhou pub struct RBTree<K: Ord, V> { 342e0dfd4d5Shanjiezhou root: NodePtr<K, V>, 343e0dfd4d5Shanjiezhou len: usize, 344e0dfd4d5Shanjiezhou } 345e0dfd4d5Shanjiezhou 346*40609970SGnoCiYeH unsafe impl<K: Ord, V> Send for RBTree<K, V> {} 347*40609970SGnoCiYeH unsafe impl<K: Ord, V> Sync for RBTree<K, V> {} 348*40609970SGnoCiYeH 349e0dfd4d5Shanjiezhou // Drop all owned pointers if the tree is dropped 350e0dfd4d5Shanjiezhou impl<K: Ord, V> Drop for RBTree<K, V> { 351e0dfd4d5Shanjiezhou #[inline] 352e0dfd4d5Shanjiezhou fn drop(&mut self) { 353e0dfd4d5Shanjiezhou self.clear(); 354e0dfd4d5Shanjiezhou } 355e0dfd4d5Shanjiezhou } 356e0dfd4d5Shanjiezhou 357e0dfd4d5Shanjiezhou /// If key and value are both impl Clone, we can call clone to get a copy. 358e0dfd4d5Shanjiezhou impl<K: Ord + Clone, V: Clone> Clone for RBTree<K, V> { 359e0dfd4d5Shanjiezhou fn clone(&self) -> RBTree<K, V> { 360e0dfd4d5Shanjiezhou unsafe { 361e0dfd4d5Shanjiezhou let mut new = RBTree::new(); 362e0dfd4d5Shanjiezhou new.root = self.root.deep_clone(); 363e0dfd4d5Shanjiezhou new.len = self.len; 364e0dfd4d5Shanjiezhou new 365e0dfd4d5Shanjiezhou } 366e0dfd4d5Shanjiezhou } 367e0dfd4d5Shanjiezhou } 368e0dfd4d5Shanjiezhou 369e0dfd4d5Shanjiezhou impl<K, V> Debug for RBTree<K, V> 370e0dfd4d5Shanjiezhou where 371e0dfd4d5Shanjiezhou K: Ord + Debug, 372e0dfd4d5Shanjiezhou V: Debug, 373e0dfd4d5Shanjiezhou { 374e0dfd4d5Shanjiezhou fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 375e0dfd4d5Shanjiezhou f.debug_map().entries(self.iter()).finish() 376e0dfd4d5Shanjiezhou } 377e0dfd4d5Shanjiezhou } 378e0dfd4d5Shanjiezhou 379e0dfd4d5Shanjiezhou /// This is a method to help us to get inner struct. 380e0dfd4d5Shanjiezhou impl<K: Ord + Debug, V: Debug> RBTree<K, V> { 381e0dfd4d5Shanjiezhou fn tree_print(&self, node: NodePtr<K, V>, direction: i32) { 382e0dfd4d5Shanjiezhou if node.is_null() { 383e0dfd4d5Shanjiezhou return; 384e0dfd4d5Shanjiezhou } 385e0dfd4d5Shanjiezhou if direction == 0 { 386e0dfd4d5Shanjiezhou unsafe { 387e0dfd4d5Shanjiezhou kdebug!("'{:?}' is root node", (*node.0)); 388e0dfd4d5Shanjiezhou } 389e0dfd4d5Shanjiezhou } else { 390e0dfd4d5Shanjiezhou let direct = if direction == -1 { "left" } else { "right" }; 391e0dfd4d5Shanjiezhou unsafe { 392e0dfd4d5Shanjiezhou kdebug!( 393e0dfd4d5Shanjiezhou "{:?} is {:?}'s {:?} child ", 394e0dfd4d5Shanjiezhou (*node.0), 395e0dfd4d5Shanjiezhou *node.parent().0, 396e0dfd4d5Shanjiezhou direct 397e0dfd4d5Shanjiezhou ); 398e0dfd4d5Shanjiezhou } 399e0dfd4d5Shanjiezhou } 400e0dfd4d5Shanjiezhou self.tree_print(node.left(), -1); 401e0dfd4d5Shanjiezhou self.tree_print(node.right(), 1); 402e0dfd4d5Shanjiezhou } 403e0dfd4d5Shanjiezhou 404e0dfd4d5Shanjiezhou pub fn print_tree(&self) { 405e0dfd4d5Shanjiezhou if self.root.is_null() { 406e0dfd4d5Shanjiezhou kdebug!("This is a empty tree"); 407e0dfd4d5Shanjiezhou return; 408e0dfd4d5Shanjiezhou } 409e0dfd4d5Shanjiezhou kdebug!("This tree size = {:?}, begin:-------------", self.len()); 410e0dfd4d5Shanjiezhou self.tree_print(self.root, 0); 411e0dfd4d5Shanjiezhou kdebug!("end--------------------------"); 412e0dfd4d5Shanjiezhou } 413e0dfd4d5Shanjiezhou } 414e0dfd4d5Shanjiezhou 415e0dfd4d5Shanjiezhou /// all key be same, but it has multi key, if has multi key, it perhaps no correct 416e0dfd4d5Shanjiezhou impl<K, V> PartialEq for RBTree<K, V> 417e0dfd4d5Shanjiezhou where 418e0dfd4d5Shanjiezhou K: Eq + Ord, 419e0dfd4d5Shanjiezhou V: PartialEq, 420e0dfd4d5Shanjiezhou { 421e0dfd4d5Shanjiezhou fn eq(&self, other: &RBTree<K, V>) -> bool { 422e0dfd4d5Shanjiezhou if self.len() != other.len() { 423e0dfd4d5Shanjiezhou return false; 424e0dfd4d5Shanjiezhou } 425e0dfd4d5Shanjiezhou 42678bf93f0SYJwu2023 self.iter() 42778bf93f0SYJwu2023 .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v)) 428e0dfd4d5Shanjiezhou } 429e0dfd4d5Shanjiezhou } 430e0dfd4d5Shanjiezhou 431e0dfd4d5Shanjiezhou impl<K, V> Eq for RBTree<K, V> 432e0dfd4d5Shanjiezhou where 433e0dfd4d5Shanjiezhou K: Eq + Ord, 434e0dfd4d5Shanjiezhou V: Eq, 435e0dfd4d5Shanjiezhou { 436e0dfd4d5Shanjiezhou } 437e0dfd4d5Shanjiezhou 438e0dfd4d5Shanjiezhou impl<'a, K, V> Index<&'a K> for RBTree<K, V> 439e0dfd4d5Shanjiezhou where 440e0dfd4d5Shanjiezhou K: Ord, 441e0dfd4d5Shanjiezhou { 442e0dfd4d5Shanjiezhou type Output = V; 443e0dfd4d5Shanjiezhou 444e0dfd4d5Shanjiezhou #[inline] 445e0dfd4d5Shanjiezhou fn index(&self, index: &K) -> &V { 446e0dfd4d5Shanjiezhou self.get(index).expect("no entry found for key") 447e0dfd4d5Shanjiezhou } 448e0dfd4d5Shanjiezhou } 449e0dfd4d5Shanjiezhou 450e0dfd4d5Shanjiezhou impl<K: Ord, V> FromIterator<(K, V)> for RBTree<K, V> { 451e0dfd4d5Shanjiezhou fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> RBTree<K, V> { 452e0dfd4d5Shanjiezhou let mut tree = RBTree::new(); 453e0dfd4d5Shanjiezhou tree.extend(iter); 454e0dfd4d5Shanjiezhou tree 455e0dfd4d5Shanjiezhou } 456e0dfd4d5Shanjiezhou } 457e0dfd4d5Shanjiezhou 458e0dfd4d5Shanjiezhou /// RBTree into iter 459e0dfd4d5Shanjiezhou impl<K: Ord, V> Extend<(K, V)> for RBTree<K, V> { 460e0dfd4d5Shanjiezhou fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) { 461e0dfd4d5Shanjiezhou let iter = iter.into_iter(); 462e0dfd4d5Shanjiezhou for (k, v) in iter { 463e0dfd4d5Shanjiezhou self.insert(k, v); 464e0dfd4d5Shanjiezhou } 465e0dfd4d5Shanjiezhou } 466e0dfd4d5Shanjiezhou } 467e0dfd4d5Shanjiezhou 468e0dfd4d5Shanjiezhou /// provide the rbtree all keys 469e0dfd4d5Shanjiezhou /// # Examples 470e0dfd4d5Shanjiezhou /// ``` 471e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 472e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 473e0dfd4d5Shanjiezhou /// for i in 1..6 { 474e0dfd4d5Shanjiezhou /// m.insert(i, i); 475e0dfd4d5Shanjiezhou /// } 476e0dfd4d5Shanjiezhou /// let vec = vec![1, 2, 3, 4, 5]; 477e0dfd4d5Shanjiezhou /// let key_vec: Vec<_> = m.keys().cloned().collect(); 478e0dfd4d5Shanjiezhou /// assert_eq!(vec, key_vec); 479e0dfd4d5Shanjiezhou /// ``` 480e0dfd4d5Shanjiezhou pub struct Keys<'a, K: Ord + 'a, V: 'a> { 481e0dfd4d5Shanjiezhou inner: Iter<'a, K, V>, 482e0dfd4d5Shanjiezhou } 483e0dfd4d5Shanjiezhou 484e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Clone for Keys<'a, K, V> { 485e0dfd4d5Shanjiezhou fn clone(&self) -> Keys<'a, K, V> { 48678bf93f0SYJwu2023 Keys { 48778bf93f0SYJwu2023 inner: self.inner.clone(), 48878bf93f0SYJwu2023 } 489e0dfd4d5Shanjiezhou } 490e0dfd4d5Shanjiezhou } 491e0dfd4d5Shanjiezhou 492e0dfd4d5Shanjiezhou impl<'a, K: Ord + Debug, V> fmt::Debug for Keys<'a, K, V> { 493e0dfd4d5Shanjiezhou fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 494e0dfd4d5Shanjiezhou f.debug_list().entries(self.clone()).finish() 495e0dfd4d5Shanjiezhou } 496e0dfd4d5Shanjiezhou } 497e0dfd4d5Shanjiezhou 498e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Iterator for Keys<'a, K, V> { 499e0dfd4d5Shanjiezhou type Item = &'a K; 500e0dfd4d5Shanjiezhou 501e0dfd4d5Shanjiezhou #[inline] 502e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<&'a K> { 503e0dfd4d5Shanjiezhou self.inner.next().map(|(k, _)| k) 504e0dfd4d5Shanjiezhou } 505e0dfd4d5Shanjiezhou 506e0dfd4d5Shanjiezhou #[inline] 507e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 508e0dfd4d5Shanjiezhou self.inner.size_hint() 509e0dfd4d5Shanjiezhou } 510e0dfd4d5Shanjiezhou } 511e0dfd4d5Shanjiezhou 512e0dfd4d5Shanjiezhou /// provide the rbtree all values order by key 513e0dfd4d5Shanjiezhou /// # Examples 514e0dfd4d5Shanjiezhou /// ``` 515e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 516e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 517e0dfd4d5Shanjiezhou /// m.insert(2, 5); 518e0dfd4d5Shanjiezhou /// m.insert(1, 6); 519e0dfd4d5Shanjiezhou /// m.insert(3, 8); 520e0dfd4d5Shanjiezhou /// m.insert(4, 9); 521e0dfd4d5Shanjiezhou /// let vec = vec![6, 5, 8, 9]; 522e0dfd4d5Shanjiezhou /// let key_vec: Vec<_> = m.values().cloned().collect(); 523e0dfd4d5Shanjiezhou /// assert_eq!(vec, key_vec); 524e0dfd4d5Shanjiezhou /// ``` 525e0dfd4d5Shanjiezhou pub struct Values<'a, K: 'a + Ord, V: 'a> { 526e0dfd4d5Shanjiezhou inner: Iter<'a, K, V>, 527e0dfd4d5Shanjiezhou } 528e0dfd4d5Shanjiezhou 529e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Clone for Values<'a, K, V> { 530e0dfd4d5Shanjiezhou fn clone(&self) -> Values<'a, K, V> { 53178bf93f0SYJwu2023 Values { 53278bf93f0SYJwu2023 inner: self.inner.clone(), 53378bf93f0SYJwu2023 } 534e0dfd4d5Shanjiezhou } 535e0dfd4d5Shanjiezhou } 536e0dfd4d5Shanjiezhou 537e0dfd4d5Shanjiezhou impl<'a, K: Ord + Debug, V: Debug> fmt::Debug for Values<'a, K, V> { 538e0dfd4d5Shanjiezhou fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 539e0dfd4d5Shanjiezhou f.debug_list().entries(self.clone()).finish() 540e0dfd4d5Shanjiezhou } 541e0dfd4d5Shanjiezhou } 542e0dfd4d5Shanjiezhou 543e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Iterator for Values<'a, K, V> { 544e0dfd4d5Shanjiezhou type Item = &'a V; 545e0dfd4d5Shanjiezhou 546e0dfd4d5Shanjiezhou #[inline] 547e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<&'a V> { 548e0dfd4d5Shanjiezhou self.inner.next().map(|(_, v)| v) 549e0dfd4d5Shanjiezhou } 550e0dfd4d5Shanjiezhou 551e0dfd4d5Shanjiezhou #[inline] 552e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 553e0dfd4d5Shanjiezhou self.inner.size_hint() 554e0dfd4d5Shanjiezhou } 555e0dfd4d5Shanjiezhou } 556e0dfd4d5Shanjiezhou 557e0dfd4d5Shanjiezhou /// provide the rbtree all values and it can be modify 558e0dfd4d5Shanjiezhou /// # Examples 559e0dfd4d5Shanjiezhou /// ``` 560e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 561e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 562e0dfd4d5Shanjiezhou /// for i in 0..32 { 563e0dfd4d5Shanjiezhou /// m.insert(i, i); 564e0dfd4d5Shanjiezhou /// } 565e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 32); 566e0dfd4d5Shanjiezhou /// for v in m.values_mut() { 567e0dfd4d5Shanjiezhou /// *v *= 2; 568e0dfd4d5Shanjiezhou /// } 569e0dfd4d5Shanjiezhou /// for i in 0..32 { 570e0dfd4d5Shanjiezhou /// assert_eq!(m.get(&i).unwrap(), &(i * 2)); 571e0dfd4d5Shanjiezhou /// } 572e0dfd4d5Shanjiezhou /// ``` 573e0dfd4d5Shanjiezhou pub struct ValuesMut<'a, K: 'a + Ord, V: 'a> { 574e0dfd4d5Shanjiezhou inner: IterMut<'a, K, V>, 575e0dfd4d5Shanjiezhou } 576e0dfd4d5Shanjiezhou 577e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Clone for ValuesMut<'a, K, V> { 578e0dfd4d5Shanjiezhou fn clone(&self) -> ValuesMut<'a, K, V> { 57978bf93f0SYJwu2023 ValuesMut { 58078bf93f0SYJwu2023 inner: self.inner.clone(), 58178bf93f0SYJwu2023 } 582e0dfd4d5Shanjiezhou } 583e0dfd4d5Shanjiezhou } 584e0dfd4d5Shanjiezhou 585e0dfd4d5Shanjiezhou impl<'a, K: Ord + Debug, V: Debug> fmt::Debug for ValuesMut<'a, K, V> { 586e0dfd4d5Shanjiezhou fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 587e0dfd4d5Shanjiezhou f.debug_list().entries(self.clone()).finish() 588e0dfd4d5Shanjiezhou } 589e0dfd4d5Shanjiezhou } 590e0dfd4d5Shanjiezhou 591e0dfd4d5Shanjiezhou impl<'a, K: Ord, V> Iterator for ValuesMut<'a, K, V> { 592e0dfd4d5Shanjiezhou type Item = &'a mut V; 593e0dfd4d5Shanjiezhou 594e0dfd4d5Shanjiezhou #[inline] 595e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<&'a mut V> { 596e0dfd4d5Shanjiezhou self.inner.next().map(|(_, v)| v) 597e0dfd4d5Shanjiezhou } 598e0dfd4d5Shanjiezhou 599e0dfd4d5Shanjiezhou #[inline] 600e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 601e0dfd4d5Shanjiezhou self.inner.size_hint() 602e0dfd4d5Shanjiezhou } 603e0dfd4d5Shanjiezhou } 604e0dfd4d5Shanjiezhou 605e0dfd4d5Shanjiezhou /// Convert RBTree to iter, move out the tree. 606e0dfd4d5Shanjiezhou pub struct IntoIter<K: Ord, V> { 607e0dfd4d5Shanjiezhou head: NodePtr<K, V>, 608e0dfd4d5Shanjiezhou tail: NodePtr<K, V>, 609e0dfd4d5Shanjiezhou len: usize, 610e0dfd4d5Shanjiezhou } 611e0dfd4d5Shanjiezhou 612e0dfd4d5Shanjiezhou // Drop all owned pointers if the collection is dropped 613e0dfd4d5Shanjiezhou impl<K: Ord, V> Drop for IntoIter<K, V> { 614e0dfd4d5Shanjiezhou #[inline] 615e0dfd4d5Shanjiezhou fn drop(&mut self) { 616e0dfd4d5Shanjiezhou for (_, _) in self {} 617e0dfd4d5Shanjiezhou } 618e0dfd4d5Shanjiezhou } 619e0dfd4d5Shanjiezhou 620e0dfd4d5Shanjiezhou impl<K: Ord, V> Iterator for IntoIter<K, V> { 621e0dfd4d5Shanjiezhou type Item = (K, V); 622e0dfd4d5Shanjiezhou 623e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<(K, V)> { 624e0dfd4d5Shanjiezhou if self.len == 0 { 625e0dfd4d5Shanjiezhou return None; 626e0dfd4d5Shanjiezhou } 627e0dfd4d5Shanjiezhou 628e0dfd4d5Shanjiezhou if self.head.is_null() { 629e0dfd4d5Shanjiezhou return None; 630e0dfd4d5Shanjiezhou } 631e0dfd4d5Shanjiezhou 632e0dfd4d5Shanjiezhou let next = self.head.next(); 633e0dfd4d5Shanjiezhou let (k, v) = unsafe { 634e0dfd4d5Shanjiezhou ( 635e0dfd4d5Shanjiezhou core::ptr::read(&(*self.head.0).key), 636e0dfd4d5Shanjiezhou core::ptr::read(&(*self.head.0).value), 637e0dfd4d5Shanjiezhou ) 638e0dfd4d5Shanjiezhou }; 639e0dfd4d5Shanjiezhou self.head = next; 640e0dfd4d5Shanjiezhou self.len -= 1; 641e0dfd4d5Shanjiezhou Some((k, v)) 642e0dfd4d5Shanjiezhou } 643e0dfd4d5Shanjiezhou 644e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 645e0dfd4d5Shanjiezhou (self.len, Some(self.len)) 646e0dfd4d5Shanjiezhou } 647e0dfd4d5Shanjiezhou } 648e0dfd4d5Shanjiezhou 649e0dfd4d5Shanjiezhou impl<K: Ord, V> DoubleEndedIterator for IntoIter<K, V> { 650e0dfd4d5Shanjiezhou #[inline] 651e0dfd4d5Shanjiezhou fn next_back(&mut self) -> Option<(K, V)> { 652e0dfd4d5Shanjiezhou if self.len == 0 { 653e0dfd4d5Shanjiezhou return None; 654e0dfd4d5Shanjiezhou } 655e0dfd4d5Shanjiezhou 656e0dfd4d5Shanjiezhou if self.tail.is_null() { 657e0dfd4d5Shanjiezhou return None; 658e0dfd4d5Shanjiezhou } 659e0dfd4d5Shanjiezhou 660e0dfd4d5Shanjiezhou let prev = self.tail.prev(); 661e0dfd4d5Shanjiezhou let obj = unsafe { Box::from_raw(self.tail.0) }; 662e0dfd4d5Shanjiezhou let (k, v) = obj.pair(); 663e0dfd4d5Shanjiezhou self.tail = prev; 664e0dfd4d5Shanjiezhou self.len -= 1; 665e0dfd4d5Shanjiezhou Some((k, v)) 666e0dfd4d5Shanjiezhou } 667e0dfd4d5Shanjiezhou } 668e0dfd4d5Shanjiezhou 669e0dfd4d5Shanjiezhou /// provide iter ref for RBTree 670e0dfd4d5Shanjiezhou /// # Examples 671e0dfd4d5Shanjiezhou /// ``` 672e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 673e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 674e0dfd4d5Shanjiezhou /// for i in 0..32 { 675e0dfd4d5Shanjiezhou /// m.insert(i, i * 2); 676e0dfd4d5Shanjiezhou /// } 677e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 32); 678e0dfd4d5Shanjiezhou /// let mut observed: u32 = 0; 679e0dfd4d5Shanjiezhou /// for (k, v) in m.iter() { 680e0dfd4d5Shanjiezhou /// assert_eq!(*v, *k * 2); 681e0dfd4d5Shanjiezhou /// observed |= 1 << *k; 682e0dfd4d5Shanjiezhou /// } 683e0dfd4d5Shanjiezhou /// assert_eq!(observed, 0xFFFF_FFFF); 684e0dfd4d5Shanjiezhou /// ``` 685e0dfd4d5Shanjiezhou pub struct Iter<'a, K: Ord + 'a, V: 'a> { 686e0dfd4d5Shanjiezhou head: NodePtr<K, V>, 687e0dfd4d5Shanjiezhou tail: NodePtr<K, V>, 688e0dfd4d5Shanjiezhou len: usize, 689e0dfd4d5Shanjiezhou _marker: marker::PhantomData<&'a ()>, 690e0dfd4d5Shanjiezhou } 691e0dfd4d5Shanjiezhou 692e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> Clone for Iter<'a, K, V> { 693e0dfd4d5Shanjiezhou fn clone(&self) -> Iter<'a, K, V> { 694e0dfd4d5Shanjiezhou Iter { 695e0dfd4d5Shanjiezhou head: self.head, 696e0dfd4d5Shanjiezhou tail: self.tail, 697e0dfd4d5Shanjiezhou len: self.len, 698e0dfd4d5Shanjiezhou _marker: self._marker, 699e0dfd4d5Shanjiezhou } 700e0dfd4d5Shanjiezhou } 701e0dfd4d5Shanjiezhou } 702e0dfd4d5Shanjiezhou 703e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> Iterator for Iter<'a, K, V> { 704e0dfd4d5Shanjiezhou type Item = (&'a K, &'a V); 705e0dfd4d5Shanjiezhou 706e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<(&'a K, &'a V)> { 707e0dfd4d5Shanjiezhou if self.len == 0 { 708e0dfd4d5Shanjiezhou return None; 709e0dfd4d5Shanjiezhou } 710e0dfd4d5Shanjiezhou 711e0dfd4d5Shanjiezhou if self.head.is_null() { 712e0dfd4d5Shanjiezhou return None; 713e0dfd4d5Shanjiezhou } 714e0dfd4d5Shanjiezhou 715e0dfd4d5Shanjiezhou let (k, v) = unsafe { (&(*self.head.0).key, &(*self.head.0).value) }; 716e0dfd4d5Shanjiezhou self.head = self.head.next(); 717e0dfd4d5Shanjiezhou self.len -= 1; 718e0dfd4d5Shanjiezhou Some((k, v)) 719e0dfd4d5Shanjiezhou } 720e0dfd4d5Shanjiezhou 721e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 722e0dfd4d5Shanjiezhou (self.len, Some(self.len)) 723e0dfd4d5Shanjiezhou } 724e0dfd4d5Shanjiezhou } 725e0dfd4d5Shanjiezhou 726e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> { 727e0dfd4d5Shanjiezhou #[inline] 728e0dfd4d5Shanjiezhou fn next_back(&mut self) -> Option<(&'a K, &'a V)> { 729e0dfd4d5Shanjiezhou // kdebug!("len = {:?}", self.len); 730e0dfd4d5Shanjiezhou if self.len == 0 { 731e0dfd4d5Shanjiezhou return None; 732e0dfd4d5Shanjiezhou } 733e0dfd4d5Shanjiezhou 734e0dfd4d5Shanjiezhou if self.tail == self.head { 735e0dfd4d5Shanjiezhou return None; 736e0dfd4d5Shanjiezhou } 737e0dfd4d5Shanjiezhou 738e0dfd4d5Shanjiezhou let (k, v) = unsafe { (&(*self.tail.0).key, &(*self.tail.0).value) }; 739e0dfd4d5Shanjiezhou self.tail = self.tail.prev(); 740e0dfd4d5Shanjiezhou self.len -= 1; 741e0dfd4d5Shanjiezhou Some((k, v)) 742e0dfd4d5Shanjiezhou } 743e0dfd4d5Shanjiezhou } 744e0dfd4d5Shanjiezhou 745e0dfd4d5Shanjiezhou /// provide iter mut ref for RBTree 746e0dfd4d5Shanjiezhou /// # Examples 747e0dfd4d5Shanjiezhou /// ``` 748e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 749e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 750e0dfd4d5Shanjiezhou /// for i in 0..32 { 751e0dfd4d5Shanjiezhou /// m.insert(i, i); 752e0dfd4d5Shanjiezhou /// } 753e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 32); 754e0dfd4d5Shanjiezhou /// for (_, v) in m.iter_mut() { 755e0dfd4d5Shanjiezhou /// *v *= 2; 756e0dfd4d5Shanjiezhou /// } 757e0dfd4d5Shanjiezhou /// for i in 0..32 { 758e0dfd4d5Shanjiezhou /// assert_eq!(m.get(&i).unwrap(), &(i * 2)); 759e0dfd4d5Shanjiezhou /// } 760e0dfd4d5Shanjiezhou /// ``` 761e0dfd4d5Shanjiezhou pub struct IterMut<'a, K: Ord + 'a, V: 'a> { 762e0dfd4d5Shanjiezhou head: NodePtr<K, V>, 763e0dfd4d5Shanjiezhou tail: NodePtr<K, V>, 764e0dfd4d5Shanjiezhou len: usize, 765e0dfd4d5Shanjiezhou _marker: marker::PhantomData<&'a ()>, 766e0dfd4d5Shanjiezhou } 767e0dfd4d5Shanjiezhou 768e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> Clone for IterMut<'a, K, V> { 769e0dfd4d5Shanjiezhou fn clone(&self) -> IterMut<'a, K, V> { 770e0dfd4d5Shanjiezhou IterMut { 771e0dfd4d5Shanjiezhou head: self.head, 772e0dfd4d5Shanjiezhou tail: self.tail, 773e0dfd4d5Shanjiezhou len: self.len, 774e0dfd4d5Shanjiezhou _marker: self._marker, 775e0dfd4d5Shanjiezhou } 776e0dfd4d5Shanjiezhou } 777e0dfd4d5Shanjiezhou } 778e0dfd4d5Shanjiezhou 779e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> Iterator for IterMut<'a, K, V> { 780e0dfd4d5Shanjiezhou type Item = (&'a K, &'a mut V); 781e0dfd4d5Shanjiezhou 782e0dfd4d5Shanjiezhou fn next(&mut self) -> Option<(&'a K, &'a mut V)> { 783e0dfd4d5Shanjiezhou if self.len == 0 { 784e0dfd4d5Shanjiezhou return None; 785e0dfd4d5Shanjiezhou } 786e0dfd4d5Shanjiezhou 787e0dfd4d5Shanjiezhou if self.head.is_null() { 788e0dfd4d5Shanjiezhou return None; 789e0dfd4d5Shanjiezhou } 790e0dfd4d5Shanjiezhou 791e0dfd4d5Shanjiezhou let (k, v) = unsafe { (&(*self.head.0).key, &mut (*self.head.0).value) }; 792e0dfd4d5Shanjiezhou self.head = self.head.next(); 793e0dfd4d5Shanjiezhou self.len -= 1; 794e0dfd4d5Shanjiezhou Some((k, v)) 795e0dfd4d5Shanjiezhou } 796e0dfd4d5Shanjiezhou 797e0dfd4d5Shanjiezhou fn size_hint(&self) -> (usize, Option<usize>) { 798e0dfd4d5Shanjiezhou (self.len, Some(self.len)) 799e0dfd4d5Shanjiezhou } 800e0dfd4d5Shanjiezhou } 801e0dfd4d5Shanjiezhou 802e0dfd4d5Shanjiezhou impl<'a, K: Ord + 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> { 803e0dfd4d5Shanjiezhou #[inline] 804e0dfd4d5Shanjiezhou fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { 805e0dfd4d5Shanjiezhou if self.len == 0 { 806e0dfd4d5Shanjiezhou return None; 807e0dfd4d5Shanjiezhou } 808e0dfd4d5Shanjiezhou 809e0dfd4d5Shanjiezhou if self.tail == self.head { 810e0dfd4d5Shanjiezhou return None; 811e0dfd4d5Shanjiezhou } 812e0dfd4d5Shanjiezhou 813e0dfd4d5Shanjiezhou let (k, v) = unsafe { (&(*self.tail.0).key, &mut (*self.tail.0).value) }; 814e0dfd4d5Shanjiezhou self.tail = self.tail.prev(); 815e0dfd4d5Shanjiezhou self.len -= 1; 816e0dfd4d5Shanjiezhou Some((k, v)) 817e0dfd4d5Shanjiezhou } 818e0dfd4d5Shanjiezhou } 819e0dfd4d5Shanjiezhou 820e0dfd4d5Shanjiezhou impl<K: Ord, V> IntoIterator for RBTree<K, V> { 821e0dfd4d5Shanjiezhou type Item = (K, V); 822e0dfd4d5Shanjiezhou type IntoIter = IntoIter<K, V>; 823e0dfd4d5Shanjiezhou 824e0dfd4d5Shanjiezhou #[inline] 825e0dfd4d5Shanjiezhou fn into_iter(mut self) -> IntoIter<K, V> { 826e0dfd4d5Shanjiezhou let iter = if self.root.is_null() { 827e0dfd4d5Shanjiezhou IntoIter { 828e0dfd4d5Shanjiezhou head: NodePtr::null(), 829e0dfd4d5Shanjiezhou tail: NodePtr::null(), 830e0dfd4d5Shanjiezhou len: self.len, 831e0dfd4d5Shanjiezhou } 832e0dfd4d5Shanjiezhou } else { 833e0dfd4d5Shanjiezhou IntoIter { 834e0dfd4d5Shanjiezhou head: self.first_child(), 835e0dfd4d5Shanjiezhou tail: self.last_child(), 836e0dfd4d5Shanjiezhou len: self.len, 837e0dfd4d5Shanjiezhou } 838e0dfd4d5Shanjiezhou }; 839e0dfd4d5Shanjiezhou self.fast_clear(); 840e0dfd4d5Shanjiezhou iter 841e0dfd4d5Shanjiezhou } 842e0dfd4d5Shanjiezhou } 843e0dfd4d5Shanjiezhou 844e0dfd4d5Shanjiezhou impl<K: Ord, V> RBTree<K, V> { 845e0dfd4d5Shanjiezhou /// Creates an empty `RBTree`. 846e0dfd4d5Shanjiezhou pub fn new() -> RBTree<K, V> { 847e0dfd4d5Shanjiezhou RBTree { 848e0dfd4d5Shanjiezhou root: NodePtr::null(), 849e0dfd4d5Shanjiezhou len: 0, 850e0dfd4d5Shanjiezhou } 851e0dfd4d5Shanjiezhou } 852e0dfd4d5Shanjiezhou 853e0dfd4d5Shanjiezhou /// Returns the len of `RBTree`. 854e0dfd4d5Shanjiezhou #[inline] 855e0dfd4d5Shanjiezhou pub fn len(&self) -> usize { 856e0dfd4d5Shanjiezhou self.len 857e0dfd4d5Shanjiezhou } 858e0dfd4d5Shanjiezhou 859e0dfd4d5Shanjiezhou /// Returns `true` if the `RBTree` is empty. 860e0dfd4d5Shanjiezhou #[inline] 861e0dfd4d5Shanjiezhou pub fn is_empty(&self) -> bool { 862e0dfd4d5Shanjiezhou self.root.is_null() 863e0dfd4d5Shanjiezhou } 864e0dfd4d5Shanjiezhou 865e0dfd4d5Shanjiezhou /* 866e0dfd4d5Shanjiezhou * 对红黑树的节点(x)进行左旋转 867e0dfd4d5Shanjiezhou * 868e0dfd4d5Shanjiezhou * 左旋示意图(对节点x进行左旋): 869e0dfd4d5Shanjiezhou * px px 870e0dfd4d5Shanjiezhou * / / 871e0dfd4d5Shanjiezhou * x y 872e0dfd4d5Shanjiezhou * / \ --(左旋)--> / \ # 873e0dfd4d5Shanjiezhou * lx y x ry 874e0dfd4d5Shanjiezhou * / \ / \ 875e0dfd4d5Shanjiezhou * ly ry lx ly 876e0dfd4d5Shanjiezhou * 877e0dfd4d5Shanjiezhou * 878e0dfd4d5Shanjiezhou */ 879e0dfd4d5Shanjiezhou #[inline] 880e0dfd4d5Shanjiezhou unsafe fn left_rotate(&mut self, mut node: NodePtr<K, V>) { 881e0dfd4d5Shanjiezhou let mut temp = node.right(); 882e0dfd4d5Shanjiezhou node.set_right(temp.left()); 883e0dfd4d5Shanjiezhou 884e0dfd4d5Shanjiezhou if !temp.left().is_null() { 885e0dfd4d5Shanjiezhou temp.left().set_parent(node.clone()); 886e0dfd4d5Shanjiezhou } 887e0dfd4d5Shanjiezhou 888e0dfd4d5Shanjiezhou temp.set_parent(node.parent()); 889e0dfd4d5Shanjiezhou if node == self.root { 890e0dfd4d5Shanjiezhou self.root = temp.clone(); 891e0dfd4d5Shanjiezhou } else if node == node.parent().left() { 892e0dfd4d5Shanjiezhou node.parent().set_left(temp.clone()); 893e0dfd4d5Shanjiezhou } else { 894e0dfd4d5Shanjiezhou node.parent().set_right(temp.clone()); 895e0dfd4d5Shanjiezhou } 896e0dfd4d5Shanjiezhou 897e0dfd4d5Shanjiezhou temp.set_left(node.clone()); 898e0dfd4d5Shanjiezhou node.set_parent(temp.clone()); 899e0dfd4d5Shanjiezhou } 900e0dfd4d5Shanjiezhou 901e0dfd4d5Shanjiezhou /* 902e0dfd4d5Shanjiezhou * 对红黑树的节点(y)进行右旋转 903e0dfd4d5Shanjiezhou * 904e0dfd4d5Shanjiezhou * 右旋示意图(对节点y进行左旋): 905e0dfd4d5Shanjiezhou * py py 906e0dfd4d5Shanjiezhou * / / 907e0dfd4d5Shanjiezhou * y x 908e0dfd4d5Shanjiezhou * / \ --(右旋)--> / \ # 909e0dfd4d5Shanjiezhou * x ry lx y 910e0dfd4d5Shanjiezhou * / \ / \ # 911e0dfd4d5Shanjiezhou * lx rx rx ry 912e0dfd4d5Shanjiezhou * 913e0dfd4d5Shanjiezhou */ 914e0dfd4d5Shanjiezhou #[inline] 915e0dfd4d5Shanjiezhou unsafe fn right_rotate(&mut self, mut node: NodePtr<K, V>) { 916e0dfd4d5Shanjiezhou let mut temp = node.left(); 917e0dfd4d5Shanjiezhou node.set_left(temp.right()); 918e0dfd4d5Shanjiezhou 919e0dfd4d5Shanjiezhou if !temp.right().is_null() { 920e0dfd4d5Shanjiezhou temp.right().set_parent(node.clone()); 921e0dfd4d5Shanjiezhou } 922e0dfd4d5Shanjiezhou 923e0dfd4d5Shanjiezhou temp.set_parent(node.parent()); 924e0dfd4d5Shanjiezhou if node == self.root { 925e0dfd4d5Shanjiezhou self.root = temp.clone(); 926e0dfd4d5Shanjiezhou } else if node == node.parent().right() { 927e0dfd4d5Shanjiezhou node.parent().set_right(temp.clone()); 928e0dfd4d5Shanjiezhou } else { 929e0dfd4d5Shanjiezhou node.parent().set_left(temp.clone()); 930e0dfd4d5Shanjiezhou } 931e0dfd4d5Shanjiezhou 932e0dfd4d5Shanjiezhou temp.set_right(node.clone()); 933e0dfd4d5Shanjiezhou node.set_parent(temp.clone()); 934e0dfd4d5Shanjiezhou } 935e0dfd4d5Shanjiezhou 936e0dfd4d5Shanjiezhou /// replace value if key exist, if not exist insert it. 937e0dfd4d5Shanjiezhou /// # Examples 938e0dfd4d5Shanjiezhou /// ``` 939e0dfd4d5Shanjiezhou /// use rbtree::RBTree; 940e0dfd4d5Shanjiezhou /// let mut m = RBTree::new(); 941e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 0); 942e0dfd4d5Shanjiezhou /// m.insert(2, 4); 943e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 1); 944e0dfd4d5Shanjiezhou /// assert_eq!(m.replace_or_insert(2, 6).unwrap(), 4); 945e0dfd4d5Shanjiezhou /// assert_eq!(m.len(), 1); 946e0dfd4d5Shanjiezhou /// assert_eq!(*m.get(&2).unwrap(), 6); 947e0dfd4d5Shanjiezhou /// ``` 948e0dfd4d5Shanjiezhou #[inline] 949e0dfd4d5Shanjiezhou pub fn replace_or_insert(&mut self, k: K, mut v: V) -> Option<V> { 950e0dfd4d5Shanjiezhou let node = self.find_node(&k); 951e0dfd4d5Shanjiezhou if node.is_null() { 952e0dfd4d5Shanjiezhou self.insert(k, v); 953e0dfd4d5Shanjiezhou return None; 954e0dfd4d5Shanjiezhou } 955e0dfd4d5Shanjiezhou 956e0dfd4d5Shanjiezhou unsafe { 957e0dfd4d5Shanjiezhou mem::swap(&mut v, &mut (*node.0).value); 958e0dfd4d5Shanjiezhou } 959e0dfd4d5Shanjiezhou 960e0dfd4d5Shanjiezhou Some(v) 961e0dfd4d5Shanjiezhou } 962e0dfd4d5Shanjiezhou 963e0dfd4d5Shanjiezhou #[inline] 964e0dfd4d5Shanjiezhou unsafe fn insert_fixup(&mut self, mut node: NodePtr<K, V>) { 965e0dfd4d5Shanjiezhou let mut parent; 966e0dfd4d5Shanjiezhou let mut gparent; 967e0dfd4d5Shanjiezhou 968e0dfd4d5Shanjiezhou while node.parent().is_red_color() { 969e0dfd4d5Shanjiezhou parent = node.parent(); 970e0dfd4d5Shanjiezhou gparent = parent.parent(); 971e0dfd4d5Shanjiezhou //若“父节点”是“祖父节点的左孩子” 972e0dfd4d5Shanjiezhou if parent == gparent.left() { 973e0dfd4d5Shanjiezhou // Case 1条件:叔叔节点是红色 974e0dfd4d5Shanjiezhou let mut uncle = gparent.right(); 975e0dfd4d5Shanjiezhou if !uncle.is_null() && uncle.is_red_color() { 976e0dfd4d5Shanjiezhou uncle.set_black_color(); 977e0dfd4d5Shanjiezhou parent.set_black_color(); 978e0dfd4d5Shanjiezhou gparent.set_red_color(); 979e0dfd4d5Shanjiezhou node = gparent; 980e0dfd4d5Shanjiezhou continue; 981e0dfd4d5Shanjiezhou } 982e0dfd4d5Shanjiezhou 983e0dfd4d5Shanjiezhou // Case 2条件:叔叔是黑色,且当前节点是右孩子 984e0dfd4d5Shanjiezhou if parent.right() == node { 985e0dfd4d5Shanjiezhou self.left_rotate(parent); 986e0dfd4d5Shanjiezhou let temp = parent; 987e0dfd4d5Shanjiezhou parent = node; 988e0dfd4d5Shanjiezhou node = temp; 989e0dfd4d5Shanjiezhou } 990e0dfd4d5Shanjiezhou 991e0dfd4d5Shanjiezhou // Case 3条件:叔叔是黑色,且当前节点是左孩子。 992e0dfd4d5Shanjiezhou parent.set_black_color(); 993e0dfd4d5Shanjiezhou gparent.set_red_color(); 994e0dfd4d5Shanjiezhou self.right_rotate(gparent); 995e0dfd4d5Shanjiezhou } else { 996e0dfd4d5Shanjiezhou // Case 1条件:叔叔节点是红色 997e0dfd4d5Shanjiezhou let mut uncle = gparent.left(); 998e0dfd4d5Shanjiezhou if !uncle.is_null() && uncle.is_red_color() { 999e0dfd4d5Shanjiezhou uncle.set_black_color(); 1000e0dfd4d5Shanjiezhou parent.set_black_color(); 1001e0dfd4d5Shanjiezhou gparent.set_red_color(); 1002e0dfd4d5Shanjiezhou node = gparent; 1003e0dfd4d5Shanjiezhou continue; 1004e0dfd4d5Shanjiezhou } 1005e0dfd4d5Shanjiezhou 1006e0dfd4d5Shanjiezhou // Case 2条件:叔叔是黑色,且当前节点是右孩子 1007e0dfd4d5Shanjiezhou if parent.left() == node { 1008e0dfd4d5Shanjiezhou self.right_rotate(parent); 1009e0dfd4d5Shanjiezhou let temp = parent; 1010e0dfd4d5Shanjiezhou parent = node; 1011e0dfd4d5Shanjiezhou node = temp; 1012e0dfd4d5Shanjiezhou } 1013e0dfd4d5Shanjiezhou 1014e0dfd4d5Shanjiezhou // Case 3条件:叔叔是黑色,且当前节点是左孩子。 1015e0dfd4d5Shanjiezhou parent.set_black_color(); 1016e0dfd4d5Shanjiezhou gparent.set_red_color(); 1017e0dfd4d5Shanjiezhou self.left_rotate(gparent); 1018e0dfd4d5Shanjiezhou } 1019e0dfd4d5Shanjiezhou } 1020e0dfd4d5Shanjiezhou self.root.set_black_color(); 1021e0dfd4d5Shanjiezhou } 1022e0dfd4d5Shanjiezhou 1023e0dfd4d5Shanjiezhou #[inline] 1024e0dfd4d5Shanjiezhou pub fn insert(&mut self, k: K, v: V) { 1025e0dfd4d5Shanjiezhou self.len += 1; 1026e0dfd4d5Shanjiezhou let mut node = NodePtr::new(k, v); 1027e0dfd4d5Shanjiezhou let mut y = NodePtr::null(); 1028e0dfd4d5Shanjiezhou let mut x = self.root; 1029e0dfd4d5Shanjiezhou 1030e0dfd4d5Shanjiezhou while !x.is_null() { 1031e0dfd4d5Shanjiezhou y = x; 1032e0dfd4d5Shanjiezhou match node.cmp(&&mut x) { 1033e0dfd4d5Shanjiezhou Ordering::Less => { 1034e0dfd4d5Shanjiezhou x = x.left(); 1035e0dfd4d5Shanjiezhou } 1036e0dfd4d5Shanjiezhou _ => { 1037e0dfd4d5Shanjiezhou x = x.right(); 1038e0dfd4d5Shanjiezhou } 1039e0dfd4d5Shanjiezhou }; 1040e0dfd4d5Shanjiezhou } 1041e0dfd4d5Shanjiezhou node.set_parent(y); 1042e0dfd4d5Shanjiezhou 1043e0dfd4d5Shanjiezhou if y.is_null() { 1044e0dfd4d5Shanjiezhou self.root = node; 1045e0dfd4d5Shanjiezhou } else { 1046e0dfd4d5Shanjiezhou match node.cmp(&&mut y) { 1047e0dfd4d5Shanjiezhou Ordering::Less => { 1048e0dfd4d5Shanjiezhou y.set_left(node); 1049e0dfd4d5Shanjiezhou } 1050e0dfd4d5Shanjiezhou _ => { 1051e0dfd4d5Shanjiezhou y.set_right(node); 1052e0dfd4d5Shanjiezhou } 1053e0dfd4d5Shanjiezhou }; 1054e0dfd4d5Shanjiezhou } 1055e0dfd4d5Shanjiezhou 1056e0dfd4d5Shanjiezhou node.set_red_color(); 1057e0dfd4d5Shanjiezhou unsafe { 1058e0dfd4d5Shanjiezhou self.insert_fixup(node); 1059e0dfd4d5Shanjiezhou } 1060e0dfd4d5Shanjiezhou } 1061e0dfd4d5Shanjiezhou 1062e0dfd4d5Shanjiezhou #[inline] 1063e0dfd4d5Shanjiezhou fn find_node(&self, k: &K) -> NodePtr<K, V> { 1064e0dfd4d5Shanjiezhou if self.root.is_null() { 1065e0dfd4d5Shanjiezhou return NodePtr::null(); 1066e0dfd4d5Shanjiezhou } 1067e0dfd4d5Shanjiezhou let mut temp = &self.root; 1068e0dfd4d5Shanjiezhou unsafe { 1069e0dfd4d5Shanjiezhou loop { 1070e0dfd4d5Shanjiezhou let next = match k.cmp(&(*temp.0).key) { 1071e0dfd4d5Shanjiezhou Ordering::Less => &mut (*temp.0).left, 1072e0dfd4d5Shanjiezhou Ordering::Greater => &mut (*temp.0).right, 1073e0dfd4d5Shanjiezhou Ordering::Equal => return *temp, 1074e0dfd4d5Shanjiezhou }; 1075e0dfd4d5Shanjiezhou if next.is_null() { 1076e0dfd4d5Shanjiezhou break; 1077e0dfd4d5Shanjiezhou } 1078e0dfd4d5Shanjiezhou temp = next; 1079e0dfd4d5Shanjiezhou } 1080e0dfd4d5Shanjiezhou } 1081e0dfd4d5Shanjiezhou NodePtr::null() 1082e0dfd4d5Shanjiezhou } 1083e0dfd4d5Shanjiezhou 1084e0dfd4d5Shanjiezhou #[inline] 1085e0dfd4d5Shanjiezhou fn first_child(&self) -> NodePtr<K, V> { 1086e0dfd4d5Shanjiezhou if self.root.is_null() { 1087e0dfd4d5Shanjiezhou NodePtr::null() 1088e0dfd4d5Shanjiezhou } else { 1089e0dfd4d5Shanjiezhou let mut temp = self.root; 1090e0dfd4d5Shanjiezhou while !temp.left().is_null() { 1091e0dfd4d5Shanjiezhou temp = temp.left(); 1092e0dfd4d5Shanjiezhou } 1093e0dfd4d5Shanjiezhou return temp; 1094e0dfd4d5Shanjiezhou } 1095e0dfd4d5Shanjiezhou } 1096e0dfd4d5Shanjiezhou 1097e0dfd4d5Shanjiezhou #[inline] 1098e0dfd4d5Shanjiezhou fn last_child(&self) -> NodePtr<K, V> { 1099e0dfd4d5Shanjiezhou if self.root.is_null() { 1100e0dfd4d5Shanjiezhou NodePtr::null() 1101e0dfd4d5Shanjiezhou } else { 1102e0dfd4d5Shanjiezhou let mut temp = self.root; 1103e0dfd4d5Shanjiezhou while !temp.right().is_null() { 1104e0dfd4d5Shanjiezhou temp = temp.right(); 1105e0dfd4d5Shanjiezhou } 1106e0dfd4d5Shanjiezhou return temp; 1107e0dfd4d5Shanjiezhou } 1108e0dfd4d5Shanjiezhou } 1109e0dfd4d5Shanjiezhou 1110e0dfd4d5Shanjiezhou #[inline] 1111e0dfd4d5Shanjiezhou pub fn get_first(&self) -> Option<(&K, &V)> { 1112e0dfd4d5Shanjiezhou let first = self.first_child(); 1113e0dfd4d5Shanjiezhou if first.is_null() { 1114e0dfd4d5Shanjiezhou return None; 1115e0dfd4d5Shanjiezhou } 1116e0dfd4d5Shanjiezhou unsafe { Some((&(*first.0).key, &(*first.0).value)) } 1117e0dfd4d5Shanjiezhou } 1118e0dfd4d5Shanjiezhou 1119e0dfd4d5Shanjiezhou #[inline] 1120e0dfd4d5Shanjiezhou pub fn get_last(&self) -> Option<(&K, &V)> { 1121e0dfd4d5Shanjiezhou let last = self.last_child(); 1122e0dfd4d5Shanjiezhou if last.is_null() { 1123e0dfd4d5Shanjiezhou return None; 1124e0dfd4d5Shanjiezhou } 1125e0dfd4d5Shanjiezhou unsafe { Some((&(*last.0).key, &(*last.0).value)) } 1126e0dfd4d5Shanjiezhou } 1127e0dfd4d5Shanjiezhou 1128e0dfd4d5Shanjiezhou #[inline] 1129e0dfd4d5Shanjiezhou pub fn pop_first(&mut self) -> Option<(K, V)> { 1130e0dfd4d5Shanjiezhou let first = self.first_child(); 1131e0dfd4d5Shanjiezhou if first.is_null() { 1132e0dfd4d5Shanjiezhou return None; 1133e0dfd4d5Shanjiezhou } 1134e0dfd4d5Shanjiezhou unsafe { Some(self.delete(first)) } 1135e0dfd4d5Shanjiezhou } 1136e0dfd4d5Shanjiezhou 1137e0dfd4d5Shanjiezhou #[inline] 1138e0dfd4d5Shanjiezhou pub fn pop_last(&mut self) -> Option<(K, V)> { 1139e0dfd4d5Shanjiezhou let last = self.last_child(); 1140e0dfd4d5Shanjiezhou if last.is_null() { 1141e0dfd4d5Shanjiezhou return None; 1142e0dfd4d5Shanjiezhou } 1143e0dfd4d5Shanjiezhou unsafe { Some(self.delete(last)) } 1144e0dfd4d5Shanjiezhou } 1145e0dfd4d5Shanjiezhou 1146e0dfd4d5Shanjiezhou #[inline] 1147e0dfd4d5Shanjiezhou pub fn get_first_mut(&mut self) -> Option<(&K, &mut V)> { 1148e0dfd4d5Shanjiezhou let first = self.first_child(); 1149e0dfd4d5Shanjiezhou if first.is_null() { 1150e0dfd4d5Shanjiezhou return None; 1151e0dfd4d5Shanjiezhou } 1152e0dfd4d5Shanjiezhou unsafe { Some((&(*first.0).key, &mut (*first.0).value)) } 1153e0dfd4d5Shanjiezhou } 1154e0dfd4d5Shanjiezhou 1155e0dfd4d5Shanjiezhou #[inline] 1156e0dfd4d5Shanjiezhou pub fn get_last_mut(&mut self) -> Option<(&K, &mut V)> { 1157e0dfd4d5Shanjiezhou let last = self.last_child(); 1158e0dfd4d5Shanjiezhou if last.is_null() { 1159e0dfd4d5Shanjiezhou return None; 1160e0dfd4d5Shanjiezhou } 1161e0dfd4d5Shanjiezhou unsafe { Some((&(*last.0).key, &mut (*last.0).value)) } 1162e0dfd4d5Shanjiezhou } 1163e0dfd4d5Shanjiezhou 1164e0dfd4d5Shanjiezhou #[inline] 1165e0dfd4d5Shanjiezhou pub fn get(&self, k: &K) -> Option<&V> { 1166e0dfd4d5Shanjiezhou let node = self.find_node(k); 1167e0dfd4d5Shanjiezhou if node.is_null() { 1168e0dfd4d5Shanjiezhou return None; 1169e0dfd4d5Shanjiezhou } 1170e0dfd4d5Shanjiezhou 1171e0dfd4d5Shanjiezhou unsafe { Some(&(*node.0).value) } 1172e0dfd4d5Shanjiezhou } 1173e0dfd4d5Shanjiezhou 1174e0dfd4d5Shanjiezhou #[inline] 1175e0dfd4d5Shanjiezhou pub fn get_mut(&mut self, k: &K) -> Option<&mut V> { 1176e0dfd4d5Shanjiezhou let node = self.find_node(k); 1177e0dfd4d5Shanjiezhou if node.is_null() { 1178e0dfd4d5Shanjiezhou return None; 1179e0dfd4d5Shanjiezhou } 1180e0dfd4d5Shanjiezhou 1181e0dfd4d5Shanjiezhou unsafe { Some(&mut (*node.0).value) } 1182e0dfd4d5Shanjiezhou } 1183e0dfd4d5Shanjiezhou 1184e0dfd4d5Shanjiezhou #[inline] 1185e0dfd4d5Shanjiezhou pub fn contains_key(&self, k: &K) -> bool { 1186e0dfd4d5Shanjiezhou let node = self.find_node(k); 1187e0dfd4d5Shanjiezhou if node.is_null() { 1188e0dfd4d5Shanjiezhou return false; 1189e0dfd4d5Shanjiezhou } 1190e0dfd4d5Shanjiezhou true 1191e0dfd4d5Shanjiezhou } 1192e0dfd4d5Shanjiezhou 1193e0dfd4d5Shanjiezhou #[inline] 1194e0dfd4d5Shanjiezhou fn clear_recurse(&mut self, current: NodePtr<K, V>) { 1195e0dfd4d5Shanjiezhou if !current.is_null() { 1196e0dfd4d5Shanjiezhou unsafe { 1197e0dfd4d5Shanjiezhou self.clear_recurse(current.left()); 1198e0dfd4d5Shanjiezhou self.clear_recurse(current.right()); 1199e0dfd4d5Shanjiezhou drop(Box::from_raw(current.0)); 1200e0dfd4d5Shanjiezhou } 1201e0dfd4d5Shanjiezhou } 1202e0dfd4d5Shanjiezhou } 1203e0dfd4d5Shanjiezhou 1204e0dfd4d5Shanjiezhou #[inline] 1205e0dfd4d5Shanjiezhou pub fn clear(&mut self) { 1206e0dfd4d5Shanjiezhou let root = self.root; 1207e0dfd4d5Shanjiezhou self.root = NodePtr::null(); 1208e0dfd4d5Shanjiezhou self.clear_recurse(root); 1209e0dfd4d5Shanjiezhou } 1210e0dfd4d5Shanjiezhou 1211e0dfd4d5Shanjiezhou /// Empties the `RBTree` without freeing objects in it. 1212e0dfd4d5Shanjiezhou #[inline] 1213e0dfd4d5Shanjiezhou fn fast_clear(&mut self) { 1214e0dfd4d5Shanjiezhou self.root = NodePtr::null(); 1215e0dfd4d5Shanjiezhou } 1216e0dfd4d5Shanjiezhou 1217e0dfd4d5Shanjiezhou #[inline] 1218e0dfd4d5Shanjiezhou pub fn remove(&mut self, k: &K) -> Option<V> { 1219e0dfd4d5Shanjiezhou let node = self.find_node(k); 1220e0dfd4d5Shanjiezhou if node.is_null() { 1221e0dfd4d5Shanjiezhou return None; 1222e0dfd4d5Shanjiezhou } 1223e0dfd4d5Shanjiezhou unsafe { Some(self.delete(node).1) } 1224e0dfd4d5Shanjiezhou } 1225e0dfd4d5Shanjiezhou 1226e0dfd4d5Shanjiezhou #[inline] 1227e0dfd4d5Shanjiezhou unsafe fn delete_fixup(&mut self, mut node: NodePtr<K, V>, mut parent: NodePtr<K, V>) { 1228e0dfd4d5Shanjiezhou let mut other; 1229e0dfd4d5Shanjiezhou while node != self.root && node.is_black_color() { 1230e0dfd4d5Shanjiezhou if parent.left() == node { 1231e0dfd4d5Shanjiezhou other = parent.right(); 1232e0dfd4d5Shanjiezhou //x的兄弟w是红色的 1233e0dfd4d5Shanjiezhou if other.is_red_color() { 1234e0dfd4d5Shanjiezhou other.set_black_color(); 1235e0dfd4d5Shanjiezhou parent.set_red_color(); 1236e0dfd4d5Shanjiezhou self.left_rotate(parent); 1237e0dfd4d5Shanjiezhou other = parent.right(); 1238e0dfd4d5Shanjiezhou } 1239e0dfd4d5Shanjiezhou 1240e0dfd4d5Shanjiezhou //x的兄弟w是黑色,且w的俩个孩子也都是黑色的 1241e0dfd4d5Shanjiezhou if other.left().is_black_color() && other.right().is_black_color() { 1242e0dfd4d5Shanjiezhou other.set_red_color(); 1243e0dfd4d5Shanjiezhou node = parent; 1244e0dfd4d5Shanjiezhou parent = node.parent(); 1245e0dfd4d5Shanjiezhou } else { 1246e0dfd4d5Shanjiezhou //x的兄弟w是黑色的,并且w的左孩子是红色,右孩子为黑色。 1247e0dfd4d5Shanjiezhou if other.right().is_black_color() { 1248e0dfd4d5Shanjiezhou other.left().set_black_color(); 1249e0dfd4d5Shanjiezhou other.set_red_color(); 1250e0dfd4d5Shanjiezhou self.right_rotate(other); 1251e0dfd4d5Shanjiezhou other = parent.right(); 1252e0dfd4d5Shanjiezhou } 1253e0dfd4d5Shanjiezhou //x的兄弟w是黑色的;并且w的右孩子是红色的,左孩子任意颜色。 1254e0dfd4d5Shanjiezhou other.set_color(parent.get_color()); 1255e0dfd4d5Shanjiezhou parent.set_black_color(); 1256e0dfd4d5Shanjiezhou other.right().set_black_color(); 1257e0dfd4d5Shanjiezhou self.left_rotate(parent); 1258e0dfd4d5Shanjiezhou node = self.root; 1259e0dfd4d5Shanjiezhou break; 1260e0dfd4d5Shanjiezhou } 1261e0dfd4d5Shanjiezhou } else { 1262e0dfd4d5Shanjiezhou other = parent.left(); 1263e0dfd4d5Shanjiezhou //x的兄弟w是红色的 1264e0dfd4d5Shanjiezhou if other.is_red_color() { 1265e0dfd4d5Shanjiezhou other.set_black_color(); 1266e0dfd4d5Shanjiezhou parent.set_red_color(); 1267e0dfd4d5Shanjiezhou self.right_rotate(parent); 1268e0dfd4d5Shanjiezhou other = parent.left(); 1269e0dfd4d5Shanjiezhou } 1270e0dfd4d5Shanjiezhou 1271e0dfd4d5Shanjiezhou //x的兄弟w是黑色,且w的俩个孩子也都是黑色的 1272e0dfd4d5Shanjiezhou if other.left().is_black_color() && other.right().is_black_color() { 1273e0dfd4d5Shanjiezhou other.set_red_color(); 1274e0dfd4d5Shanjiezhou node = parent; 1275e0dfd4d5Shanjiezhou parent = node.parent(); 1276e0dfd4d5Shanjiezhou } else { 1277e0dfd4d5Shanjiezhou //x的兄弟w是黑色的,并且w的左孩子是红色,右孩子为黑色。 1278e0dfd4d5Shanjiezhou if other.left().is_black_color() { 1279e0dfd4d5Shanjiezhou other.right().set_black_color(); 1280e0dfd4d5Shanjiezhou other.set_red_color(); 1281e0dfd4d5Shanjiezhou self.left_rotate(other); 1282e0dfd4d5Shanjiezhou other = parent.left(); 1283e0dfd4d5Shanjiezhou } 1284e0dfd4d5Shanjiezhou //x的兄弟w是黑色的;并且w的右孩子是红色的,左孩子任意颜色。 1285e0dfd4d5Shanjiezhou other.set_color(parent.get_color()); 1286e0dfd4d5Shanjiezhou parent.set_black_color(); 1287e0dfd4d5Shanjiezhou other.left().set_black_color(); 1288e0dfd4d5Shanjiezhou self.right_rotate(parent); 1289e0dfd4d5Shanjiezhou node = self.root; 1290e0dfd4d5Shanjiezhou break; 1291e0dfd4d5Shanjiezhou } 1292e0dfd4d5Shanjiezhou } 1293e0dfd4d5Shanjiezhou } 1294e0dfd4d5Shanjiezhou 1295e0dfd4d5Shanjiezhou node.set_black_color(); 1296e0dfd4d5Shanjiezhou } 1297e0dfd4d5Shanjiezhou 1298e0dfd4d5Shanjiezhou #[inline] 1299e0dfd4d5Shanjiezhou unsafe fn delete(&mut self, node: NodePtr<K, V>) -> (K, V) { 1300e0dfd4d5Shanjiezhou let mut child; 1301e0dfd4d5Shanjiezhou let mut parent; 1302e0dfd4d5Shanjiezhou let color; 1303e0dfd4d5Shanjiezhou 1304e0dfd4d5Shanjiezhou self.len -= 1; 1305e0dfd4d5Shanjiezhou // 被删除节点的"左右孩子都不为空"的情况。 1306e0dfd4d5Shanjiezhou if !node.left().is_null() && !node.right().is_null() { 1307e0dfd4d5Shanjiezhou // 被删节点的后继节点。(称为"取代节点") 1308e0dfd4d5Shanjiezhou // 用它来取代"被删节点"的位置,然后再将"被删节点"去掉。 1309e0dfd4d5Shanjiezhou let mut replace = node.right().min_node(); 1310e0dfd4d5Shanjiezhou if node == self.root { 1311e0dfd4d5Shanjiezhou self.root = replace; 1312e0dfd4d5Shanjiezhou } else { 1313e0dfd4d5Shanjiezhou if node.parent().left() == node { 1314e0dfd4d5Shanjiezhou node.parent().set_left(replace); 1315e0dfd4d5Shanjiezhou } else { 1316e0dfd4d5Shanjiezhou node.parent().set_right(replace); 1317e0dfd4d5Shanjiezhou } 1318e0dfd4d5Shanjiezhou } 1319e0dfd4d5Shanjiezhou 1320e0dfd4d5Shanjiezhou // child是"取代节点"的右孩子,也是需要"调整的节点"。 1321e0dfd4d5Shanjiezhou // "取代节点"肯定不存在左孩子!因为它是一个后继节点。 1322e0dfd4d5Shanjiezhou child = replace.right(); 1323e0dfd4d5Shanjiezhou parent = replace.parent(); 1324e0dfd4d5Shanjiezhou color = replace.get_color(); 1325e0dfd4d5Shanjiezhou if parent == node { 1326e0dfd4d5Shanjiezhou parent = replace; 1327e0dfd4d5Shanjiezhou } else { 1328e0dfd4d5Shanjiezhou if !child.is_null() { 1329e0dfd4d5Shanjiezhou child.set_parent(parent); 1330e0dfd4d5Shanjiezhou } 1331e0dfd4d5Shanjiezhou parent.set_left(child); 1332e0dfd4d5Shanjiezhou replace.set_right(node.right()); 1333e0dfd4d5Shanjiezhou node.right().set_parent(replace); 1334e0dfd4d5Shanjiezhou } 1335e0dfd4d5Shanjiezhou 1336e0dfd4d5Shanjiezhou replace.set_parent(node.parent()); 1337e0dfd4d5Shanjiezhou replace.set_color(node.get_color()); 1338e0dfd4d5Shanjiezhou replace.set_left(node.left()); 1339e0dfd4d5Shanjiezhou node.left().set_parent(replace); 1340e0dfd4d5Shanjiezhou 1341e0dfd4d5Shanjiezhou if color == Color::Black { 1342e0dfd4d5Shanjiezhou self.delete_fixup(child, parent); 1343e0dfd4d5Shanjiezhou } 1344e0dfd4d5Shanjiezhou 1345e0dfd4d5Shanjiezhou let obj = Box::from_raw(node.0); 1346e0dfd4d5Shanjiezhou return obj.pair(); 1347e0dfd4d5Shanjiezhou } 1348e0dfd4d5Shanjiezhou 1349e0dfd4d5Shanjiezhou if !node.left().is_null() { 1350e0dfd4d5Shanjiezhou child = node.left(); 1351e0dfd4d5Shanjiezhou } else { 1352e0dfd4d5Shanjiezhou child = node.right(); 1353e0dfd4d5Shanjiezhou } 1354e0dfd4d5Shanjiezhou 1355e0dfd4d5Shanjiezhou parent = node.parent(); 1356e0dfd4d5Shanjiezhou color = node.get_color(); 1357e0dfd4d5Shanjiezhou if !child.is_null() { 1358e0dfd4d5Shanjiezhou child.set_parent(parent); 1359e0dfd4d5Shanjiezhou } 1360e0dfd4d5Shanjiezhou 1361e0dfd4d5Shanjiezhou if self.root == node { 1362e0dfd4d5Shanjiezhou self.root = child 1363e0dfd4d5Shanjiezhou } else { 1364e0dfd4d5Shanjiezhou if parent.left() == node { 1365e0dfd4d5Shanjiezhou parent.set_left(child); 1366e0dfd4d5Shanjiezhou } else { 1367e0dfd4d5Shanjiezhou parent.set_right(child); 1368e0dfd4d5Shanjiezhou } 1369e0dfd4d5Shanjiezhou } 1370e0dfd4d5Shanjiezhou 1371e0dfd4d5Shanjiezhou if color == Color::Black { 1372e0dfd4d5Shanjiezhou self.delete_fixup(child, parent); 1373e0dfd4d5Shanjiezhou } 1374e0dfd4d5Shanjiezhou 1375e0dfd4d5Shanjiezhou let obj = Box::from_raw(node.0); 1376e0dfd4d5Shanjiezhou return obj.pair(); 1377e0dfd4d5Shanjiezhou } 1378e0dfd4d5Shanjiezhou 1379e0dfd4d5Shanjiezhou /// Return the keys iter 1380e0dfd4d5Shanjiezhou #[inline] 1381e0dfd4d5Shanjiezhou pub fn keys(&self) -> Keys<K, V> { 1382e0dfd4d5Shanjiezhou Keys { inner: self.iter() } 1383e0dfd4d5Shanjiezhou } 1384e0dfd4d5Shanjiezhou 1385e0dfd4d5Shanjiezhou /// Return the value iter 1386e0dfd4d5Shanjiezhou #[inline] 1387e0dfd4d5Shanjiezhou pub fn values(&self) -> Values<K, V> { 1388e0dfd4d5Shanjiezhou Values { inner: self.iter() } 1389e0dfd4d5Shanjiezhou } 1390e0dfd4d5Shanjiezhou 1391e0dfd4d5Shanjiezhou /// Return the value iter mut 1392e0dfd4d5Shanjiezhou #[inline] 1393e0dfd4d5Shanjiezhou pub fn values_mut(&mut self) -> ValuesMut<K, V> { 139478bf93f0SYJwu2023 ValuesMut { 139578bf93f0SYJwu2023 inner: self.iter_mut(), 139678bf93f0SYJwu2023 } 1397e0dfd4d5Shanjiezhou } 1398e0dfd4d5Shanjiezhou 1399e0dfd4d5Shanjiezhou /// Return the key and value iter 1400e0dfd4d5Shanjiezhou #[inline] 1401e0dfd4d5Shanjiezhou pub fn iter(&self) -> Iter<K, V> { 1402e0dfd4d5Shanjiezhou Iter { 1403e0dfd4d5Shanjiezhou head: self.first_child(), 1404e0dfd4d5Shanjiezhou tail: self.last_child(), 1405e0dfd4d5Shanjiezhou len: self.len, 1406e0dfd4d5Shanjiezhou _marker: marker::PhantomData, 1407e0dfd4d5Shanjiezhou } 1408e0dfd4d5Shanjiezhou } 1409e0dfd4d5Shanjiezhou 1410e0dfd4d5Shanjiezhou /// Return the key and mut value iter 1411e0dfd4d5Shanjiezhou #[inline] 1412e0dfd4d5Shanjiezhou pub fn iter_mut(&mut self) -> IterMut<K, V> { 1413e0dfd4d5Shanjiezhou IterMut { 1414e0dfd4d5Shanjiezhou head: self.first_child(), 1415e0dfd4d5Shanjiezhou tail: self.last_child(), 1416e0dfd4d5Shanjiezhou len: self.len, 1417e0dfd4d5Shanjiezhou _marker: marker::PhantomData, 1418e0dfd4d5Shanjiezhou } 1419e0dfd4d5Shanjiezhou } 1420e0dfd4d5Shanjiezhou } 1421e0dfd4d5Shanjiezhou 1422fba56231SLoGin #[cfg(test)] 1423e0dfd4d5Shanjiezhou mod tests { 1424e0dfd4d5Shanjiezhou 1425e0dfd4d5Shanjiezhou #[test] 1426e0dfd4d5Shanjiezhou fn test_insert() { 1427fba56231SLoGin use crate::libs::rbtree::RBTree; 1428e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1429e0dfd4d5Shanjiezhou assert_eq!(m.len(), 0); 1430e0dfd4d5Shanjiezhou m.insert(1, 2); 1431e0dfd4d5Shanjiezhou assert_eq!(m.len(), 1); 1432e0dfd4d5Shanjiezhou m.insert(2, 4); 1433e0dfd4d5Shanjiezhou assert_eq!(m.len(), 2); 1434e0dfd4d5Shanjiezhou m.insert(2, 6); 1435e0dfd4d5Shanjiezhou assert_eq!(m.len(), 3); 1436e0dfd4d5Shanjiezhou assert_eq!(*m.get(&1).unwrap(), 2); 1437e0dfd4d5Shanjiezhou assert_eq!(*m.get(&2).unwrap(), 4); 1438e0dfd4d5Shanjiezhou assert_eq!(*m.get(&2).unwrap(), 4); 1439e0dfd4d5Shanjiezhou } 1440e0dfd4d5Shanjiezhou 1441e0dfd4d5Shanjiezhou #[test] 1442e0dfd4d5Shanjiezhou fn test_replace() { 1443fba56231SLoGin use crate::libs::rbtree::RBTree; 1444e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1445e0dfd4d5Shanjiezhou assert_eq!(m.len(), 0); 1446e0dfd4d5Shanjiezhou m.insert(2, 4); 1447e0dfd4d5Shanjiezhou assert_eq!(m.len(), 1); 1448e0dfd4d5Shanjiezhou assert_eq!(m.replace_or_insert(2, 6).unwrap(), 4); 1449e0dfd4d5Shanjiezhou assert_eq!(m.len(), 1); 1450e0dfd4d5Shanjiezhou assert_eq!(*m.get(&2).unwrap(), 6); 1451e0dfd4d5Shanjiezhou } 1452e0dfd4d5Shanjiezhou 1453e0dfd4d5Shanjiezhou #[test] 1454e0dfd4d5Shanjiezhou fn test_clone() { 1455fba56231SLoGin use crate::libs::rbtree::RBTree; 1456e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1457e0dfd4d5Shanjiezhou assert_eq!(m.len(), 0); 1458e0dfd4d5Shanjiezhou m.insert(1, 2); 1459e0dfd4d5Shanjiezhou assert_eq!(m.len(), 1); 1460e0dfd4d5Shanjiezhou m.insert(2, 4); 1461e0dfd4d5Shanjiezhou assert_eq!(m.len(), 2); 1462e0dfd4d5Shanjiezhou let m2 = m.clone(); 1463e0dfd4d5Shanjiezhou m.clear(); 1464e0dfd4d5Shanjiezhou assert_eq!(*m2.get(&1).unwrap(), 2); 1465e0dfd4d5Shanjiezhou assert_eq!(*m2.get(&2).unwrap(), 4); 1466e0dfd4d5Shanjiezhou assert_eq!(m2.len(), 2); 1467e0dfd4d5Shanjiezhou } 1468e0dfd4d5Shanjiezhou 1469e0dfd4d5Shanjiezhou #[test] 1470e0dfd4d5Shanjiezhou fn test_empty_remove() { 1471fba56231SLoGin use crate::libs::rbtree::RBTree; 1472e0dfd4d5Shanjiezhou let mut m: RBTree<isize, bool> = RBTree::new(); 1473e0dfd4d5Shanjiezhou assert_eq!(m.remove(&0), None); 1474e0dfd4d5Shanjiezhou } 1475e0dfd4d5Shanjiezhou 1476e0dfd4d5Shanjiezhou #[test] 1477e0dfd4d5Shanjiezhou fn test_empty_iter() { 1478fba56231SLoGin use crate::libs::rbtree::RBTree; 1479e0dfd4d5Shanjiezhou let mut m: RBTree<isize, bool> = RBTree::new(); 1480e0dfd4d5Shanjiezhou assert_eq!(m.iter().next(), None); 1481e0dfd4d5Shanjiezhou assert_eq!(m.iter_mut().next(), None); 1482e0dfd4d5Shanjiezhou assert_eq!(m.len(), 0); 1483e0dfd4d5Shanjiezhou assert!(m.is_empty()); 1484e0dfd4d5Shanjiezhou assert_eq!(m.into_iter().next(), None); 1485e0dfd4d5Shanjiezhou } 1486e0dfd4d5Shanjiezhou 1487e0dfd4d5Shanjiezhou #[test] 1488e0dfd4d5Shanjiezhou fn test_lots_of_insertions() { 1489fba56231SLoGin use crate::libs::rbtree::RBTree; 1490e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1491e0dfd4d5Shanjiezhou 1492e0dfd4d5Shanjiezhou // Try this a few times to make sure we never screw up the hashmap's 1493e0dfd4d5Shanjiezhou // internal state. 1494e0dfd4d5Shanjiezhou for _ in 0..10 { 1495e0dfd4d5Shanjiezhou assert!(m.is_empty()); 1496e0dfd4d5Shanjiezhou 1497e0dfd4d5Shanjiezhou for i in 1..101 { 1498e0dfd4d5Shanjiezhou m.insert(i, i); 1499e0dfd4d5Shanjiezhou 1500e0dfd4d5Shanjiezhou for j in 1..i + 1 { 1501e0dfd4d5Shanjiezhou let r = m.get(&j); 1502e0dfd4d5Shanjiezhou assert_eq!(r, Some(&j)); 1503e0dfd4d5Shanjiezhou } 1504e0dfd4d5Shanjiezhou 1505e0dfd4d5Shanjiezhou for j in i + 1..101 { 1506e0dfd4d5Shanjiezhou let r = m.get(&j); 1507e0dfd4d5Shanjiezhou assert_eq!(r, None); 1508e0dfd4d5Shanjiezhou } 1509e0dfd4d5Shanjiezhou } 1510e0dfd4d5Shanjiezhou 1511e0dfd4d5Shanjiezhou for i in 101..201 { 1512e0dfd4d5Shanjiezhou assert!(!m.contains_key(&i)); 1513e0dfd4d5Shanjiezhou } 1514e0dfd4d5Shanjiezhou 1515e0dfd4d5Shanjiezhou // remove forwards 1516e0dfd4d5Shanjiezhou for i in 1..101 { 1517e0dfd4d5Shanjiezhou assert!(m.remove(&i).is_some()); 1518e0dfd4d5Shanjiezhou 1519e0dfd4d5Shanjiezhou for j in 1..i + 1 { 1520e0dfd4d5Shanjiezhou assert!(!m.contains_key(&j)); 1521e0dfd4d5Shanjiezhou } 1522e0dfd4d5Shanjiezhou 1523e0dfd4d5Shanjiezhou for j in i + 1..101 { 1524e0dfd4d5Shanjiezhou assert!(m.contains_key(&j)); 1525e0dfd4d5Shanjiezhou } 1526e0dfd4d5Shanjiezhou } 1527e0dfd4d5Shanjiezhou 1528e0dfd4d5Shanjiezhou for i in 1..101 { 1529e0dfd4d5Shanjiezhou assert!(!m.contains_key(&i)); 1530e0dfd4d5Shanjiezhou } 1531e0dfd4d5Shanjiezhou 1532e0dfd4d5Shanjiezhou for i in 1..101 { 1533e0dfd4d5Shanjiezhou m.insert(i, i); 1534e0dfd4d5Shanjiezhou } 1535e0dfd4d5Shanjiezhou 1536e0dfd4d5Shanjiezhou // remove backwards 1537e0dfd4d5Shanjiezhou for i in (1..101).rev() { 1538e0dfd4d5Shanjiezhou assert!(m.remove(&i).is_some()); 1539e0dfd4d5Shanjiezhou 1540e0dfd4d5Shanjiezhou for j in i..101 { 1541e0dfd4d5Shanjiezhou assert!(!m.contains_key(&j)); 1542e0dfd4d5Shanjiezhou } 1543e0dfd4d5Shanjiezhou 1544e0dfd4d5Shanjiezhou for j in 1..i { 1545e0dfd4d5Shanjiezhou assert!(m.contains_key(&j)); 1546e0dfd4d5Shanjiezhou } 1547e0dfd4d5Shanjiezhou } 1548e0dfd4d5Shanjiezhou } 1549e0dfd4d5Shanjiezhou } 1550e0dfd4d5Shanjiezhou 1551e0dfd4d5Shanjiezhou #[test] 1552e0dfd4d5Shanjiezhou fn test_find_mut() { 1553fba56231SLoGin use crate::libs::rbtree::RBTree; 1554e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1555e0dfd4d5Shanjiezhou m.insert(1, 12); 1556e0dfd4d5Shanjiezhou m.insert(2, 8); 1557e0dfd4d5Shanjiezhou m.insert(5, 14); 1558e0dfd4d5Shanjiezhou let new = 100; 1559e0dfd4d5Shanjiezhou match m.get_mut(&5) { 1560e0dfd4d5Shanjiezhou None => panic!(), 1561e0dfd4d5Shanjiezhou Some(x) => *x = new, 1562e0dfd4d5Shanjiezhou } 1563e0dfd4d5Shanjiezhou assert_eq!(m.get(&5), Some(&new)); 1564e0dfd4d5Shanjiezhou } 1565e0dfd4d5Shanjiezhou 1566e0dfd4d5Shanjiezhou #[test] 1567e0dfd4d5Shanjiezhou fn test_remove() { 1568fba56231SLoGin use crate::libs::rbtree::RBTree; 1569e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1570e0dfd4d5Shanjiezhou m.insert(1, 2); 1571e0dfd4d5Shanjiezhou assert_eq!(*m.get(&1).unwrap(), 2); 1572e0dfd4d5Shanjiezhou m.insert(5, 3); 1573e0dfd4d5Shanjiezhou assert_eq!(*m.get(&5).unwrap(), 3); 1574e0dfd4d5Shanjiezhou m.insert(9, 4); 1575e0dfd4d5Shanjiezhou assert_eq!(*m.get(&1).unwrap(), 2); 1576e0dfd4d5Shanjiezhou assert_eq!(*m.get(&5).unwrap(), 3); 1577e0dfd4d5Shanjiezhou assert_eq!(*m.get(&9).unwrap(), 4); 1578e0dfd4d5Shanjiezhou assert_eq!(m.remove(&1).unwrap(), 2); 1579e0dfd4d5Shanjiezhou assert_eq!(m.remove(&5).unwrap(), 3); 1580e0dfd4d5Shanjiezhou assert_eq!(m.remove(&9).unwrap(), 4); 1581e0dfd4d5Shanjiezhou assert_eq!(m.len(), 0); 1582e0dfd4d5Shanjiezhou } 1583e0dfd4d5Shanjiezhou 1584e0dfd4d5Shanjiezhou #[test] 1585e0dfd4d5Shanjiezhou fn test_is_empty() { 1586fba56231SLoGin use crate::libs::rbtree::RBTree; 1587e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1588e0dfd4d5Shanjiezhou m.insert(1, 2); 1589e0dfd4d5Shanjiezhou assert!(!m.is_empty()); 1590e0dfd4d5Shanjiezhou assert!(m.remove(&1).is_some()); 1591e0dfd4d5Shanjiezhou assert!(m.is_empty()); 1592e0dfd4d5Shanjiezhou } 1593e0dfd4d5Shanjiezhou 1594e0dfd4d5Shanjiezhou #[test] 1595e0dfd4d5Shanjiezhou fn test_pop() { 1596fba56231SLoGin use crate::libs::rbtree::RBTree; 1597e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1598e0dfd4d5Shanjiezhou m.insert(2, 4); 1599e0dfd4d5Shanjiezhou m.insert(1, 2); 1600e0dfd4d5Shanjiezhou m.insert(3, 6); 1601e0dfd4d5Shanjiezhou assert_eq!(m.len(), 3); 1602e0dfd4d5Shanjiezhou assert_eq!(m.pop_first(), Some((1, 2))); 1603e0dfd4d5Shanjiezhou assert_eq!(m.len(), 2); 1604e0dfd4d5Shanjiezhou assert_eq!(m.pop_last(), Some((3, 6))); 1605e0dfd4d5Shanjiezhou assert_eq!(m.len(), 1); 1606e0dfd4d5Shanjiezhou assert_eq!(m.get_first(), Some((&2, &4))); 1607e0dfd4d5Shanjiezhou assert_eq!(m.get_last(), Some((&2, &4))); 1608e0dfd4d5Shanjiezhou } 1609e0dfd4d5Shanjiezhou 1610e0dfd4d5Shanjiezhou #[test] 1611e0dfd4d5Shanjiezhou fn test_iterate() { 1612fba56231SLoGin use crate::libs::rbtree::RBTree; 1613e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1614e0dfd4d5Shanjiezhou for i in 0..32 { 1615e0dfd4d5Shanjiezhou m.insert(i, i * 2); 1616e0dfd4d5Shanjiezhou } 1617e0dfd4d5Shanjiezhou assert_eq!(m.len(), 32); 1618e0dfd4d5Shanjiezhou 1619e0dfd4d5Shanjiezhou let mut observed: u32 = 0; 1620e0dfd4d5Shanjiezhou 1621e0dfd4d5Shanjiezhou for (k, v) in m.iter() { 1622e0dfd4d5Shanjiezhou assert_eq!(*v, *k * 2); 1623e0dfd4d5Shanjiezhou observed |= 1 << *k; 1624e0dfd4d5Shanjiezhou } 1625e0dfd4d5Shanjiezhou assert_eq!(observed, 0xFFFF_FFFF); 1626e0dfd4d5Shanjiezhou } 1627e0dfd4d5Shanjiezhou 1628e0dfd4d5Shanjiezhou #[test] 1629e0dfd4d5Shanjiezhou fn test_keys() { 1630fba56231SLoGin use crate::libs::rbtree::RBTree; 1631e0dfd4d5Shanjiezhou let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; 1632e0dfd4d5Shanjiezhou let map: RBTree<_, _> = vec.into_iter().collect(); 1633e0dfd4d5Shanjiezhou let keys: Vec<_> = map.keys().cloned().collect(); 1634e0dfd4d5Shanjiezhou assert_eq!(keys.len(), 3); 1635e0dfd4d5Shanjiezhou assert!(keys.contains(&1)); 1636e0dfd4d5Shanjiezhou assert!(keys.contains(&2)); 1637e0dfd4d5Shanjiezhou assert!(keys.contains(&3)); 1638e0dfd4d5Shanjiezhou } 1639e0dfd4d5Shanjiezhou 1640e0dfd4d5Shanjiezhou #[test] 1641e0dfd4d5Shanjiezhou fn test_values() { 1642fba56231SLoGin use crate::libs::rbtree::RBTree; 1643e0dfd4d5Shanjiezhou let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; 1644e0dfd4d5Shanjiezhou let map: RBTree<_, _> = vec.into_iter().collect(); 1645e0dfd4d5Shanjiezhou let values: Vec<_> = map.values().cloned().collect(); 1646e0dfd4d5Shanjiezhou assert_eq!(values.len(), 3); 1647e0dfd4d5Shanjiezhou assert!(values.contains(&'a')); 1648e0dfd4d5Shanjiezhou assert!(values.contains(&'b')); 1649e0dfd4d5Shanjiezhou assert!(values.contains(&'c')); 1650e0dfd4d5Shanjiezhou } 1651e0dfd4d5Shanjiezhou 1652e0dfd4d5Shanjiezhou #[test] 1653e0dfd4d5Shanjiezhou fn test_values_mut() { 1654fba56231SLoGin use crate::libs::rbtree::RBTree; 1655e0dfd4d5Shanjiezhou let vec = vec![(1, 1), (2, 2), (3, 3)]; 1656e0dfd4d5Shanjiezhou let mut map: RBTree<_, _> = vec.into_iter().collect(); 1657e0dfd4d5Shanjiezhou for value in map.values_mut() { 1658e0dfd4d5Shanjiezhou *value = (*value) * 2 1659e0dfd4d5Shanjiezhou } 1660e0dfd4d5Shanjiezhou let values: Vec<_> = map.values().cloned().collect(); 1661e0dfd4d5Shanjiezhou assert_eq!(values.len(), 3); 1662e0dfd4d5Shanjiezhou assert!(values.contains(&2)); 1663e0dfd4d5Shanjiezhou assert!(values.contains(&4)); 1664e0dfd4d5Shanjiezhou assert!(values.contains(&6)); 1665e0dfd4d5Shanjiezhou } 1666e0dfd4d5Shanjiezhou 1667e0dfd4d5Shanjiezhou #[test] 1668e0dfd4d5Shanjiezhou fn test_find() { 1669fba56231SLoGin use crate::libs::rbtree::RBTree; 1670e0dfd4d5Shanjiezhou let mut m = RBTree::new(); 1671e0dfd4d5Shanjiezhou assert!(m.get(&1).is_none()); 1672e0dfd4d5Shanjiezhou m.insert(1, 2); 1673e0dfd4d5Shanjiezhou match m.get(&1) { 1674e0dfd4d5Shanjiezhou None => panic!(), 1675e0dfd4d5Shanjiezhou Some(v) => assert_eq!(*v, 2), 1676e0dfd4d5Shanjiezhou } 1677e0dfd4d5Shanjiezhou } 1678e0dfd4d5Shanjiezhou 1679e0dfd4d5Shanjiezhou #[test] 1680e0dfd4d5Shanjiezhou fn test_eq() { 1681fba56231SLoGin use crate::libs::rbtree::RBTree; 1682e0dfd4d5Shanjiezhou let mut m1 = RBTree::new(); 1683e0dfd4d5Shanjiezhou m1.insert(1, 2); 1684e0dfd4d5Shanjiezhou m1.insert(2, 3); 1685e0dfd4d5Shanjiezhou m1.insert(3, 4); 1686e0dfd4d5Shanjiezhou 1687e0dfd4d5Shanjiezhou let mut m2 = RBTree::new(); 1688e0dfd4d5Shanjiezhou m2.insert(1, 2); 1689e0dfd4d5Shanjiezhou m2.insert(2, 3); 1690e0dfd4d5Shanjiezhou 1691e0dfd4d5Shanjiezhou assert!(m1 != m2); 1692e0dfd4d5Shanjiezhou 1693e0dfd4d5Shanjiezhou m2.insert(3, 4); 1694e0dfd4d5Shanjiezhou 1695e0dfd4d5Shanjiezhou assert_eq!(m1, m2); 1696e0dfd4d5Shanjiezhou } 1697e0dfd4d5Shanjiezhou 1698e0dfd4d5Shanjiezhou #[test] 1699e0dfd4d5Shanjiezhou fn test_show() { 1700fba56231SLoGin use crate::libs::rbtree::RBTree; 1701e0dfd4d5Shanjiezhou let mut map = RBTree::new(); 1702e0dfd4d5Shanjiezhou let empty: RBTree<i32, i32> = RBTree::new(); 1703e0dfd4d5Shanjiezhou 1704e0dfd4d5Shanjiezhou map.insert(1, 2); 1705e0dfd4d5Shanjiezhou map.insert(3, 4); 1706e0dfd4d5Shanjiezhou 1707e0dfd4d5Shanjiezhou let map_str = format!("{:?}", map); 1708e0dfd4d5Shanjiezhou 1709e0dfd4d5Shanjiezhou assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}"); 1710e0dfd4d5Shanjiezhou assert_eq!(format!("{:?}", empty), "{}"); 1711e0dfd4d5Shanjiezhou } 1712e0dfd4d5Shanjiezhou 1713e0dfd4d5Shanjiezhou #[test] 1714e0dfd4d5Shanjiezhou fn test_from_iter() { 1715fba56231SLoGin use crate::libs::rbtree::RBTree; 1716e0dfd4d5Shanjiezhou let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; 1717e0dfd4d5Shanjiezhou 1718e0dfd4d5Shanjiezhou let map: RBTree<_, _> = xs.iter().cloned().collect(); 1719e0dfd4d5Shanjiezhou 1720e0dfd4d5Shanjiezhou for &(k, v) in &xs { 1721e0dfd4d5Shanjiezhou assert_eq!(map.get(&k), Some(&v)); 1722e0dfd4d5Shanjiezhou } 1723e0dfd4d5Shanjiezhou } 1724e0dfd4d5Shanjiezhou 1725e0dfd4d5Shanjiezhou #[test] 1726e0dfd4d5Shanjiezhou fn test_size_hint() { 1727fba56231SLoGin use crate::libs::rbtree::RBTree; 1728e0dfd4d5Shanjiezhou let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; 1729e0dfd4d5Shanjiezhou 1730e0dfd4d5Shanjiezhou let map: RBTree<_, _> = xs.iter().cloned().collect(); 1731e0dfd4d5Shanjiezhou 1732e0dfd4d5Shanjiezhou let mut iter = map.iter(); 1733e0dfd4d5Shanjiezhou 1734e0dfd4d5Shanjiezhou for _ in iter.by_ref().take(3) {} 1735e0dfd4d5Shanjiezhou 1736e0dfd4d5Shanjiezhou assert_eq!(iter.size_hint(), (3, Some(3))); 1737e0dfd4d5Shanjiezhou } 1738e0dfd4d5Shanjiezhou 1739e0dfd4d5Shanjiezhou #[test] 1740e0dfd4d5Shanjiezhou fn test_iter_len() { 1741fba56231SLoGin use crate::libs::rbtree::RBTree; 1742e0dfd4d5Shanjiezhou let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; 1743e0dfd4d5Shanjiezhou 1744e0dfd4d5Shanjiezhou let map: RBTree<_, _> = xs.iter().cloned().collect(); 1745e0dfd4d5Shanjiezhou 1746e0dfd4d5Shanjiezhou let mut iter = map.iter(); 1747e0dfd4d5Shanjiezhou 1748e0dfd4d5Shanjiezhou for _ in iter.by_ref().take(3) {} 1749e0dfd4d5Shanjiezhou 1750e0dfd4d5Shanjiezhou assert_eq!(iter.count(), 3); 1751e0dfd4d5Shanjiezhou } 1752e0dfd4d5Shanjiezhou 1753e0dfd4d5Shanjiezhou #[test] 1754e0dfd4d5Shanjiezhou fn test_mut_size_hint() { 1755fba56231SLoGin use crate::libs::rbtree::RBTree; 1756e0dfd4d5Shanjiezhou let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; 1757e0dfd4d5Shanjiezhou 1758e0dfd4d5Shanjiezhou let mut map: RBTree<_, _> = xs.iter().cloned().collect(); 1759e0dfd4d5Shanjiezhou 1760e0dfd4d5Shanjiezhou let mut iter = map.iter_mut(); 1761e0dfd4d5Shanjiezhou 1762e0dfd4d5Shanjiezhou for _ in iter.by_ref().take(3) {} 1763e0dfd4d5Shanjiezhou 1764e0dfd4d5Shanjiezhou assert_eq!(iter.size_hint(), (3, Some(3))); 1765e0dfd4d5Shanjiezhou } 1766e0dfd4d5Shanjiezhou 1767e0dfd4d5Shanjiezhou #[test] 1768e0dfd4d5Shanjiezhou fn test_iter_mut_len() { 1769fba56231SLoGin use crate::libs::rbtree::RBTree; 1770e0dfd4d5Shanjiezhou let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; 1771e0dfd4d5Shanjiezhou 1772e0dfd4d5Shanjiezhou let mut map: RBTree<_, _> = xs.iter().cloned().collect(); 1773e0dfd4d5Shanjiezhou 1774e0dfd4d5Shanjiezhou let mut iter = map.iter_mut(); 1775e0dfd4d5Shanjiezhou 1776e0dfd4d5Shanjiezhou for _ in iter.by_ref().take(3) {} 1777e0dfd4d5Shanjiezhou 1778e0dfd4d5Shanjiezhou assert_eq!(iter.count(), 3); 1779e0dfd4d5Shanjiezhou } 1780e0dfd4d5Shanjiezhou 1781e0dfd4d5Shanjiezhou #[test] 1782e0dfd4d5Shanjiezhou fn test_index() { 1783fba56231SLoGin use crate::libs::rbtree::RBTree; 1784e0dfd4d5Shanjiezhou let mut map = RBTree::new(); 1785e0dfd4d5Shanjiezhou 1786e0dfd4d5Shanjiezhou map.insert(1, 2); 1787e0dfd4d5Shanjiezhou map.insert(2, 1); 1788e0dfd4d5Shanjiezhou map.insert(3, 4); 1789e0dfd4d5Shanjiezhou 1790e0dfd4d5Shanjiezhou assert_eq!(map[&2], 1); 1791e0dfd4d5Shanjiezhou } 1792e0dfd4d5Shanjiezhou 1793e0dfd4d5Shanjiezhou #[test] 1794e0dfd4d5Shanjiezhou #[should_panic] 1795e0dfd4d5Shanjiezhou fn test_index_nonexistent() { 1796fba56231SLoGin use crate::libs::rbtree::RBTree; 1797e0dfd4d5Shanjiezhou let mut map = RBTree::new(); 1798e0dfd4d5Shanjiezhou 1799e0dfd4d5Shanjiezhou map.insert(1, 2); 1800e0dfd4d5Shanjiezhou map.insert(2, 1); 1801e0dfd4d5Shanjiezhou map.insert(3, 4); 1802e0dfd4d5Shanjiezhou 1803e0dfd4d5Shanjiezhou map[&4]; 1804e0dfd4d5Shanjiezhou } 1805e0dfd4d5Shanjiezhou 1806e0dfd4d5Shanjiezhou #[test] 1807e0dfd4d5Shanjiezhou fn test_extend_iter() { 1808fba56231SLoGin use crate::libs::rbtree::RBTree; 1809e0dfd4d5Shanjiezhou let mut a = RBTree::new(); 1810e0dfd4d5Shanjiezhou a.insert(1, "one"); 1811e0dfd4d5Shanjiezhou let mut b = RBTree::new(); 1812e0dfd4d5Shanjiezhou b.insert(2, "two"); 1813e0dfd4d5Shanjiezhou b.insert(3, "three"); 1814e0dfd4d5Shanjiezhou 1815e0dfd4d5Shanjiezhou a.extend(b.into_iter()); 1816e0dfd4d5Shanjiezhou 1817e0dfd4d5Shanjiezhou assert_eq!(a.len(), 3); 1818e0dfd4d5Shanjiezhou assert_eq!(a[&1], "one"); 1819e0dfd4d5Shanjiezhou assert_eq!(a[&2], "two"); 1820e0dfd4d5Shanjiezhou assert_eq!(a[&3], "three"); 1821e0dfd4d5Shanjiezhou } 1822e0dfd4d5Shanjiezhou } 1823