├── chapter01 ├── src │ ├── lib.rs │ └── interface.rs └── Cargo.toml ├── chapter07 ├── src │ ├── lib.rs │ └── treap.rs └── Cargo.toml ├── chapter09 ├── src │ └── lib.rs └── Cargo.toml ├── .gitignore ├── chapter14 ├── src │ ├── lib.rs │ ├── blockstore.rs │ └── btree.rs └── Cargo.toml ├── chapter04 ├── src │ ├── lib.rs │ ├── skiplistsset.rs │ └── skiplistlist.rs └── Cargo.toml ├── chapter10 ├── src │ ├── lib.rs │ ├── meldableheap.rs │ └── binaryheap.rs └── Cargo.toml ├── chapter06 ├── src │ ├── lib.rs │ ├── binarytree.rs │ └── binarysearchtree.rs └── Cargo.toml ├── chapter03 ├── src │ ├── lib.rs │ ├── sllist.rs │ ├── dllist.rs │ └── selist.rs └── Cargo.toml ├── chapter12 ├── src │ ├── lib.rs │ ├── bfs.rs │ ├── dfs.rs │ ├── adjacencymatrix.rs │ └── adjacencylists.rs └── Cargo.toml ├── chapter11 ├── src │ ├── lib.rs │ ├── heapsort.rs │ ├── countingsort.rs │ ├── radixsort.rs │ ├── quicksort.rs │ └── mergesort.rs └── Cargo.toml ├── chapter08 ├── src │ ├── lib.rs │ └── scapegoattree.rs └── Cargo.toml ├── chapter02 ├── src │ ├── lib.rs │ ├── arrayqueue.rs │ ├── boundeddeque.rs │ ├── dualarraydeque.rs │ ├── arraystack.rs │ ├── rootisharraystack.rs │ └── arraydeque.rs └── Cargo.toml ├── chapter13 ├── src │ ├── lib.rs │ ├── yfasttrie.rs │ ├── binarytrie.rs │ └── xfasttrie.rs └── Cargo.toml ├── Cargo.toml ├── chapter05 ├── Cargo.toml └── src │ ├── lib.rs │ ├── chainedhashtable.rs │ └── linearhashtable.rs ├── LICENSE └── README.md /chapter01/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod interface; 2 | -------------------------------------------------------------------------------- /chapter07/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod treap; 2 | -------------------------------------------------------------------------------- /chapter09/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod redblacktree; 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | Cargo.lock 3 | /.vscode 4 | -------------------------------------------------------------------------------- /chapter14/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod blockstore; 2 | pub mod btree; 3 | -------------------------------------------------------------------------------- /chapter04/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod skiplistlist; 2 | pub mod skiplistsset; 3 | -------------------------------------------------------------------------------- /chapter10/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod binaryheap; 2 | pub mod meldableheap; 3 | -------------------------------------------------------------------------------- /chapter06/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod binarysearchtree; 2 | pub mod binarytree; 3 | -------------------------------------------------------------------------------- /chapter03/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod dllist; 2 | pub mod selist; 3 | pub mod sllist; 4 | -------------------------------------------------------------------------------- /chapter12/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod adjacencylists; 2 | pub mod adjacencymatrix; 3 | pub mod bfs; 4 | pub mod dfs; 5 | -------------------------------------------------------------------------------- /chapter11/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod countingsort; 2 | pub mod heapsort; 3 | pub mod mergesort; 4 | pub mod quicksort; 5 | pub mod radixsort; 6 | -------------------------------------------------------------------------------- /chapter08/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod scapegoattree; 2 | 3 | pub fn log32(q: usize) -> i64 { 4 | (q as f64).log(3.0 / 2.0).floor() as i64 5 | } 6 | -------------------------------------------------------------------------------- /chapter02/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod arraydeque; 2 | pub mod arrayqueue; 3 | pub mod arraystack; 4 | pub mod boundeddeque; 5 | pub mod dualarraydeque; 6 | pub mod rootisharraystack; 7 | -------------------------------------------------------------------------------- /chapter01/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter01" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /chapter13/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod binarytrie; 2 | pub mod xfasttrie; 3 | pub mod yfasttrie; 4 | 5 | pub trait USizeV { 6 | fn usize_value(&self) -> usize; 7 | } 8 | impl USizeV for i32 { 9 | fn usize_value(&self) -> usize { 10 | *self as usize 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /chapter02/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter02" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } -------------------------------------------------------------------------------- /chapter04/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter04" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | rand = "0.7.3" 12 | -------------------------------------------------------------------------------- /chapter10/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter10" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | rand = "0.7.3" 12 | -------------------------------------------------------------------------------- /chapter11/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter11" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | rand = "0.7.3" 11 | chapter10 = { path = "../chapter10" } 12 | 13 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | members = [ 3 | "chapter01", 4 | "chapter02", 5 | "chapter03", 6 | "chapter04", 7 | "chapter05", 8 | "chapter06", 9 | "chapter07", 10 | "chapter08", 11 | "chapter09", 12 | "chapter10", 13 | "chapter11", 14 | "chapter12", 15 | "chapter13", 16 | "chapter14", 17 | ] 18 | -------------------------------------------------------------------------------- /chapter03/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter03" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter02 = { path = "../chapter02" } -------------------------------------------------------------------------------- /chapter06/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter06" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter02 = { path = "../chapter02" } 12 | -------------------------------------------------------------------------------- /chapter08/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter08" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter09 = { path = "../chapter09" } 12 | rand = "0.7.3" 13 | -------------------------------------------------------------------------------- /chapter09/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter09" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter04 = { path = "../chapter04" } 12 | rand = "0.7.3" 13 | -------------------------------------------------------------------------------- /chapter07/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter07" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter09 = { path = "../chapter09" } 12 | rand = "0.7.3" 13 | 14 | -------------------------------------------------------------------------------- /chapter05/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter05" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter02 = { path = "../chapter02" } 12 | rand = "0.7.3" 13 | lazy_static = "1.4.0" 14 | -------------------------------------------------------------------------------- /chapter12/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter12" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter02 = { path = "../chapter02" } 12 | chapter03 = { path = "../chapter03" } 13 | rand = "0.7.3" 14 | -------------------------------------------------------------------------------- /chapter14/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter14" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter02 = { path = "../chapter02" } 12 | chapter09 = { path = "../chapter09" } 13 | rand = "0.7.3" 14 | -------------------------------------------------------------------------------- /chapter13/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "chapter13" 3 | version = "0.1.0" 4 | authors = ["Hayato Ohhashi "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | chapter01 = { path = "../chapter01" } 11 | chapter09 = { path = "../chapter09" } 12 | chapter05 = { path = "../chapter05" } 13 | chapter07 = { path = "../chapter07" } 14 | rand = "0.7.3" 15 | -------------------------------------------------------------------------------- /chapter05/src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod chainedhashtable; 2 | pub mod linearhashtable; 3 | 4 | use std::collections::hash_map::DefaultHasher; 5 | use std::hash::{Hash, Hasher}; 6 | 7 | pub fn hashcode(x: &T) -> usize { 8 | let mut s = DefaultHasher::new(); 9 | x.hash(&mut s); 10 | s.finish() as usize 11 | } 12 | 13 | pub fn byte_chunks_64(h: u64) -> [u8; 8] { 14 | [ 15 | (h & 0xff) as u8, 16 | ((h >> 8) & 0xff) as u8, 17 | ((h >> 16) & 0xff) as u8, 18 | ((h >> 24) & 0xff) as u8, 19 | ((h >> 32) & 0xff) as u8, 20 | ((h >> 40) & 0xff) as u8, 21 | ((h >> 48) & 0xff) as u8, 22 | ((h >> 56) & 0xff) as u8, 23 | ] 24 | } 25 | 26 | pub trait Tabulation { 27 | fn hashcode(&self) -> usize 28 | where 29 | Self: Hash, 30 | { 31 | let mut s = DefaultHasher::new(); 32 | self.hash(&mut s); 33 | s.finish() as usize 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Hayato Ohhashi 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /chapter11/src/heapsort.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter10::binaryheap::BinaryHeap; 3 | 4 | pub fn heapsort(a: &mut [T]) { 5 | BinaryHeap::sort(a); 6 | } 7 | 8 | #[cfg(test)] 9 | mod test { 10 | use super::heapsort; 11 | use rand::distributions::Standard; 12 | use rand::{thread_rng, Rng}; 13 | #[test] 14 | fn test_heapsort() { 15 | let mut a = [13, 8, 5, 2, 4, 0, 6, 9, 7, 3, 12, 1, 10, 11]; 16 | heapsort(&mut a); 17 | assert_eq!(&a, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]); 18 | //println!("{:?}", a); 19 | let mut a = [0]; 20 | heapsort(&mut a); 21 | assert_eq!(&a, &[0]); 22 | 23 | let mut rng = thread_rng(); 24 | for _ in 0u32..50000u32 { 25 | let len: usize = rng.gen(); 26 | let mut v: Vec = rng.sample_iter(&Standard).take((len % 32) + 1).collect(); 27 | heapsort(&mut v); 28 | for i in 0..v.len() - 1 { 29 | assert!(v[i] <= v[i + 1]) 30 | } 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /chapter14/src/blockstore.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::List; 3 | use chapter02::arraystack::Array as ArrayStack; 4 | 5 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 6 | pub struct BlockStore { 7 | blocks: ArrayStack, 8 | free: ArrayStack, 9 | } 10 | 11 | impl BlockStore { 12 | pub fn new() -> Self { 13 | Self { 14 | blocks: ArrayStack::new(), 15 | free: ArrayStack::new(), 16 | } 17 | } 18 | pub fn place_block(&mut self, block: T) -> usize { 19 | if self.free.size() > 0 { 20 | self.free.remove(self.free.size() - 1).unwrap() 21 | } else { 22 | let i = self.blocks.size(); 23 | self.blocks.add(i, block); 24 | i 25 | } 26 | } 27 | pub fn free_block(&mut self, i: usize) { 28 | self.blocks.take(i); 29 | self.free.add(self.free.size(), i); 30 | } 31 | pub fn read_block(&self, i: usize) -> Option { 32 | self.blocks.get(i) 33 | } 34 | pub fn write_block(&mut self, i: usize, block: T) { 35 | self.blocks.set(i, block); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /chapter01/src/interface.rs: -------------------------------------------------------------------------------- 1 | pub trait Queue { 2 | fn add(&mut self, x: T); 3 | fn remove(&mut self) -> Option; 4 | } 5 | 6 | pub trait Stack { 7 | fn push(&mut self, x: T); 8 | fn pop(&mut self) -> Option; 9 | } 10 | 11 | pub trait List { 12 | fn size(&self) -> usize; 13 | fn get(&self, i: usize) -> Option; 14 | fn set(&mut self, i: usize, x: T) -> Option; 15 | fn add(&mut self, i: usize, x: T); 16 | fn remove(&mut self, i: usize) -> Option; 17 | } 18 | 19 | pub trait USet { 20 | fn size(&self) -> usize; 21 | fn add(&mut self, x: T) -> bool; 22 | fn remove(&mut self, x: &T) -> Option; 23 | fn find(&self, x: &T) -> Option; 24 | } 25 | 26 | pub trait SSet { 27 | fn size(&self) -> usize; 28 | fn add(&mut self, x: T) -> bool; 29 | fn remove(&mut self, x: &T) -> Option; 30 | fn find(&self, x: &T) -> Option; 31 | } 32 | 33 | pub trait Graph { 34 | fn add_edge(&mut self, i: usize, j: usize); 35 | fn remove_edge(&mut self, i: usize, j: usize); 36 | fn has_edge(&self, i: usize, j: usize) -> bool; 37 | fn out_edges(&self, i: usize) -> Vec; 38 | fn in_edges(&self, i: usize) -> Vec; 39 | } 40 | -------------------------------------------------------------------------------- /chapter11/src/countingsort.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | pub fn countingsort(a: &mut [usize]) { 3 | let k = *a.iter().max().unwrap() + 1; 4 | let mut c = vec![0usize; k]; 5 | for ai in a.iter() { 6 | c[*ai] += 1; 7 | } 8 | for i in 1..k { 9 | c[i] += c[i - 1]; 10 | } 11 | let mut b = vec![0usize; a.len()]; 12 | for ai in a.iter().rev() { 13 | c[*ai] -= 1; 14 | b[c[*ai]] = *ai; 15 | } 16 | a.copy_from_slice(&b); 17 | } 18 | 19 | #[cfg(test)] 20 | mod test { 21 | use super::countingsort; 22 | use rand::distributions::Uniform; 23 | use rand::{thread_rng, Rng}; 24 | #[test] 25 | fn test_countingsort() { 26 | let mut a = [7, 2, 9, 0, 1, 2, 0, 9, 7, 4, 4, 6, 9, 1, 0, 9, 3, 2, 5, 9]; 27 | countingsort(&mut a); 28 | assert_eq!( 29 | &a, 30 | &[0, 0, 0, 1, 1, 2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9, 9, 9, 9, 9] 31 | ); 32 | let mut rng = thread_rng(); 33 | for _ in 0u32..50000u32 { 34 | let len: usize = rng.gen(); 35 | let die_range = Uniform::new_inclusive(1, 1000); 36 | let mut v: Vec = rng.sample_iter(die_range).take((len % 32) + 1).collect(); 37 | countingsort(&mut v); 38 | for i in 0..v.len() - 1 { 39 | assert!(v[i] <= v[i + 1]) 40 | } 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /chapter12/src/bfs.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use super::adjacencylists::AdjacencyLists; 3 | use chapter01::interface::{Graph, Queue}; 4 | use chapter03::sllist::SLList; 5 | 6 | pub fn bfs(g: &AdjacencyLists, r: usize) { 7 | let mut seen = vec![false; g.nvertices()]; 8 | let mut q = SLList::new(); 9 | q.add(r); 10 | if let Some(e) = seen.get_mut(r) { 11 | *e = true 12 | } 13 | while let Some(i) = q.remove() { 14 | let edges = g.out_edges(i); 15 | for j in edges.into_iter() { 16 | if !seen[j] { 17 | q.add(j); 18 | if let Some(e) = seen.get_mut(j) { 19 | *e = true 20 | } 21 | } 22 | } 23 | } 24 | } 25 | 26 | #[cfg(test)] 27 | mod test { 28 | use super::*; 29 | use rand::{thread_rng, Rng}; 30 | use std::collections::HashSet; 31 | #[test] 32 | fn test_bfs() { 33 | let n = 50; 34 | let mut adjm = AdjacencyLists::new(n); 35 | let mut set: HashSet<(usize, usize)> = HashSet::new(); 36 | let mut rng = thread_rng(); 37 | for _ in 0..(5 * n) { 38 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 39 | if !set.contains(&(i, j)) { 40 | set.insert((i, j)); 41 | adjm.add_edge(i, j); 42 | } 43 | } 44 | bfs(&adjm, 0); 45 | println!("done"); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /chapter11/src/radixsort.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | pub fn radixsort(a: &mut [usize]) { 3 | let d = 8; 4 | let w = 8 * std::mem::size_of::(); 5 | for p in 0..(w / d) { 6 | let mut c = vec![0usize; 1 << d]; 7 | let mut b = vec![0usize; a.len()]; 8 | for ai in a.iter() { 9 | c[(*ai >> (d * p)) & ((1 << d) - 1)] += 1; 10 | } 11 | for i in 1..(1 << d) { 12 | c[i] += c[i - 1]; 13 | } 14 | for ai in a.iter().rev() { 15 | c[(*ai >> (d * p)) & ((1 << d) - 1)] -= 1; 16 | b[c[(*ai >> (d * p)) & ((1 << d) - 1)]] = *ai; 17 | } 18 | a.copy_from_slice(&b); 19 | } 20 | } 21 | 22 | #[cfg(test)] 23 | mod test { 24 | use super::radixsort; 25 | use rand::distributions::Uniform; 26 | use rand::{thread_rng, Rng}; 27 | #[test] 28 | fn test_radixsort() { 29 | let mut a = [7, 2, 9, 0, 1, 2, 0, 9, 7, 4, 4, 6, 9, 1, 0, 9, 3, 2, 5, 9]; 30 | radixsort(&mut a); 31 | assert_eq!( 32 | &a, 33 | &[0, 0, 0, 1, 1, 2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9, 9, 9, 9, 9] 34 | ); 35 | let mut rng = thread_rng(); 36 | for _ in 0u32..50000u32 { 37 | let len: usize = rng.gen(); 38 | let die_range = Uniform::new_inclusive(1, 1000); 39 | let mut v: Vec = rng.sample_iter(die_range).take((len % 32) + 1).collect(); 40 | radixsort(&mut v); 41 | for i in 0..v.len() - 1 { 42 | assert!(v[i] <= v[i + 1]) 43 | } 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /chapter11/src/quicksort.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | pub fn quicksort(a: &mut [T]) { 3 | do_sort(a, 0, a.len()); 4 | } 5 | fn do_sort(a: &mut [T], i: usize, n: usize) { 6 | if n <= 1 { 7 | return; 8 | } 9 | let x = a[i + rand::random::() % n].clone(); 10 | let mut p = i; 11 | let mut j = i; 12 | let mut q = i + n; 13 | while j < q { 14 | if a.get(j) < Some(&x) { 15 | a.swap(j, p); 16 | j += 1; 17 | p += 1; 18 | } else if a.get(j) > Some(&x) { 19 | q -= 1; 20 | a.swap(j, q); 21 | } else { 22 | j += 1; 23 | } 24 | } 25 | do_sort(a, i, p - i); 26 | do_sort(a, q, n - (q - i)); 27 | } 28 | 29 | #[cfg(test)] 30 | mod test { 31 | use super::quicksort; 32 | use rand::distributions::Standard; 33 | use rand::{thread_rng, Rng}; 34 | #[test] 35 | fn test_quicksort() { 36 | let mut a = [13, 8, 5, 2, 4, 0, 6, 9, 7, 3, 12, 1, 10, 11]; 37 | quicksort(&mut a); 38 | assert_eq!(&a, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]); 39 | let mut a = [0, 0]; 40 | quicksort(&mut a); 41 | assert_eq!(&a, &[0, 0]); 42 | let mut a = [2, 0]; 43 | quicksort(&mut a); 44 | assert_eq!(&a, &[0, 2]); 45 | 46 | let mut rng = thread_rng(); 47 | for _ in 0u32..50000u32 { 48 | let len: usize = rng.gen(); 49 | let mut v: Vec = rng.sample_iter(&Standard).take((len % 32) + 1).collect(); 50 | quicksort(&mut v); 51 | for i in 0..v.len() - 1 { 52 | assert!(v[i] <= v[i + 1]) 53 | } 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /chapter11/src/mergesort.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::if_same_then_else)] 2 | pub fn mergesort(a: &mut [T]) { 3 | let mut w = a.to_vec(); 4 | if a.len() > 1 { 5 | let mid = a.len() / 2; 6 | let (a0, a1) = a.split_at_mut(mid); 7 | mergesort(a0); 8 | mergesort(a1); 9 | merge(a0, a1, &mut w); 10 | } 11 | a.clone_from_slice(&w); 12 | } 13 | 14 | fn merge(a0: &mut [T], a1: &mut [T], a: &mut [T]) { 15 | let mut i0 = 0; 16 | let mut i1 = 0; 17 | for ai in a.iter_mut() { 18 | if i0 == a0.len() { 19 | *ai = a1[i1].clone(); 20 | i1 += 1; 21 | } else if i1 == a1.len() { 22 | *ai = a0[i0].clone(); 23 | i0 += 1; 24 | } else if a0[i0] < a1[i1] { 25 | *ai = a0[i0].clone(); 26 | i0 += 1; 27 | } else { 28 | *ai = a1[i1].clone(); 29 | i1 += 1; 30 | } 31 | } 32 | } 33 | 34 | #[cfg(test)] 35 | mod test { 36 | use super::mergesort; 37 | use rand::distributions::Standard; 38 | use rand::{thread_rng, Rng}; 39 | #[test] 40 | fn test_mergesort() { 41 | let mut a = [13, 8, 5, 2, 4, 0, 6, 9, 7, 3, 12, 1, 10, 11]; 42 | mergesort(&mut a); 43 | assert_eq!(&a, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]); 44 | //println!("{:?}", a); 45 | 46 | let mut rng = thread_rng(); 47 | for _ in 0u32..50000u32 { 48 | let len: usize = rng.gen(); 49 | let mut v: Vec = rng.sample_iter(&Standard).take((len % 32) + 1).collect(); 50 | mergesort(&mut v); 51 | for i in 0..v.len() - 1 { 52 | assert!(v[i] <= v[i + 1]) 53 | } 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /chapter12/src/dfs.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use super::adjacencylists::AdjacencyLists; 3 | use chapter01::interface::{Graph, Stack}; 4 | use chapter03::sllist::SLList; 5 | 6 | #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] 7 | enum Color { 8 | White, 9 | Grey, 10 | Black, 11 | } 12 | 13 | fn do_dfs(g: &AdjacencyLists, i: usize, c: &mut [Color]) { 14 | if let Some(e) = c.get_mut(i) { 15 | *e = Color::Grey 16 | } 17 | let edges = g.out_edges(i); 18 | for j in edges.into_iter() { 19 | if let Some(Color::White) = c.get(j) { 20 | if let Some(e) = c.get_mut(j) { 21 | *e = Color::Grey 22 | } 23 | do_dfs(g, j, c); 24 | } 25 | } 26 | if let Some(e) = c.get_mut(i) { 27 | *e = Color::Black 28 | } 29 | } 30 | 31 | pub fn dfs(g: &AdjacencyLists, r: usize) { 32 | let mut c = vec![Color::White; g.nvertices()]; 33 | do_dfs(g, r, &mut c); 34 | } 35 | 36 | pub fn dfs2(g: &AdjacencyLists, r: usize) { 37 | let mut c = vec![Color::White; g.nvertices()]; 38 | let mut s = SLList::new(); 39 | s.push(r); 40 | while let Some(i) = s.pop() { 41 | if let Some(Color::White) = c.get(i) { 42 | if let Some(e) = c.get_mut(i) { 43 | *e = Color::Grey 44 | } 45 | let edges = g.out_edges(i); 46 | for j in edges.into_iter() { 47 | s.push(j); 48 | } 49 | } 50 | } 51 | } 52 | 53 | #[cfg(test)] 54 | mod test { 55 | use super::*; 56 | use rand::{thread_rng, Rng}; 57 | use std::collections::HashSet; 58 | #[test] 59 | fn test_dfs() { 60 | let n = 50; 61 | let mut adjm = AdjacencyLists::new(n); 62 | let mut set: HashSet<(usize, usize)> = HashSet::new(); 63 | let mut rng = thread_rng(); 64 | for _ in 0..(5 * n) { 65 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 66 | if !set.contains(&(i, j)) { 67 | set.insert((i, j)); 68 | adjm.add_edge(i, j); 69 | } 70 | } 71 | dfs(&adjm, 0); 72 | println!("done"); 73 | dfs2(&adjm, 0); 74 | println!("done2"); 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /chapter02/src/arrayqueue.rs: -------------------------------------------------------------------------------- 1 | use chapter01::interface::Queue; 2 | 3 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 4 | pub struct Array { 5 | a: Box<[Option]>, 6 | j: usize, 7 | n: usize, 8 | } 9 | 10 | impl Array { 11 | pub fn length(&self) -> usize { 12 | self.a.len() 13 | } 14 | 15 | pub fn new() -> Self { 16 | Self::with_length(1) 17 | } 18 | 19 | pub fn with_length(capacity: usize) -> Self { 20 | Self { 21 | a: Self::allocate_in_heap(capacity), 22 | j: 0, 23 | n: 0, 24 | } 25 | } 26 | 27 | fn allocate_in_heap(size: usize) -> Box<[Option]> { 28 | std::iter::repeat_with(Default::default) 29 | .take(size) 30 | .collect::>() 31 | .into_boxed_slice() 32 | } 33 | 34 | fn resize(&mut self) { 35 | let new_a = Self::allocate_in_heap(std::cmp::max(self.n * 2, 1)); 36 | let mut old_a = std::mem::replace(&mut self.a, new_a); 37 | for k in 0..self.n { 38 | self.a[k] = old_a[(self.j + k) % old_a.len()].take(); 39 | } 40 | self.j = 0; 41 | } 42 | } 43 | 44 | impl Queue for Array { 45 | fn add(&mut self, value: T) { 46 | if self.n + 1 >= self.length() { 47 | self.resize(); 48 | } 49 | self.a[(self.j + self.n) % self.length()] = Some(value); 50 | self.n += 1; 51 | } 52 | 53 | fn remove(&mut self) -> Option { 54 | let x = self.a[self.j].take(); 55 | self.j = (self.j + 1) % self.length(); 56 | self.n -= 1; 57 | if self.length() >= 3 * self.n { 58 | self.resize(); 59 | } 60 | x 61 | } 62 | } 63 | 64 | #[cfg(test)] 65 | mod test { 66 | use super::Array; 67 | use chapter01::interface::Queue; 68 | #[test] 69 | fn test_arrayqueue() { 70 | let mut array_queue: Array = Array::new(); 71 | for elem in "aaabc".chars() { 72 | array_queue.add(elem); 73 | } 74 | assert_eq!(array_queue.remove(), Some('a')); 75 | assert_eq!(array_queue.remove(), Some('a')); 76 | array_queue.add('d'); 77 | array_queue.add('e'); 78 | assert_eq!(array_queue.remove(), Some('a')); 79 | array_queue.add('f'); 80 | array_queue.add('g'); 81 | assert_eq!(array_queue.length(), 10); 82 | array_queue.add('h'); 83 | assert_eq!(array_queue.remove(), Some('b')); 84 | println!("\nArrayQueue = {:?}\n", array_queue); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Open Data Structures (in Rust) 2 | 3 | [Open Data Structures](https://opendatastructures.org/) is a textbook and source list about data structures. 4 | This is the Rust version of Open Data Structures. Only safe Rust. 5 | 6 | *Advice and pull requests are welcome!* 7 | 8 | * chapter01 (Interface) 9 | * [trait Queue](/chapter01/src/interface.rs#L1) 10 | * [trait Stack](/chapter01/src/interface.rs#L6) 11 | * [trait List](/chapter01/src/interface.rs#L11) 12 | * [trait USet](/chapter01/src/interface.rs#L19) 13 | * [trait SSet](/chapter01/src/interface.rs#L26) 14 | * [trait Graph](/chapter01/src/interface.rs#L33) 15 | * chapter02 (Array-Based Lists) 16 | * [ArrayStack](/chapter02/src/arraystack.rs) 17 | * [ArrayQueue](/chapter02/src/arrayqueue.rs) 18 | * [ArrayDeque](/chapter02/src/arraydeque.rs) 19 | * [BDeque](/chapter02/src/boundeddeque.rs) 20 | * [DualArrayDeque](/chapter02/src/dualarraydeque.rs) 21 | * [RootishArrayStack](/chapter02/src/rootisharraystack.rs) 22 | * chapter03 (Linked Lists) 23 | * [SLList](/chapter03/src/sllist.rs) 24 | * [DLList](/chapter03/src/dllist.rs) 25 | * [SEList](/chapter03/src/selist.rs) 26 | * chapter04 (Skiplists) 27 | * [SkiplistSSet](/chapter04/src/skiplistsset.rs) 28 | * [SkiplistList](/chapter04/src/skiplistlist.rs) 29 | * chapter05 (Hash Tables) 30 | * [ChainedHashTable](/chapter05/src/chainedhashtable.rs) 31 | * [LinearHashTable](/chapter05/src/linearhashtable.rs) 32 | * chapter06 (Binary Trees) 33 | * [BinaryTree](/chapter06/src/binarytree.rs) 34 | * [BinarySearchTree](/chapter06/src/binarysearchtree.rs) 35 | * chapter07 (Random Binary Search Trees) 36 | * [Treap](/chapter07/src/treap.rs) 37 | * chapter08 (Scapegoat Trees) 38 | * [ScapegoatTree](/chapter08/src/scapegoattree.rs) 39 | * chapter09 (Red-Black Trees) 40 | * [RedBlackTree](/chapter09/src/redblacktree.rs) 41 | * chapter10 (Heaps) 42 | * [BinaryHeap](/chapter10/src/binaryheap.rs) 43 | * [MeldableHeap](/chapter10/src/meldableheap.rs) 44 | * chapter11 (Sorting Algorithms) 45 | * [Merge-Sort](/chapter11/src/mergesort.rs) 46 | * [Quicksort](/chapter11/src/quicksort.rs) 47 | * [Heap-sort](/chapter11/src/heapsort.rs), using [BinaryHeap](/chapter10/src/binaryheap.rs#L87) 48 | * [Counting Sort](/chapter11/src/countingsort.rs) 49 | * [Radix-Sort](/chapter11/src/radixsort.rs) 50 | * chapter12 (Graphs) 51 | * [AdjacencyMatrix](/chapter12/src/adjacencymatrix.rs) 52 | * [AdjacencyLists](/chapter12/src/adjacencylists.rs) 53 | * [Breadth-First Search](/chapter12/src/bfs.rs) 54 | * [Depth-First Search](/chapter12/src/dfs.rs) 55 | * chapter13 (Data Structures for Integers) 56 | * [BinaryTrie](/chapter13/src/binarytrie.rs) 57 | * [XFastTrie](/chapter13/src/xfasttrie.rs) 58 | * [YFastTrie](/chapter13/src/yfasttrie.rs) 59 | * chapter14 (External Memory Searching) 60 | * [BTree](/chapter14/src/btree.rs) -------------------------------------------------------------------------------- /chapter03/src/sllist.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::{Queue, Stack}; 3 | use std::cell::RefCell; 4 | use std::rc::Rc; 5 | 6 | type Link = Option>>>; 7 | 8 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 9 | pub struct SLList { 10 | head: Link, 11 | tail: Link, 12 | n: usize, 13 | } 14 | 15 | impl Drop for SLList { 16 | fn drop(&mut self) { 17 | while self.remove().is_some() {} 18 | } 19 | } 20 | 21 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 22 | struct Node { 23 | x: T, 24 | next: Link, 25 | } 26 | 27 | impl Node { 28 | fn new(x: T) -> Rc> { 29 | Rc::new(RefCell::new(Self { x, next: None })) 30 | } 31 | } 32 | 33 | impl SLList { 34 | pub fn new() -> Self { 35 | Self { 36 | head: None, 37 | tail: None, 38 | n: 0, 39 | } 40 | } 41 | pub fn size(&self) -> usize { 42 | self.n 43 | } 44 | } 45 | 46 | impl Stack for SLList { 47 | fn push(&mut self, x: T) { 48 | let new = Node::new(x); 49 | match self.head.take() { 50 | Some(old) => new.borrow_mut().next = Some(old), 51 | None => self.tail = Some(new.clone()), 52 | } 53 | self.n += 1; 54 | self.head = Some(new); 55 | } 56 | fn pop(&mut self) -> Option { 57 | self.head.take().map(|old| { 58 | if let Some(next) = old.borrow_mut().next.take() { 59 | self.head = Some(next); 60 | } else { 61 | self.tail.take(); 62 | } 63 | self.n -= 1; 64 | Rc::try_unwrap(old).ok().unwrap().into_inner().x 65 | }) 66 | } 67 | } 68 | 69 | impl Queue for SLList { 70 | fn add(&mut self, x: T) { 71 | let new = Node::new(x); 72 | match self.tail.take() { 73 | Some(old) => old.borrow_mut().next = Some(new.clone()), 74 | None => self.head = Some(new.clone()), 75 | } 76 | self.n += 1; 77 | self.tail = Some(new); 78 | } 79 | fn remove(&mut self) -> Option { 80 | self.head.take().map(|old| { 81 | if let Some(next) = old.borrow_mut().next.take() { 82 | self.head = Some(next); 83 | } else { 84 | self.tail.take(); 85 | } 86 | self.n -= 1; 87 | Rc::try_unwrap(old).ok().unwrap().into_inner().x 88 | }) 89 | } 90 | } 91 | 92 | #[cfg(test)] 93 | mod test { 94 | use super::SLList; 95 | use chapter01::interface::{Queue, Stack}; 96 | #[test] 97 | fn test_sllist() { 98 | let mut sllist: SLList = SLList::new(); 99 | for elem in "abcde".chars() { 100 | sllist.add(elem); 101 | } 102 | sllist.add('x'); 103 | assert_eq!(sllist.remove(), Some('a')); 104 | assert_eq!(sllist.pop(), Some('b')); 105 | sllist.push('y'); 106 | println!("\nSLList = {:?}", sllist); 107 | for elem in "ycdex".chars() { 108 | assert_eq!(sllist.remove(), Some(elem)); 109 | } 110 | assert_eq!(sllist.pop(), None); 111 | 112 | // test large linked list for stack overflow. 113 | let mut sllist: SLList = SLList::new(); 114 | let num = 10; 115 | for i in 0..num { 116 | sllist.add(i); 117 | } 118 | while sllist.remove().is_some() {} 119 | let mut sllist: SLList = SLList::new(); 120 | let num = 100000; 121 | for i in 0..num { 122 | sllist.add(i); 123 | } 124 | println!("fin"); 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /chapter12/src/adjacencymatrix.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::Graph; 3 | 4 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 5 | pub struct AdjacencyMatrix { 6 | n: usize, 7 | a: Vec>, 8 | } 9 | 10 | impl AdjacencyMatrix { 11 | pub fn new(n: usize) -> Self { 12 | Self { 13 | n, 14 | a: vec![vec![false; n]; n], 15 | } 16 | } 17 | fn get_mut(&mut self, i: usize, j: usize) -> Option<&mut bool> { 18 | if let Some(ii) = self.a.get_mut(i) { 19 | ii.get_mut(j) 20 | } else { 21 | None 22 | } 23 | } 24 | fn get(&self, i: usize, j: usize) -> Option<&bool> { 25 | if let Some(ii) = self.a.get(i) { 26 | ii.get(j) 27 | } else { 28 | None 29 | } 30 | } 31 | } 32 | 33 | impl Graph for AdjacencyMatrix { 34 | fn add_edge(&mut self, i: usize, j: usize) { 35 | if let Some(e) = self.get_mut(i, j) { 36 | *e = true; 37 | } 38 | } 39 | fn remove_edge(&mut self, i: usize, j: usize) { 40 | if let Some(e) = self.get_mut(i, j) { 41 | *e = false; 42 | } 43 | } 44 | fn has_edge(&self, i: usize, j: usize) -> bool { 45 | if let Some(e) = self.get(i, j) { 46 | *e 47 | } else { 48 | false 49 | } 50 | } 51 | fn out_edges(&self, i: usize) -> Vec { 52 | let mut edges = vec![]; 53 | for j in 0..self.n { 54 | if let Some(true) = self.get(i, j) { 55 | edges.push(j); 56 | } 57 | } 58 | edges 59 | } 60 | fn in_edges(&self, i: usize) -> Vec { 61 | let mut edges = vec![]; 62 | for j in 0..self.n { 63 | if let Some(true) = self.get(j, i) { 64 | edges.push(j); 65 | } 66 | } 67 | edges 68 | } 69 | } 70 | 71 | #[cfg(test)] 72 | mod test { 73 | use super::*; 74 | use rand::{thread_rng, Rng}; 75 | use std::collections::HashSet; 76 | #[test] 77 | fn test_adjacencymatrix() { 78 | let n = 50; 79 | let mut adjm = AdjacencyMatrix::new(n); 80 | let mut set: HashSet<(usize, usize)> = HashSet::new(); 81 | let mut rng = thread_rng(); 82 | // add test 83 | for _ in 0..(5 * n) { 84 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 85 | if !set.contains(&(i, j)) { 86 | set.insert((i, j)); 87 | adjm.add_edge(i, j); 88 | } 89 | } 90 | for i in 0..n { 91 | for j in 0..n { 92 | assert_eq!(adjm.has_edge(i, j), set.contains(&(i, j))); 93 | } 94 | } 95 | // remove test 96 | for _ in 0..n { 97 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 98 | if set.contains(&(i, j)) { 99 | set.remove(&(i, j)); 100 | adjm.remove_edge(i, j); 101 | } 102 | } 103 | for i in 0..n { 104 | for j in 0..n { 105 | assert_eq!(adjm.has_edge(i, j), set.contains(&(i, j))); 106 | } 107 | } 108 | // check that in and out degrees are correctly computed 109 | for i in 0..n { 110 | let mut oe = 0; 111 | let mut ie = 0; 112 | for _ in set.iter().filter(|e| e.0 == i) { 113 | oe += 1; 114 | } 115 | for _ in set.iter().filter(|e| e.1 == i) { 116 | ie += 1; 117 | } 118 | assert_eq!(adjm.out_edges(i).len(), oe); 119 | assert_eq!(adjm.in_edges(i).len(), ie); 120 | } 121 | } 122 | } 123 | -------------------------------------------------------------------------------- /chapter12/src/adjacencylists.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::{Graph, List}; 3 | use chapter02::arraystack::Array as ArrayStack; 4 | 5 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 6 | pub struct AdjacencyLists { 7 | n: usize, 8 | adj: Vec>, 9 | } 10 | 11 | impl AdjacencyLists { 12 | pub fn new(n: usize) -> Self { 13 | Self { 14 | n, 15 | adj: vec![ArrayStack::new(); n], 16 | } 17 | } 18 | pub fn nvertices(&self) -> usize { 19 | self.n 20 | } 21 | } 22 | 23 | impl Graph for AdjacencyLists { 24 | fn add_edge(&mut self, i: usize, j: usize) { 25 | if let Some(e) = self.adj.get_mut(i) { 26 | e.add(e.size(), j); 27 | } 28 | } 29 | fn remove_edge(&mut self, i: usize, j: usize) { 30 | if let Some(e) = self.adj.get_mut(i) { 31 | for k in 0..e.size() { 32 | if e.get(k) == Some(j) { 33 | e.remove(k); 34 | return; 35 | } 36 | } 37 | } 38 | } 39 | fn has_edge(&self, i: usize, j: usize) -> bool { 40 | match self.adj.get(i) { 41 | Some(e) => e.contains(j), 42 | None => false, 43 | } 44 | } 45 | fn out_edges(&self, i: usize) -> Vec { 46 | let mut edges = vec![]; 47 | if let Some(e) = self.adj.get(i) { 48 | for k in 0..e.size() { 49 | if let Some(u) = e.get(k) { 50 | edges.push(u) 51 | } 52 | } 53 | } 54 | edges 55 | } 56 | fn in_edges(&self, i: usize) -> Vec { 57 | let mut edges = vec![]; 58 | for j in 0..self.n { 59 | if let Some(e) = self.adj.get(j) { 60 | if e.contains(i) { 61 | edges.push(j); 62 | } 63 | } 64 | } 65 | edges 66 | } 67 | } 68 | 69 | #[cfg(test)] 70 | mod test { 71 | use super::*; 72 | use rand::{thread_rng, Rng}; 73 | use std::collections::HashSet; 74 | #[test] 75 | fn test_adjacencylists() { 76 | let n = 50; 77 | let mut adjm = AdjacencyLists::new(n); 78 | let mut set: HashSet<(usize, usize)> = HashSet::new(); 79 | let mut rng = thread_rng(); 80 | // add test 81 | for _ in 0..(5 * n) { 82 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 83 | if !set.contains(&(i, j)) { 84 | set.insert((i, j)); 85 | adjm.add_edge(i, j); 86 | } 87 | } 88 | for i in 0..n { 89 | for j in 0..n { 90 | assert_eq!(adjm.has_edge(i, j), set.contains(&(i, j))); 91 | } 92 | } 93 | // remove test 94 | for _ in 0..n { 95 | let (i, j) = (rng.gen_range(0, n), rng.gen_range(0, n)); 96 | if set.contains(&(i, j)) { 97 | set.remove(&(i, j)); 98 | adjm.remove_edge(i, j); 99 | } 100 | } 101 | for i in 0..n { 102 | for j in 0..n { 103 | assert_eq!(adjm.has_edge(i, j), set.contains(&(i, j))); 104 | } 105 | } 106 | // check that in and out degrees are correctly computed 107 | for i in 0..n { 108 | let mut oe = 0; 109 | let mut ie = 0; 110 | for _ in set.iter().filter(|e| e.0 == i) { 111 | oe += 1; 112 | } 113 | for _ in set.iter().filter(|e| e.1 == i) { 114 | ie += 1; 115 | } 116 | assert_eq!(adjm.out_edges(i).len(), oe); 117 | assert_eq!(adjm.in_edges(i).len(), ie); 118 | } 119 | } 120 | } 121 | -------------------------------------------------------------------------------- /chapter02/src/boundeddeque.rs: -------------------------------------------------------------------------------- 1 | use chapter01::interface::List; 2 | 3 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 4 | pub struct Array { 5 | a: Box<[Option]>, 6 | j: usize, 7 | n: usize, 8 | } 9 | 10 | impl Array { 11 | pub fn pos(&self) -> usize { 12 | self.j 13 | } 14 | pub fn length(&self) -> usize { 15 | self.a.len() 16 | } 17 | 18 | pub fn new(b: usize) -> Self { 19 | Self { 20 | a: Self::allocate_in_heap(b), 21 | j: 0, 22 | n: 0, 23 | } 24 | } 25 | 26 | fn allocate_in_heap(size: usize) -> Box<[Option]> { 27 | std::iter::repeat_with(Default::default) 28 | .take(size) 29 | .collect::>() 30 | .into_boxed_slice() 31 | } 32 | } 33 | 34 | impl List for Array { 35 | fn size(&self) -> usize { 36 | self.n 37 | } 38 | 39 | fn get(&self, i: usize) -> Option { 40 | self.a.get((self.j + i) % self.length())?.as_ref().cloned() 41 | } 42 | 43 | fn set(&mut self, i: usize, x: T) -> Option { 44 | self.a.get_mut((self.j + i) % self.length())?.replace(x) 45 | } 46 | 47 | fn add(&mut self, i: usize, x: T) { 48 | assert!(i <= self.n); 49 | assert_ne!(self.length(), self.n); 50 | if i < self.n / 2 { 51 | self.j = if self.j == 0 { 52 | self.length() - 1 53 | } else { 54 | self.j - 1 55 | }; 56 | for k in 0..i { 57 | self.a[(self.j + k) % self.length()] = 58 | self.a[(self.j + k + 1) % self.length()].take(); 59 | } 60 | } else { 61 | for k in (i + 1..=self.n).rev() { 62 | self.a[(self.j + k) % self.length()] = 63 | self.a[(self.j + k - 1) % self.length()].take(); 64 | } 65 | } 66 | self.a[(self.j + i) % self.length()] = Some(x); 67 | self.n += 1; 68 | } 69 | 70 | fn remove(&mut self, i: usize) -> Option { 71 | if i >= self.n { 72 | None 73 | } else { 74 | let x = self.a[(self.j + i) % self.length()].take(); 75 | if i < self.n / 2 { 76 | for k in (1..=i).rev() { 77 | self.a[(self.j + k) % self.length()] = 78 | self.a[(self.j + k - 1) % self.length()].take(); 79 | } 80 | self.j = (self.j + 1) % self.length(); 81 | } else { 82 | for k in i..self.n - 1 { 83 | self.a[(self.j + k) % self.length()] = 84 | self.a[(self.j + k + 1) % self.length()].take(); 85 | } 86 | } 87 | self.n -= 1; 88 | x 89 | } 90 | } 91 | } 92 | 93 | #[cfg(test)] 94 | mod test { 95 | use super::Array; 96 | use chapter01::interface::List; 97 | #[test] 98 | fn test_boundeddeque() { 99 | let mut bounded_deque: Array = Array::new(6); 100 | bounded_deque.add(0, 'a'); 101 | bounded_deque.add(1, 'b'); 102 | bounded_deque.add(2, 'c'); 103 | bounded_deque.add(3, 'd'); 104 | for (i, elem) in "abcd".chars().enumerate() { 105 | assert_eq!(bounded_deque.get(i), Some(elem)); 106 | } 107 | bounded_deque.add(3, 'x'); 108 | bounded_deque.add(4, 'y'); 109 | assert_eq!(bounded_deque.remove(0), Some('a')); 110 | bounded_deque.set(3, 'z'); 111 | for (i, elem) in "bcxzd".chars().enumerate() { 112 | assert_eq!(bounded_deque.get(i), Some(elem)); 113 | } 114 | //while bounded_deque.remove(0).is_some() {} 115 | for _i in 0..6 { 116 | bounded_deque.remove(0); 117 | } 118 | println!("\nBDeque = {:?}\n", bounded_deque); 119 | } 120 | } 121 | -------------------------------------------------------------------------------- /chapter02/src/dualarraydeque.rs: -------------------------------------------------------------------------------- 1 | use super::arraystack::Array as ArrayStack; 2 | use chapter01::interface::List; 3 | 4 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 5 | pub struct Array { 6 | front: ArrayStack, 7 | back: ArrayStack, 8 | } 9 | 10 | impl Array { 11 | pub fn new() -> Self { 12 | Self { 13 | front: ArrayStack::new(), 14 | back: ArrayStack::new(), 15 | } 16 | } 17 | 18 | pub fn balance(&mut self) { 19 | if 3 * self.front.size() < self.back.size() || 3 * self.back.size() < self.front.size() { 20 | let n = self.front.size() + self.back.size(); 21 | let nf = n / 2; 22 | let nb = n - nf; 23 | let mut af: ArrayStack = ArrayStack::with_length(std::cmp::max(2 * nf, 1)); 24 | let mut bf: ArrayStack = ArrayStack::with_length(std::cmp::max(2 * nb, 1)); 25 | for i in 0..nf { 26 | af.add(nf - i - 1, self.remove(0).unwrap()); 27 | } 28 | for i in 0..nb { 29 | bf.add(i, self.remove(0).unwrap()); 30 | } 31 | std::mem::replace(&mut self.front, af); 32 | std::mem::replace(&mut self.back, bf); 33 | } 34 | } 35 | } 36 | 37 | impl List for Array { 38 | fn size(&self) -> usize { 39 | self.front.size() + self.back.size() 40 | } 41 | 42 | fn get(&self, i: usize) -> Option { 43 | if i < self.front.size() { 44 | self.front.get(self.front.size() - i - 1) 45 | } else { 46 | self.back.get(i - self.front.size()) 47 | } 48 | } 49 | 50 | fn set(&mut self, i: usize, x: T) -> Option { 51 | if i < self.front.size() { 52 | self.front.set(self.front.size() - i - 1, x) 53 | } else { 54 | self.back.set(i - self.front.size(), x) 55 | } 56 | } 57 | 58 | fn add(&mut self, i: usize, x: T) { 59 | if i < self.front.size() { 60 | self.front.add(self.front.size() - i, x); 61 | } else { 62 | self.back.add(i - self.front.size(), x); 63 | } 64 | self.balance(); 65 | } 66 | 67 | fn remove(&mut self, i: usize) -> Option { 68 | let x; 69 | if i < self.front.size() { 70 | x = self.front.remove(self.front.size() - i - 1); 71 | } else { 72 | x = self.back.remove(i - self.front.size()); 73 | } 74 | self.balance(); 75 | x 76 | } 77 | } 78 | 79 | #[cfg(test)] 80 | mod test { 81 | use super::Array; 82 | use chapter01::interface::List; 83 | #[test] 84 | fn test_dualarraydeque() { 85 | let mut dual_array_deque: Array = Array::new(); 86 | assert_eq!(dual_array_deque.size(), 0); 87 | dual_array_deque.add(0, 'A'); 88 | dual_array_deque.add(1, 'B'); 89 | dual_array_deque.add(2, 'C'); 90 | dual_array_deque.add(3, 'D'); 91 | assert_eq!(dual_array_deque.get(0), Some('A')); 92 | assert_eq!(dual_array_deque.get(1), Some('B')); 93 | assert_eq!(dual_array_deque.get(2), Some('C')); 94 | assert_eq!(dual_array_deque.get(3), Some('D')); 95 | dual_array_deque.add(3, 'x'); 96 | dual_array_deque.add(4, 'y'); 97 | assert_eq!(dual_array_deque.remove(0), Some('A')); 98 | assert_eq!(dual_array_deque.get(0), Some('B')); 99 | assert_eq!(dual_array_deque.get(1), Some('C')); 100 | assert_eq!(dual_array_deque.get(2), Some('x')); 101 | assert_eq!(dual_array_deque.get(3), Some('y')); 102 | assert_eq!(dual_array_deque.get(4), Some('D')); 103 | println!("\nDualArrayDeque = {:?}\n", dual_array_deque); 104 | let mut dual_array_deque: Array = Array::new(); 105 | let num = 10; 106 | for i in 0..num { 107 | dual_array_deque.add(dual_array_deque.size(), i); 108 | } 109 | while dual_array_deque.remove(0).is_some() {} 110 | println!("\nDualArrayDeque = {:?}\n", dual_array_deque); 111 | } 112 | } 113 | -------------------------------------------------------------------------------- /chapter02/src/arraystack.rs: -------------------------------------------------------------------------------- 1 | use chapter01::interface::List; 2 | 3 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 4 | pub struct Array { 5 | a: Box<[Option]>, 6 | n: usize, 7 | } 8 | 9 | impl Array { 10 | pub fn length(&self) -> usize { 11 | self.a.len() 12 | } 13 | 14 | pub fn new() -> Self { 15 | Self::with_length(1) 16 | } 17 | 18 | pub fn with_length(capacity: usize) -> Self { 19 | Self { 20 | a: Self::allocate_in_heap(capacity), 21 | n: 0, 22 | } 23 | } 24 | 25 | fn allocate_in_heap(size: usize) -> Box<[Option]> { 26 | std::iter::repeat_with(Default::default) 27 | .take(size) 28 | .collect::>() 29 | .into_boxed_slice() 30 | } 31 | 32 | fn resize(&mut self) { 33 | let new_a = Self::allocate_in_heap(std::cmp::max(self.n * 2, 1)); 34 | let old_a = std::mem::replace(&mut self.a, new_a); 35 | for (i, elem) in old_a.into_vec().into_iter().enumerate().take(self.n) { 36 | self.a[i] = elem; 37 | } 38 | } 39 | } 40 | 41 | impl Array { 42 | pub fn contains(&self, j: T) -> bool { 43 | for i in 0..self.n { 44 | if self.a.get(i).unwrap().as_ref() == Some(&j) { 45 | return true; 46 | } 47 | } 48 | false 49 | } 50 | } 51 | 52 | impl Array { 53 | pub fn take(&mut self, i: usize) -> Option { 54 | self.a.get_mut(i)?.take() 55 | } 56 | } 57 | 58 | impl List for Array { 59 | fn size(&self) -> usize { 60 | self.n 61 | } 62 | 63 | fn get(&self, i: usize) -> Option { 64 | self.a.get(i)?.as_ref().cloned() 65 | } 66 | 67 | fn set(&mut self, i: usize, x: T) -> Option { 68 | self.a.get_mut(i)?.replace(x) 69 | } 70 | 71 | fn add(&mut self, i: usize, x: T) { 72 | if self.n + 1 >= self.length() { 73 | self.resize(); 74 | } 75 | 76 | if i >= self.n { 77 | self.a[self.n] = Some(x); 78 | } else { 79 | self.a[i..self.n].rotate_right(1); 80 | let end = self.a[i].replace(x); 81 | self.a[self.n] = end; 82 | } 83 | self.n += 1; 84 | } 85 | 86 | fn remove(&mut self, i: usize) -> Option { 87 | let x = self.a.get_mut(i)?.take(); 88 | if i < self.n { 89 | self.a[i..self.n].rotate_left(1); 90 | self.n -= 1; 91 | if self.length() >= 3 * self.n { 92 | self.resize(); 93 | } 94 | } 95 | x 96 | } 97 | } 98 | 99 | #[cfg(test)] 100 | mod test { 101 | use super::Array; 102 | use chapter01::interface::List; 103 | 104 | #[test] 105 | fn test_arraystack() { 106 | let mut array_stack: Array = Array::new(); 107 | assert_eq!(array_stack.size(), 0); 108 | for (i, elem) in "bred".chars().enumerate() { 109 | array_stack.add(i, elem); 110 | } 111 | array_stack.add(2, 'e'); 112 | array_stack.add(5, 'r'); 113 | assert_eq!((array_stack.size(), array_stack.length()), (6, 10)); 114 | for (i, elem) in "breedr".chars().enumerate() { 115 | assert_eq!(array_stack.get(i), Some(elem)); 116 | } 117 | array_stack.add(5, 'e'); 118 | array_stack.remove(4); 119 | array_stack.remove(4); 120 | assert_eq!((array_stack.size(), array_stack.length()), (5, 10)); 121 | array_stack.remove(4); 122 | array_stack.remove(3); 123 | array_stack.set(2, 'i'); 124 | assert_eq!((array_stack.size(), array_stack.length()), (3, 6)); 125 | for (i, elem) in "bri".chars().enumerate() { 126 | assert_eq!(array_stack.get(i), Some(elem)); 127 | } 128 | assert_eq!(array_stack.get(4), None); 129 | println!("\nArrayStack = {:?}\n", array_stack); 130 | let mut array_stack: Array = Array::new(); 131 | let num = 10; 132 | for i in 0..num { 133 | array_stack.add(array_stack.size(), i); 134 | } 135 | while array_stack.remove(0).is_some() {} 136 | println!("\nArrayStack = {:?}\n", array_stack); 137 | } 138 | } 139 | -------------------------------------------------------------------------------- /chapter02/src/rootisharraystack.rs: -------------------------------------------------------------------------------- 1 | use super::arraystack::Array as ArrayStack; 2 | use chapter01::interface::List; 3 | use std::cell::RefCell; 4 | use std::rc::Rc; 5 | 6 | #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] 7 | pub struct Array { 8 | blocks: ArrayStack>]>>, 9 | n: usize, 10 | } 11 | 12 | impl Default for Array { 13 | fn default() -> Self { 14 | Self::new() 15 | } 16 | } 17 | 18 | impl Array { 19 | pub fn new() -> Self { 20 | Self { 21 | blocks: ArrayStack::new(), 22 | n: 0, 23 | } 24 | } 25 | fn i2b(i: usize) -> usize { 26 | let db = (-3.0 + (9.0 + 8.0 * i as f64).sqrt()) / 2f64; 27 | db.ceil() as usize 28 | } 29 | fn grow(&mut self) { 30 | let block = std::iter::repeat_with(Default::default) 31 | .take(self.blocks.size() + 1) 32 | .collect::>(); 33 | self.blocks.add(self.blocks.size(), block); 34 | } 35 | fn shrink(&mut self) { 36 | let mut r = self.blocks.size(); 37 | while r > 0 && (std::cmp::max(2, r) - 2) * (r - 1) / 2 >= self.n { 38 | self.blocks.remove(self.blocks.size() - 1); 39 | r -= 1; 40 | } 41 | } 42 | } 43 | 44 | impl List for Array { 45 | fn size(&self) -> usize { 46 | self.n 47 | } 48 | 49 | fn get(&self, i: usize) -> Option { 50 | let b = Self::i2b(i); 51 | let j = i - b * (b + 1) / 2; 52 | match self.blocks.get(b)?[j].borrow().as_ref() { 53 | Some(value) => Some(value.clone()), 54 | None => None, 55 | } 56 | } 57 | 58 | fn set(&mut self, i: usize, x: T) -> Option { 59 | let b = Self::i2b(i); 60 | let j = i - b * (b + 1) / 2; 61 | self.blocks.get(b)?[j].borrow_mut().replace(x) 62 | } 63 | 64 | fn add(&mut self, i: usize, x: T) { 65 | assert!(i <= self.n); 66 | let r = self.blocks.size(); 67 | if r * (r + 1) / 2 < self.n + 1 { 68 | self.grow(); 69 | } 70 | self.n += 1; 71 | for j in (i + 1..self.n).rev() { 72 | self.set(j, self.get(j - 1).unwrap()); 73 | } 74 | self.set(i, x); 75 | } 76 | 77 | fn remove(&mut self, i: usize) -> Option { 78 | if i < self.n { 79 | let x = self.get(i); 80 | for j in i..self.n - 1 { 81 | self.set(j, self.get(j + 1).unwrap()); 82 | } 83 | let eb = Self::i2b(self.n - 1); 84 | let ej = self.n - 1 - eb * (eb + 1) / 2; 85 | self.blocks.get(eb)?[ej].borrow_mut().take(); 86 | self.n -= 1; 87 | let r = self.blocks.size(); 88 | if (r - 2) * (r - 1) / 2 <= self.n { 89 | self.shrink(); 90 | } 91 | x 92 | } else { 93 | None 94 | } 95 | } 96 | } 97 | 98 | #[cfg(test)] 99 | mod test { 100 | use super::Array; 101 | use chapter01::interface::List; 102 | #[test] 103 | fn test_rootisharraystack() { 104 | let mut rootish_array_stack: Array = Array::new(); 105 | assert_eq!(rootish_array_stack.size(), 0); 106 | for (i, elem) in "abcdefgh".chars().enumerate() { 107 | rootish_array_stack.add(i, elem); 108 | } 109 | for (i, elem) in "abcdefgh".chars().enumerate() { 110 | assert_eq!(rootish_array_stack.get(i), Some(elem)); 111 | } 112 | rootish_array_stack.add(2, 'x'); 113 | rootish_array_stack.remove(1); 114 | rootish_array_stack.remove(7); 115 | rootish_array_stack.remove(6); 116 | for (i, elem) in "axcdef".chars().enumerate() { 117 | assert_eq!(rootish_array_stack.get(i), Some(elem)); 118 | } 119 | println!("\nRootishArrayStack = {:?}\n", rootish_array_stack); 120 | let mut rootish_array_stack: Array = Array::new(); 121 | println!("{:?}", rootish_array_stack); 122 | let num = 10; 123 | for i in 0..num { 124 | rootish_array_stack.add(rootish_array_stack.size(), i); 125 | } 126 | while rootish_array_stack.remove(0).is_some() {} 127 | println!("\nRootishArrayStack = {:?}\n", rootish_array_stack); 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /chapter02/src/arraydeque.rs: -------------------------------------------------------------------------------- 1 | use chapter01::interface::List; 2 | 3 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 4 | pub struct Array { 5 | a: Box<[Option]>, 6 | j: usize, 7 | n: usize, 8 | } 9 | 10 | impl Array { 11 | pub fn pos(&self) -> usize { 12 | self.j 13 | } 14 | pub fn length(&self) -> usize { 15 | self.a.len() 16 | } 17 | 18 | pub fn new() -> Self { 19 | Self::with_length(1) 20 | } 21 | 22 | pub fn with_length(length: usize) -> Self { 23 | Self { 24 | a: Self::allocate_in_heap(length), 25 | j: 0, 26 | n: 0, 27 | } 28 | } 29 | 30 | fn allocate_in_heap(size: usize) -> Box<[Option]> { 31 | std::iter::repeat_with(Default::default) 32 | .take(size) 33 | .collect::>() 34 | .into_boxed_slice() 35 | } 36 | 37 | pub fn resize(&mut self) { 38 | let new_a = Self::allocate_in_heap(std::cmp::max(1, self.n * 2)); 39 | let mut old_a = std::mem::replace(&mut self.a, new_a); 40 | for k in 0..self.n { 41 | self.a[k] = old_a[(self.j + k) % old_a.len()].take(); 42 | } 43 | self.j = 0; 44 | } 45 | } 46 | 47 | impl List for Array { 48 | fn size(&self) -> usize { 49 | self.n 50 | } 51 | 52 | fn get(&self, i: usize) -> Option { 53 | self.a.get((self.j + i) % self.length())?.as_ref().cloned() 54 | } 55 | 56 | fn set(&mut self, i: usize, x: T) -> Option { 57 | self.a.get_mut((self.j + i) % self.length())?.replace(x) 58 | } 59 | 60 | fn add(&mut self, i: usize, x: T) { 61 | assert!(i <= self.n); 62 | if self.n + 1 >= self.length() { 63 | self.resize(); 64 | } 65 | 66 | if i < self.n / 2 { 67 | self.j = if self.j == 0 { 68 | self.length() - 1 69 | } else { 70 | self.j - 1 71 | }; 72 | for k in 0..i { 73 | self.a[(self.j + k) % self.length()] = 74 | self.a[(self.j + k + 1) % self.length()].take(); 75 | } 76 | } else { 77 | for k in (i + 1..=self.n).rev() { 78 | self.a[(self.j + k) % self.length()] = 79 | self.a[(self.j + k - 1) % self.length()].take(); 80 | } 81 | } 82 | self.a[(self.j + i) % self.length()] = Some(x); 83 | self.n += 1; 84 | } 85 | 86 | fn remove(&mut self, i: usize) -> Option { 87 | if i >= self.n { 88 | None 89 | } else { 90 | let x = self.a[(self.j + i) % self.length()].take(); 91 | if i < self.n / 2 { 92 | for k in (1..=i).rev() { 93 | self.a[(self.j + k) % self.length()] = 94 | self.a[(self.j + k - 1) % self.length()].take(); 95 | } 96 | self.j = (self.j + 1) % self.length(); 97 | } else { 98 | for k in i..self.n - 1 { 99 | self.a[(self.j + k) % self.length()] = 100 | self.a[(self.j + k + 1) % self.length()].take(); 101 | } 102 | } 103 | self.n -= 1; 104 | if self.length() > 3 * self.n { 105 | self.resize(); 106 | } 107 | x 108 | } 109 | } 110 | } 111 | 112 | #[cfg(test)] 113 | mod test { 114 | use super::Array; 115 | use chapter01::interface::List; 116 | #[test] 117 | fn test_arraydeque() { 118 | let mut array_deque: Array = Array::new(); 119 | assert_eq!(array_deque.size(), 0); 120 | array_deque.get(0); 121 | array_deque.add(0, 'a'); 122 | array_deque.add(1, 'b'); 123 | array_deque.add(2, 'c'); 124 | array_deque.add(3, 'd'); 125 | for (i, elem) in "abcd".chars().enumerate() { 126 | assert_eq!(array_deque.get(i), Some(elem)); 127 | } 128 | array_deque.add(3, 'x'); 129 | array_deque.add(4, 'y'); 130 | assert_eq!(array_deque.remove(0), Some('a')); 131 | array_deque.set(3, 'z'); 132 | for (i, elem) in "bcxzd".chars().enumerate() { 133 | assert_eq!(array_deque.get(i), Some(elem)); 134 | } 135 | println!("\nArrayDeque = {:?}\n", array_deque); 136 | let mut array_deque: Array = Array::new(); 137 | let num = 10; 138 | for i in 0..num { 139 | array_deque.add(array_deque.size(), i); 140 | } 141 | while array_deque.remove(0).is_some() {} 142 | println!("\nArrayDeque = {:?}\n", array_deque); 143 | } 144 | } 145 | -------------------------------------------------------------------------------- /chapter05/src/chainedhashtable.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use super::hashcode; 3 | use chapter01::interface::{List, USet}; 4 | use chapter02::arraystack::Array as ArrayStack; 5 | use std::hash::Hash; 6 | 7 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 8 | pub struct ChainedHashTable { 9 | t: Box<[ArrayStack]>, 10 | n: usize, 11 | d: usize, 12 | z: usize, 13 | } 14 | 15 | impl ChainedHashTable 16 | where 17 | T: PartialEq + Clone + Hash, 18 | { 19 | const W: usize = std::mem::size_of::() * 8; 20 | pub fn new() -> Self { 21 | Self { 22 | t: Self::allocate_in_heap(2), 23 | n: 0, 24 | d: 1, 25 | z: rand::random::() | 1, 26 | } 27 | } 28 | fn allocate_in_heap(size: usize) -> Box<[ArrayStack]> { 29 | std::iter::repeat_with(|| ArrayStack::new()) 30 | .take(size) 31 | .collect::>() 32 | .into_boxed_slice() 33 | } 34 | fn resize(&mut self) { 35 | self.d = 1; 36 | while 1 << self.d <= self.n { 37 | self.d += 1 38 | } 39 | self.n = 0; 40 | let new_t = Self::allocate_in_heap(1 << self.d); 41 | let old_t = std::mem::replace(&mut self.t, new_t); 42 | for elem in old_t.into_vec().iter_mut() { 43 | let len = elem.size(); 44 | for _j in 0..len { 45 | self.add(elem.remove(0).unwrap()); 46 | } 47 | } 48 | } 49 | fn hash(&self, x: &T) -> usize { 50 | (((self.z as u128 * hashcode(x) as u128) % ((1 as u128) << Self::W as u128)) 51 | >> (Self::W - self.d) as u128) as usize 52 | } 53 | } 54 | 55 | impl USet for ChainedHashTable 56 | where 57 | T: PartialEq + Clone + Hash, 58 | { 59 | fn size(&self) -> usize { 60 | self.n 61 | } 62 | fn add(&mut self, x: T) -> bool { 63 | if self.find(&x).is_some() { 64 | return false; 65 | } 66 | if self.n + 1 > self.t.len() { 67 | self.resize(); 68 | } 69 | if let Some(t) = self.t.get_mut(self.hash(&x)) { 70 | t.add(t.size(), x) 71 | } 72 | self.n += 1; 73 | true 74 | } 75 | fn remove(&mut self, x: &T) -> Option { 76 | let j = self.hash(x); 77 | for i in 0..self.t.get(j)?.size() { 78 | if Some(x) == self.t.get(j).and_then(|t| t.get(i)).as_ref() { 79 | let y = self.t.get_mut(j)?.remove(i); 80 | self.n -= 1; 81 | if 3 * self.n < self.t.len() { 82 | self.resize() 83 | } 84 | return y; 85 | } 86 | } 87 | None 88 | } 89 | fn find(&self, x: &T) -> Option { 90 | let j = self.hash(x); 91 | for i in 0..self.t.get(j)?.size() { 92 | if Some(x) == self.t.get(j).and_then(|t| t.get(i)).as_ref() { 93 | return self.t.get(j)?.get(i); 94 | } 95 | } 96 | None 97 | } 98 | } 99 | 100 | #[cfg(test)] 101 | mod test { 102 | use super::ChainedHashTable; 103 | use chapter01::interface::USet; 104 | 105 | #[test] 106 | fn test_chainedhashtable() { 107 | let mut chainedhashtable = ChainedHashTable::::new(); 108 | chainedhashtable.add('a'); 109 | chainedhashtable.add('b'); 110 | chainedhashtable.add('c'); 111 | chainedhashtable.add('d'); 112 | chainedhashtable.add('e'); 113 | chainedhashtable.add('f'); 114 | chainedhashtable.add('g'); 115 | chainedhashtable.add('h'); 116 | chainedhashtable.add('i'); 117 | chainedhashtable.add('j'); 118 | chainedhashtable.add('k'); 119 | chainedhashtable.add('l'); 120 | chainedhashtable.add('m'); 121 | chainedhashtable.add('x'); 122 | for elem in "abcdefghijklmx".chars() { 123 | assert_eq!(Some(elem), chainedhashtable.find(&elem)); 124 | } 125 | assert_eq!(chainedhashtable.remove(&'x'), Some('x')); 126 | assert_eq!(chainedhashtable.remove(&'a'), Some('a')); 127 | assert_eq!(chainedhashtable.remove(&'b'), Some('b')); 128 | assert_eq!(chainedhashtable.remove(&'c'), Some('c')); 129 | assert_eq!(chainedhashtable.remove(&'d'), Some('d')); 130 | assert_eq!(chainedhashtable.remove(&'e'), Some('e')); 131 | assert_eq!(chainedhashtable.remove(&'f'), Some('f')); 132 | assert_eq!(chainedhashtable.remove(&'g'), Some('g')); 133 | assert_eq!(chainedhashtable.remove(&'h'), Some('h')); 134 | assert_eq!(chainedhashtable.remove(&'i'), Some('i')); 135 | assert_eq!(chainedhashtable.remove(&'x'), None); 136 | } 137 | } 138 | -------------------------------------------------------------------------------- /chapter13/src/yfasttrie.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names)] 2 | use crate::{xfasttrie::XFastTrie, USizeV}; 3 | use chapter01::interface::SSet; 4 | use chapter07::treap::Treap; 5 | use std::cell::RefCell; 6 | use std::rc::Rc; 7 | 8 | #[derive(Clone, Debug, Default)] 9 | struct YPair { 10 | ix: usize, 11 | t: Rc>>, 12 | } 13 | 14 | impl USizeV for YPair { 15 | fn usize_value(&self) -> usize { 16 | self.ix 17 | } 18 | } 19 | 20 | impl PartialOrd for YPair 21 | where 22 | T: USizeV + Default + PartialOrd + Clone, 23 | { 24 | fn partial_cmp(&self, other: &YPair) -> Option { 25 | Some(self.ix.cmp(&other.ix)) 26 | } 27 | } 28 | 29 | impl PartialEq for YPair 30 | where 31 | T: USizeV + Default + PartialOrd + Clone, 32 | { 33 | fn eq(&self, other: &YPair) -> bool { 34 | self.ix == other.ix 35 | } 36 | } 37 | 38 | impl YPair 39 | where 40 | T: USizeV + Default + PartialOrd + Clone, 41 | { 42 | fn with_x(ix: usize) -> Self { 43 | Self { 44 | ix, 45 | t: Rc::new(RefCell::new(Treap::new())), 46 | } 47 | } 48 | fn with_xt(ix: usize, t: Treap) -> Self { 49 | Self { 50 | ix, 51 | t: Rc::new(RefCell::new(t)), 52 | } 53 | } 54 | } 55 | 56 | #[derive(Clone, Debug, Default)] 57 | pub struct YFastTrie 58 | where 59 | T: USizeV + Default + PartialOrd + Clone, 60 | { 61 | xft: XFastTrie>, 62 | n: usize, 63 | } 64 | 65 | impl YFastTrie 66 | where 67 | T: USizeV + Default + PartialOrd + Clone, 68 | { 69 | const W: usize = 32; 70 | pub fn new() -> Self { 71 | let mut xft = XFastTrie::new(); 72 | xft.add(YPair::with_x((1 << Self::W) - 1)); 73 | Self { n: 0, xft } 74 | } 75 | } 76 | 77 | impl SSet for YFastTrie 78 | where 79 | T: USizeV + Default + PartialOrd + Clone + std::fmt::Debug, 80 | { 81 | fn size(&self) -> usize { 82 | self.n 83 | } 84 | fn add(&mut self, x: T) -> bool { 85 | let ix = x.usize_value(); 86 | let mut t = self.xft.find(&YPair::with_x(ix)).map(|y| y.t); 87 | match t { 88 | Some(ref mut t) => { 89 | if t.borrow_mut().add(x.clone()) { 90 | self.n += 1; 91 | if rand::random::() % Self::W == 0 { 92 | let t1 = t.borrow_mut().split(x); 93 | self.xft.add(YPair::with_xt(ix, t1)); 94 | } 95 | true 96 | } else { 97 | false 98 | } 99 | } 100 | None => false, 101 | } 102 | } 103 | fn remove(&mut self, x: &T) -> Option { 104 | let ix = x.usize_value(); 105 | let u = self.xft.find_node(ix); 106 | let ret = match &u { 107 | Some(u) => u.x.borrow().t.borrow_mut().remove(x), 108 | None => None, 109 | }; 110 | if ret.is_some() { 111 | self.n -= 1; 112 | } 113 | if let Some(u) = u { 114 | if u.x.borrow().ix == ix && ix != (1 << Self::W) - 1 { 115 | if let Some(n) = u.next.borrow().as_ref() { 116 | n.x.borrow() 117 | .t 118 | .borrow_mut() 119 | .absorb(u.x.borrow().t.replace(Treap::new())); 120 | } 121 | self.xft.remove_node(u); 122 | } 123 | } 124 | ret 125 | } 126 | fn find(&self, x: &T) -> Option { 127 | self.xft 128 | .find(&YPair::with_x(x.usize_value())) 129 | .and_then(|y| y.t.borrow().find(&x)) 130 | } 131 | } 132 | 133 | #[cfg(test)] 134 | mod test { 135 | use super::*; 136 | use chapter01::interface::SSet; 137 | use chapter09::redblacktree::RedBlackTree; 138 | use rand::{thread_rng, Rng}; 139 | #[test] 140 | fn test_yfasttrie() { 141 | let mut rng = thread_rng(); 142 | let n = 200; 143 | let mut redblacktree = RedBlackTree::::new(); 144 | let mut yfasttrie = YFastTrie::::new(); 145 | 146 | for _ in 0..2 { 147 | for _ in 0..n { 148 | let x = rng.gen_range(0, 5 * n); 149 | redblacktree.add(x); 150 | yfasttrie.add(x); 151 | assert_eq!(redblacktree.size(), yfasttrie.size()); 152 | } 153 | for _ in 0..n { 154 | let x = rng.gen_range(0, 5 * n); 155 | let y1 = redblacktree.find(&x); 156 | let y2 = yfasttrie.find(&x); 157 | assert_eq!(y1, y2); 158 | } 159 | for _ in 0..n { 160 | let x = rng.gen_range(0, 5 * n); 161 | let b1 = redblacktree.remove(&x); 162 | let b2 = yfasttrie.remove(&x); 163 | assert_eq!(b1, b2); 164 | } 165 | assert_eq!(redblacktree.size(), yfasttrie.size()); 166 | for _ in 0..n { 167 | let x = rng.gen_range(0, 5 * n); 168 | let y1 = redblacktree.find(&x); 169 | let y2 = yfasttrie.find(&x); 170 | assert_eq!(y1, y2); 171 | } 172 | } 173 | // test large linked list for stack overflow. 174 | let mut bst = YFastTrie::::new(); 175 | let num = 100000; 176 | for i in 0..num { 177 | bst.add(i); 178 | } 179 | println!("fin"); 180 | } 181 | } 182 | -------------------------------------------------------------------------------- /chapter03/src/dllist.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::List; 3 | use std::cell::RefCell; 4 | use std::rc::{Rc, Weak}; 5 | 6 | type Link = Option>>>; 7 | type Wink = Option>>>; 8 | 9 | #[derive(Clone, Debug, Default)] 10 | pub struct DLList { 11 | head: Link, 12 | tail: Wink, 13 | n: usize, 14 | } 15 | 16 | impl Drop for DLList 17 | where 18 | T: Clone + Default, 19 | { 20 | fn drop(&mut self) { 21 | while self.remove(0).is_some() {} 22 | } 23 | } 24 | 25 | #[derive(Clone, Debug, Default)] 26 | pub struct Node { 27 | x: T, 28 | next: Link, 29 | prev: Wink, 30 | } 31 | 32 | impl Node { 33 | fn new(x: T) -> Rc> { 34 | Rc::new(RefCell::new(Self { 35 | x, 36 | next: None, 37 | prev: None, 38 | })) 39 | } 40 | } 41 | 42 | impl DLList { 43 | pub fn new() -> Self { 44 | let dummy1: Rc>> = Default::default(); 45 | let dummy2: Rc>> = Default::default(); 46 | dummy1.borrow_mut().next = Some(dummy2.clone()); 47 | dummy2.borrow_mut().prev = Some(Rc::downgrade(&dummy1)); 48 | Self { 49 | head: Some(dummy1), 50 | tail: Some(Rc::downgrade(&dummy2)), 51 | n: 0, 52 | } 53 | } 54 | 55 | fn get_link(&self, i: usize) -> Link { 56 | let mut p: Link; 57 | if i < self.n / 2 { 58 | p = self.head.as_ref().and_then(|d| d.borrow().next.clone()); 59 | for _j in 0..i { 60 | p = p.and_then(|p| p.borrow().next.clone()); 61 | } 62 | } else { 63 | p = self.tail.as_ref().and_then(|p| p.upgrade()); 64 | for _j in (i + 1..=self.n).rev() { 65 | p = p.and_then(|p| p.borrow().prev.as_ref().and_then(|p| p.upgrade())); 66 | } 67 | } 68 | p 69 | } 70 | 71 | fn add_before(&mut self, w: Link, x: T) { 72 | let u = Node::new(x); 73 | u.borrow_mut().prev = w.as_ref().and_then(|p| p.borrow().prev.clone()); 74 | if let Some(p) = w.as_ref() { 75 | p.borrow_mut().prev = Some(Rc::downgrade(&u)) 76 | } 77 | u.borrow_mut().next = w; 78 | u.borrow() 79 | .prev 80 | .as_ref() 81 | .and_then(|p| p.upgrade().map(|p| p.borrow_mut().next = Some(u.clone()))); 82 | self.n += 1; 83 | } 84 | 85 | fn remove_link(&mut self, w: Link) { 86 | let prev = w.as_ref().and_then(|p| p.borrow_mut().prev.take()); 87 | let next = w.and_then(|p| p.borrow_mut().next.take()); 88 | prev.as_ref() 89 | .and_then(|p| p.upgrade().map(|p| p.borrow_mut().next = next.clone())); 90 | if let Some(p) = next { 91 | p.borrow_mut().prev = prev 92 | } 93 | self.n -= 1; 94 | } 95 | } 96 | 97 | impl List for DLList { 98 | fn size(&self) -> usize { 99 | self.n 100 | } 101 | fn get(&self, i: usize) -> Option { 102 | if self.n == 0 { 103 | None 104 | } else { 105 | self.get_link(i).map(|p| p.borrow().x.clone()) 106 | } 107 | } 108 | fn set(&mut self, i: usize, x: T) -> Option { 109 | if self.n > 0 { 110 | self.get_link(i).map(|p| { 111 | let ret = p.borrow().x.clone(); 112 | p.borrow_mut().x = x; 113 | ret 114 | }) 115 | } else { 116 | None 117 | } 118 | } 119 | fn add(&mut self, i: usize, x: T) { 120 | self.add_before(self.get_link(i), x); 121 | } 122 | 123 | fn remove(&mut self, i: usize) -> Option { 124 | if self.n == 0 { 125 | return None; 126 | } 127 | let w = self.get_link(i); 128 | self.remove_link(w.clone()); 129 | match w { 130 | Some(w) => Some(Rc::try_unwrap(w).ok().unwrap().into_inner().x), 131 | None => None, 132 | } 133 | } 134 | } 135 | 136 | #[cfg(test)] 137 | mod test { 138 | use super::DLList; 139 | use chapter01::interface::List; 140 | #[test] 141 | fn test_dllist() { 142 | let mut dllist: DLList = DLList::new(); 143 | assert_eq!(dllist.size(), 0); 144 | dllist.add(0, 'a'); 145 | dllist.add(1, 'b'); 146 | dllist.add(2, 'c'); 147 | dllist.add(3, 'd'); 148 | dllist.add(4, 'e'); 149 | assert_eq!(dllist.get(0), Some('a')); 150 | assert_eq!(dllist.get(1), Some('b')); 151 | assert_eq!(dllist.get(2), Some('c')); 152 | assert_eq!(dllist.get(3), Some('d')); 153 | assert_eq!(dllist.get(4), Some('e')); 154 | assert_eq!(dllist.set(1, 'x'), Some('b')); 155 | assert_eq!(dllist.get(1), Some('x')); 156 | assert_eq!(dllist.remove(2), Some('c')); 157 | dllist.add(2, 'y'); 158 | assert_eq!(dllist.get(2), Some('y')); 159 | println!("\nDLList = {:?}\n", dllist); 160 | for elem in "axyde".chars() { 161 | assert_eq!(dllist.remove(0), Some(elem)); 162 | } 163 | assert_eq!(dllist.remove(0), None); 164 | assert_eq!(dllist.get(0), None); 165 | 166 | // test large linked list for stack overflow. 167 | let mut dllist: DLList = DLList::new(); 168 | let num = 10; 169 | for i in 0..num { 170 | dllist.add(dllist.size(), i); 171 | } 172 | while dllist.remove(0).is_some() {} 173 | let mut dllist: DLList = DLList::new(); 174 | let num = 100000; 175 | for i in 0..num { 176 | dllist.add(dllist.size(), i); 177 | } 178 | println!("fin"); 179 | } 180 | } 181 | -------------------------------------------------------------------------------- /chapter10/src/meldableheap.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::Queue; 3 | use std::cell::RefCell; 4 | use std::rc::{Rc, Weak}; 5 | 6 | type Tree = Option>>; 7 | 8 | #[derive(Clone, Debug, Default)] 9 | pub struct MHNode { 10 | x: RefCell, 11 | left: RefCell>>>, 12 | right: RefCell>>>, 13 | parent: RefCell>>>, 14 | } 15 | 16 | #[derive(Clone, Debug, Default)] 17 | pub struct MeldableHeap { 18 | n: usize, 19 | r: Option>>, 20 | } 21 | 22 | impl Drop for MeldableHeap { 23 | fn drop(&mut self) { 24 | while let Some(r) = self.r.clone() { 25 | self.splice(r); 26 | } 27 | } 28 | } 29 | 30 | impl MHNode { 31 | pub fn new(x: T) -> Self { 32 | Self { 33 | x: RefCell::new(x), 34 | ..Default::default() 35 | } 36 | } 37 | } 38 | 39 | impl MeldableHeap { 40 | pub fn new() -> Self { 41 | Self { n: 0, r: None } 42 | } 43 | fn merge(h1: Tree, h2: Tree) -> Tree { 44 | match (h1, h2) { 45 | (None, h2) => h2, 46 | (h1, None) => h1, 47 | (Some(h1), Some(h2)) if *h1.x.borrow() > *h2.x.borrow() => { 48 | Self::merge(Some(h2), Some(h1)) 49 | } 50 | (Some(h1), Some(h2)) => { 51 | if rand::random::() { 52 | let u = Self::merge(h1.left.borrow().clone(), Some(h2)); 53 | *h1.left.borrow_mut() = u; 54 | if let Some(left) = &*h1.left.borrow() { 55 | left.parent.borrow_mut().replace(Rc::downgrade(&h1)); 56 | } 57 | Some(h1) 58 | } else { 59 | let u = Self::merge(h1.right.borrow().clone(), Some(h2)); 60 | *h1.right.borrow_mut() = u; 61 | if let Some(right) = &*h1.right.borrow() { 62 | right.parent.borrow_mut().replace(Rc::downgrade(&h1)); 63 | } 64 | Some(h1) 65 | } 66 | } 67 | } 68 | } 69 | pub fn find_min(&self) -> Option { 70 | self.r.as_ref().map(|r| r.x.borrow().clone()) 71 | } 72 | fn splice(&mut self, u: Rc>) -> Option { 73 | let s: Tree; 74 | let mut p: Tree = None; 75 | if u.left.borrow().is_some() { 76 | s = u.left.borrow_mut().take(); 77 | } else { 78 | s = u.right.borrow_mut().take(); 79 | } 80 | if let Some(r) = &self.r { 81 | if Rc::ptr_eq(&u, r) { 82 | self.r = s.clone(); 83 | p = None; 84 | } else { 85 | p = u.parent.borrow_mut().take().and_then(|p| p.upgrade()); 86 | if let Some(p) = p.as_ref() { 87 | let left = p.left.borrow().clone(); 88 | match left { 89 | Some(ref left) if Rc::ptr_eq(left, &u) => { 90 | *p.left.borrow_mut() = s.clone(); 91 | } 92 | _ => { 93 | *p.right.borrow_mut() = s.clone(); 94 | } 95 | } 96 | } 97 | } 98 | } 99 | match (s, p) { 100 | (Some(ref s), Some(ref p)) => { 101 | s.parent.borrow_mut().replace(Rc::downgrade(p)); 102 | } 103 | (Some(ref s), None) => { 104 | s.parent.borrow_mut().take(); 105 | } 106 | _ => (), 107 | } 108 | self.n -= 1; 109 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 110 | } 111 | } 112 | 113 | impl Queue for MeldableHeap 114 | where 115 | T: PartialOrd + Clone + Default, 116 | { 117 | fn add(&mut self, x: T) { 118 | let u = Rc::new(MHNode::new(x)); 119 | self.r = Self::merge(Some(u), self.r.clone()); 120 | self.r.as_ref().and_then(|r| r.parent.borrow_mut().take()); 121 | self.n += 1; 122 | } 123 | fn remove(&mut self) -> Option { 124 | let u = self.r.take(); 125 | self.r = Self::merge( 126 | u.as_ref().and_then(|r| r.left.borrow_mut().take()), 127 | u.as_ref().and_then(|r| r.right.borrow_mut().take()), 128 | ); 129 | self.r.as_ref().and_then(|r| r.parent.borrow_mut().take()); 130 | if self.n != 0 { 131 | self.n -= 1; 132 | } 133 | u.map(|u| Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 134 | } 135 | } 136 | 137 | #[cfg(test)] 138 | mod test { 139 | use super::*; 140 | use chapter01::interface::Queue; 141 | #[test] 142 | fn test_meldableheap() { 143 | let mut meldableheap = MeldableHeap::::new(); 144 | meldableheap.add(7); 145 | meldableheap.add(8); 146 | meldableheap.add(9); 147 | meldableheap.add(26); 148 | meldableheap.add(4); 149 | assert_eq!(meldableheap.n, 5); 150 | assert_eq!(meldableheap.remove(), Some(4)); 151 | assert_eq!(meldableheap.n, 4); 152 | assert_eq!(meldableheap.remove(), Some(7)); 153 | assert_eq!(meldableheap.remove(), Some(8)); 154 | assert_eq!(meldableheap.remove(), Some(9)); 155 | assert_eq!(meldableheap.remove(), Some(26)); 156 | assert_eq!(meldableheap.n, 0); 157 | assert_eq!(meldableheap.remove(), None); 158 | println!("{:?}", meldableheap); 159 | 160 | // test large linked list for stack overflow. 161 | let mut bst = MeldableHeap::::new(); 162 | let num = 100000; 163 | for i in 0..num { 164 | bst.add(i); 165 | } 166 | println!("fin"); 167 | } 168 | } 169 | -------------------------------------------------------------------------------- /chapter10/src/binaryheap.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::Queue; 3 | 4 | #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] 5 | pub struct BinaryHeap { 6 | a: Box<[Option]>, 7 | n: usize, 8 | } 9 | 10 | impl BinaryHeap { 11 | pub fn length(&self) -> usize { 12 | self.a.len() 13 | } 14 | 15 | pub fn new() -> Self { 16 | Self::with_length(1) 17 | } 18 | 19 | pub fn with_length(capacity: usize) -> Self { 20 | Self { 21 | a: Self::allocate_in_heap(capacity), 22 | n: 0, 23 | } 24 | } 25 | 26 | fn allocate_in_heap(size: usize) -> Box<[Option]> { 27 | std::iter::repeat_with(Default::default) 28 | .take(size) 29 | .collect::>() 30 | .into_boxed_slice() 31 | } 32 | 33 | fn resize(&mut self) { 34 | let new_a = Self::allocate_in_heap(std::cmp::max(self.n * 2, 1)); 35 | let old_a = std::mem::replace(&mut self.a, new_a); 36 | for (i, elem) in old_a.into_vec().into_iter().enumerate().take(self.n) { 37 | self.a[i] = elem; 38 | } 39 | } 40 | fn bubbleup(&mut self, mut i: usize) { 41 | let mut p = Self::parent(i); 42 | while self.a.get(i) < self.a.get(p) { 43 | self.a.swap(i, p); 44 | i = p; 45 | p = Self::parent(i); 46 | } 47 | } 48 | fn trickle_down(&mut self, mut i: usize) { 49 | loop { 50 | let mut flag = false; 51 | let mut j = i; 52 | let r = Self::riht(i); 53 | if r < self.n && self.a.get(r) < self.a.get(i) { 54 | let l = Self::left(i); 55 | if self.a.get(l) < self.a.get(r) { 56 | j = l; 57 | flag = true; 58 | } else { 59 | j = r; 60 | flag = true; 61 | } 62 | } else { 63 | let l = Self::left(i); 64 | if l < self.n && self.a.get(l) < self.a.get(i) { 65 | j = l; 66 | flag = true; 67 | } 68 | } 69 | if flag { 70 | self.a.swap(i, j); 71 | i = j; 72 | } else { 73 | break; 74 | } 75 | } 76 | } 77 | fn left(i: usize) -> usize { 78 | 2 * i + 1 79 | } 80 | fn riht(i: usize) -> usize { 81 | 2 * i + 2 82 | } 83 | fn parent(i: usize) -> usize { 84 | (std::cmp::max(1, i) - 1) / 2 85 | } 86 | } 87 | 88 | impl BinaryHeap { 89 | fn from_slice(b: &[T]) -> Self { 90 | let mut bh = Self { 91 | a: b.iter() 92 | .map(|x| Some(x.clone())) 93 | .take(b.len()) 94 | .collect::>() 95 | .into_boxed_slice(), 96 | n: b.len(), 97 | }; 98 | for i in (0..std::cmp::max(bh.n / 2, 1)).rev() { 99 | bh.trickle_down(i); 100 | } 101 | bh 102 | } 103 | pub fn sort(b: &mut [T]) { 104 | let mut h = Self::from_slice(b); 105 | while h.n > 1 { 106 | h.n -= 1; 107 | h.a.swap(h.n, 0); 108 | h.trickle_down(0); 109 | } 110 | for (i, bi) in b.iter_mut().enumerate() { 111 | *bi = h.a[i].take().unwrap(); 112 | } 113 | b.reverse(); 114 | } 115 | } 116 | impl Queue for BinaryHeap { 117 | fn add(&mut self, x: T) { 118 | if self.n + 1 > self.length() { 119 | self.resize(); 120 | } 121 | self.a[self.n] = Some(x); 122 | self.n += 1; 123 | self.bubbleup(self.n - 1); 124 | } 125 | 126 | fn remove(&mut self) -> Option { 127 | let x = self.a.get_mut(0)?.take(); 128 | self.a[0] = self.a.get_mut(self.n - 1)?.take(); 129 | self.n -= 1; 130 | self.trickle_down(0); 131 | if 3 * self.n < self.length() { 132 | self.resize(); 133 | } 134 | x 135 | } 136 | } 137 | 138 | #[cfg(test)] 139 | mod test { 140 | use super::*; 141 | use chapter01::interface::Queue; 142 | #[test] 143 | fn test_binaryheap() { 144 | let mut binaryheap = BinaryHeap::::new(); 145 | binaryheap.add(4); 146 | binaryheap.add(9); 147 | binaryheap.add(8); 148 | binaryheap.add(17); 149 | binaryheap.add(26); 150 | binaryheap.add(50); 151 | binaryheap.add(16); 152 | binaryheap.add(19); 153 | binaryheap.add(69); 154 | binaryheap.add(32); 155 | binaryheap.add(93); 156 | binaryheap.add(55); 157 | binaryheap.add(6); 158 | assert_eq!(&Some(4), binaryheap.a.get(0).unwrap()); 159 | assert_eq!(&Some(9), binaryheap.a.get(1).unwrap()); 160 | assert_eq!(&Some(6), binaryheap.a.get(2).unwrap()); 161 | assert_eq!(&Some(17), binaryheap.a.get(3).unwrap()); 162 | assert_eq!(&Some(26), binaryheap.a.get(4).unwrap()); 163 | assert_eq!(&Some(8), binaryheap.a.get(5).unwrap()); 164 | assert_eq!(&Some(16), binaryheap.a.get(6).unwrap()); 165 | assert_eq!(&Some(19), binaryheap.a.get(7).unwrap()); 166 | assert_eq!(&Some(69), binaryheap.a.get(8).unwrap()); 167 | assert_eq!(&Some(32), binaryheap.a.get(9).unwrap()); 168 | assert_eq!(&Some(93), binaryheap.a.get(10).unwrap()); 169 | assert_eq!(&Some(55), binaryheap.a.get(11).unwrap()); 170 | assert_eq!(&Some(50), binaryheap.a.get(12).unwrap()); 171 | assert_eq!(Some(4), binaryheap.remove()); 172 | assert_eq!(&Some(6), binaryheap.a.get(0).unwrap()); 173 | assert_eq!(&Some(9), binaryheap.a.get(1).unwrap()); 174 | assert_eq!(&Some(8), binaryheap.a.get(2).unwrap()); 175 | assert_eq!(&Some(17), binaryheap.a.get(3).unwrap()); 176 | assert_eq!(&Some(26), binaryheap.a.get(4).unwrap()); 177 | assert_eq!(&Some(50), binaryheap.a.get(5).unwrap()); 178 | assert_eq!(&Some(16), binaryheap.a.get(6).unwrap()); 179 | assert_eq!(&Some(19), binaryheap.a.get(7).unwrap()); 180 | assert_eq!(&Some(69), binaryheap.a.get(8).unwrap()); 181 | assert_eq!(&Some(32), binaryheap.a.get(9).unwrap()); 182 | assert_eq!(&Some(93), binaryheap.a.get(10).unwrap()); 183 | assert_eq!(&Some(55), binaryheap.a.get(11).unwrap()); 184 | //println!("{:?}", binaryheap); 185 | } 186 | } 187 | -------------------------------------------------------------------------------- /chapter05/src/linearhashtable.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use super::{byte_chunks_64, Tabulation}; 3 | use chapter01::interface::USet; 4 | use lazy_static::lazy_static; 5 | use rand::{thread_rng, Rng}; 6 | use std::hash::Hash; 7 | 8 | lazy_static! { 9 | pub static ref TAB: [[u64; 256]; 8] = { 10 | let mut array = [[0; 256]; 8]; 11 | for item in &mut array { 12 | thread_rng().fill(item); 13 | } 14 | array 15 | }; 16 | } 17 | 18 | #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Copy)] 19 | enum Elem { 20 | Val(T), 21 | Null, 22 | Del, 23 | } 24 | 25 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 26 | pub struct LinearHashTable { 27 | t: Box<[Elem]>, 28 | n: usize, 29 | q: usize, 30 | d: u32, 31 | } 32 | 33 | impl Default for Elem { 34 | fn default() -> Self { 35 | Elem::Null 36 | } 37 | } 38 | impl Tabulation for T {} 39 | impl LinearHashTable 40 | where 41 | T: PartialEq + Clone + Hash, 42 | { 43 | const W: u32 = (std::mem::size_of::() * 8) as u32; 44 | pub fn new() -> Self { 45 | Self { 46 | t: Self::allocate_in_heap(2), 47 | n: 0, 48 | q: 1, 49 | d: 1, 50 | } 51 | } 52 | fn allocate_in_heap(size: usize) -> Box<[Elem]> { 53 | std::iter::repeat_with(|| Default::default()) 54 | .take(size) 55 | .collect::>() 56 | .into_boxed_slice() 57 | } 58 | fn hash(&self, x: &T) -> usize { 59 | // u64 tabulation hashing 60 | 61 | let mut v = 0u64; 62 | let h = x.hashcode(); 63 | let chunks = byte_chunks_64(h as u64); 64 | for (i, c) in chunks.iter().enumerate() { 65 | v ^= TAB[i][*c as usize]; 66 | } 67 | v = v.overflowing_shr(Self::W - self.d).0; 68 | v as usize 69 | } 70 | fn resize(&mut self) { 71 | self.d = 1; 72 | while (1 << self.d) < 3 * self.n { 73 | self.d += 1; 74 | } 75 | let new_t = Self::allocate_in_heap(1 << self.d); 76 | let old_t = std::mem::replace(&mut self.t, new_t); 77 | for oelem in old_t.into_vec().into_iter() { 78 | match oelem { 79 | Elem::Val(x) => { 80 | let mut i = self.hash(&x); 81 | loop { 82 | match self.t.get(i) { 83 | Some(nelem) if nelem != &Elem::Null => { 84 | i = if i == self.t.len() - 1 { 0 } else { i + 1 } 85 | } 86 | _ => break, 87 | } 88 | } 89 | if let Some(elem) = self.t.get_mut(i) { 90 | *elem = Elem::Val(x); 91 | } 92 | } 93 | _ => continue, 94 | } 95 | } 96 | } 97 | } 98 | 99 | impl USet for LinearHashTable 100 | where 101 | T: PartialEq + Clone + Hash, 102 | { 103 | fn size(&self) -> usize { 104 | self.n 105 | } 106 | fn add(&mut self, x: T) -> bool { 107 | if self.find(&x).is_some() { 108 | return false; 109 | } 110 | if 2 * (self.q + 1) > self.t.len() { 111 | self.resize(); 112 | } 113 | let mut i = self.hash(&x); 114 | loop { 115 | match self.t.get(i) { 116 | Some(elem) => match elem { 117 | Elem::Val(_y) => i = if i == self.t.len() - 1 { 0 } else { i + 1 }, 118 | _ => break, 119 | }, 120 | None => return false, 121 | } 122 | } 123 | if self.t.get(i).unwrap() == &Elem::Null { 124 | self.q += 1 125 | } 126 | self.n += 1; 127 | if let Some(elem) = self.t.get_mut(i) { 128 | *elem = Elem::Val(x) 129 | } 130 | true 131 | } 132 | fn remove(&mut self, x: &T) -> Option { 133 | let mut i = self.hash(x); 134 | loop { 135 | match self.t.get_mut(i) { 136 | Some(elem) if elem != &Elem::Null => match elem { 137 | Elem::Val(y) if y == x => { 138 | let y = std::mem::replace(elem, Elem::Del); 139 | self.n -= 1; 140 | if 8 * self.n < self.t.len() { 141 | self.resize() 142 | } 143 | break match y { 144 | Elem::Val(y) => Some(y), 145 | _ => None, 146 | }; 147 | } 148 | _ => i = if i == self.t.len() - 1 { 0 } else { i + 1 }, 149 | }, 150 | _ => break None, 151 | } 152 | } 153 | } 154 | fn find(&self, x: &T) -> Option { 155 | let mut i = self.hash(x); 156 | loop { 157 | match self.t.get(i) { 158 | Some(elem) if elem != &Elem::Null => match elem { 159 | Elem::Val(y) if y == x => break Some(y.clone()), 160 | _ => i = if i == self.t.len() - 1 { 0 } else { i + 1 }, 161 | }, 162 | _ => break None, 163 | } 164 | } 165 | } 166 | } 167 | 168 | #[cfg(test)] 169 | mod test { 170 | use super::LinearHashTable; 171 | use chapter01::interface::USet; 172 | #[test] 173 | fn test_linearhashtable() { 174 | let mut linearhashtable = LinearHashTable::::new(); 175 | linearhashtable.add('a'); 176 | linearhashtable.add('b'); 177 | linearhashtable.add('c'); 178 | linearhashtable.add('d'); 179 | linearhashtable.add('e'); 180 | linearhashtable.add('x'); 181 | assert_eq!(false, linearhashtable.add('x')); 182 | for elem in "abcdex".chars() { 183 | assert_eq!(linearhashtable.find(&elem), Some(elem)); 184 | } 185 | assert_eq!(linearhashtable.remove(&'x'), Some('x')); 186 | assert_eq!(linearhashtable.remove(&'x'), None); 187 | assert_eq!(linearhashtable.remove(&'a'), Some('a')); 188 | assert_eq!(linearhashtable.remove(&'b'), Some('b')); 189 | assert_eq!(linearhashtable.remove(&'c'), Some('c')); 190 | assert_eq!(linearhashtable.remove(&'e'), Some('e')); 191 | assert_eq!(linearhashtable.remove(&'a'), None); 192 | println!("{:?}", linearhashtable); 193 | } 194 | } 195 | -------------------------------------------------------------------------------- /chapter06/src/binarytree.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::List; 3 | use chapter02::arraydeque::Array as ArrayDeque; 4 | use std::cell::RefCell; 5 | use std::rc::{Rc, Weak}; 6 | 7 | type Tree = Option>; 8 | 9 | #[derive(Clone, Debug, Default)] 10 | pub struct BTNode { 11 | left: RefCell>>, 12 | right: RefCell>>, 13 | parent: RefCell>>, 14 | } 15 | 16 | #[derive(Clone, Debug, Default)] 17 | pub struct BinaryTree { 18 | r: Option>, 19 | } 20 | 21 | impl BTNode { 22 | pub fn new() -> Self { 23 | Self { 24 | ..Default::default() 25 | } 26 | } 27 | } 28 | 29 | impl BinaryTree { 30 | pub fn new(r: Rc) -> Self { 31 | Self { r: Some(r) } 32 | } 33 | 34 | pub fn depth(&self, u: &Tree) -> usize { 35 | let mut u = u.clone(); 36 | let mut d = 0; 37 | loop { 38 | match u { 39 | Some(n) if !Rc::ptr_eq(&n, self.r.as_ref().unwrap()) => { 40 | u = n.parent.borrow().as_ref().and_then(|p| p.upgrade()); 41 | d += 1; 42 | } 43 | _ => break d, 44 | }; 45 | } 46 | } 47 | 48 | fn size_u(u: &Tree) -> usize { 49 | match u { 50 | Some(n) => 1 + Self::size_u(&n.left.borrow()) + Self::size_u(&n.right.borrow()), 51 | None => 0, 52 | } 53 | } 54 | pub fn size(&self) -> usize { 55 | Self::size_u(&self.r) 56 | } 57 | 58 | pub fn size2(&self) -> usize { 59 | let mut c: usize = 0; 60 | let mut u = self.r.clone(); 61 | let mut next: Option>; 62 | let mut prev: Option> = None; 63 | loop { 64 | match u { 65 | Some(ref n) => { 66 | let parent = n.parent.borrow().as_ref().and_then(|p| p.upgrade()); 67 | let left = n.left.borrow().clone(); 68 | let right = n.right.borrow().clone(); 69 | match (prev, parent, left, right) { 70 | (Some(p), Some(v), left, right) if Rc::ptr_eq(&p, &v) => { 71 | c += 1; 72 | next = left.or(right).or(Some(p)); 73 | } 74 | (None, None, left, right) => { 75 | c += 1; 76 | next = left.or(right).or(None); 77 | } 78 | (Some(p), parent, Some(l), right) if Rc::ptr_eq(&p, &l) => { 79 | next = right.or(parent); 80 | } 81 | (None, parent, None, right) => { 82 | next = right.or(parent); 83 | } 84 | (_, parent, ..) => next = parent, 85 | } 86 | } 87 | None => break c, 88 | } 89 | prev = u; 90 | u = next; 91 | } 92 | } 93 | 94 | fn height_u(u: &Tree) -> i32 { 95 | match u { 96 | Some(n) => { 97 | 1 + std::cmp::max( 98 | Self::height_u(&n.left.borrow()), 99 | Self::height_u(&n.right.borrow()), 100 | ) 101 | } 102 | None => -1, 103 | } 104 | } 105 | 106 | pub fn height(&self) -> i32 { 107 | Self::height_u(&self.r) 108 | } 109 | 110 | fn traverse_u(u: &Tree) { 111 | match u { 112 | Some(n) => { 113 | Self::traverse_u(&n.left.borrow()); 114 | Self::traverse_u(&n.right.borrow()); 115 | } 116 | None => (), 117 | } 118 | } 119 | 120 | pub fn traverse(&self) { 121 | Self::traverse_u(&self.r) 122 | } 123 | 124 | pub fn traverse2(&self) { 125 | let mut u = self.r.clone(); 126 | let mut next: Option>; 127 | let mut prev: Option> = None; 128 | while let Some(ref n) = u { 129 | let parent = n.parent.borrow().as_ref().and_then(|p| p.upgrade()); 130 | let left = n.left.borrow().clone(); 131 | let right = n.right.borrow().clone(); 132 | match (prev, parent, left, right) { 133 | (Some(p), Some(v), left, right) if Rc::ptr_eq(&p, &v) => { 134 | next = left.or(right).or(Some(p)); 135 | } 136 | (None, None, left, right) => { 137 | next = left.or(right).or(None); 138 | } 139 | (Some(p), parent, Some(l), right) if Rc::ptr_eq(&p, &l) => { 140 | next = right.or(parent); 141 | } 142 | (None, parent, None, right) => { 143 | next = right.or(parent); 144 | } 145 | (_, parent, ..) => next = parent, 146 | } 147 | prev = u; 148 | u = next; 149 | } 150 | } 151 | 152 | pub fn bf_traverse(&self) { 153 | let mut q: ArrayDeque> = ArrayDeque::new(); 154 | if let Some(r) = self.r.clone() { 155 | q.add(q.size(), r) 156 | } 157 | while q.size() > 0 { 158 | if let Some(u) = q.remove(q.size() - 1) { 159 | if let Some(l) = u.left.borrow().as_ref() { 160 | q.add(q.size(), l.clone()) 161 | } 162 | if let Some(r) = u.right.borrow().as_ref() { 163 | q.add(q.size(), r.clone()) 164 | } 165 | } 166 | } 167 | } 168 | } 169 | 170 | #[cfg(test)] 171 | mod test { 172 | use super::*; 173 | #[test] 174 | fn test_binarytree() { 175 | let r = Rc::new(BTNode::new()); 176 | let n1 = Rc::new(BTNode::new()); 177 | let n2 = Rc::new(BTNode::new()); 178 | let n3 = Rc::new(BTNode::new()); 179 | // r.left = n1, n1.parent = r 180 | // r.right = n2, n2.parent = r 181 | // n2.left = n3, n3.parent = n2 182 | r.left.borrow_mut().replace(Rc::clone(&n1)); 183 | n1.parent.borrow_mut().replace(Rc::downgrade(&r)); 184 | r.right.borrow_mut().replace(Rc::clone(&n2)); 185 | n2.parent.borrow_mut().replace(Rc::downgrade(&r)); 186 | n2.left.borrow_mut().replace(Rc::clone(&n3)); 187 | n3.parent.borrow_mut().replace(Rc::downgrade(&n2)); 188 | 189 | let binarytree = BinaryTree::new(Rc::clone(&r)); 190 | assert_eq!(4, binarytree.size()); 191 | assert_eq!(4, binarytree.size2()); 192 | assert_eq!(2, binarytree.height()); 193 | assert_eq!((), binarytree.traverse()); 194 | assert_eq!((), binarytree.traverse2()); 195 | assert_eq!((), binarytree.bf_traverse()); 196 | } 197 | } 198 | -------------------------------------------------------------------------------- /chapter04/src/skiplistsset.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::SSet; 3 | use std::cell::RefCell; 4 | use std::rc::Rc; 5 | 6 | type Link = Option>>>; 7 | 8 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 9 | pub struct SkiplistSSet { 10 | head: Link, 11 | h: usize, 12 | n: usize, 13 | } 14 | 15 | impl Drop for SkiplistSSet { 16 | fn drop(&mut self) { 17 | while let Some(ref x) = self 18 | .head 19 | .as_ref() 20 | .and_then(|s| s.borrow().next[0].as_ref().map(|n| n.borrow().x.clone())) 21 | { 22 | self.remove(x); 23 | } 24 | } 25 | } 26 | 27 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 28 | struct Node { 29 | x: T, 30 | next: Vec>, 31 | } 32 | 33 | impl Node { 34 | fn new(x: T, h: usize) -> Rc>> { 35 | Rc::new(RefCell::new(Node { 36 | x, 37 | next: vec![None; h + 1], 38 | })) 39 | } 40 | } 41 | 42 | impl SkiplistSSet { 43 | pub fn new() -> Self { 44 | let sentinel = Node::new(Default::default(), 32); 45 | Self { 46 | head: Some(sentinel), 47 | h: 0, 48 | n: 0, 49 | } 50 | } 51 | 52 | fn find_pred_node(&self, x: &T) -> Link { 53 | match self.head { 54 | Some(ref sentinel) => { 55 | let mut n = Rc::clone(sentinel); 56 | for r in (0..=self.h).rev() { 57 | loop { 58 | let u = Rc::clone(&n); 59 | match u.borrow().next[r] { 60 | Some(ref u) if u.borrow().x < *x => n = Rc::clone(u), 61 | _ => break, 62 | }; 63 | } 64 | } 65 | Some(n) 66 | } 67 | None => None, 68 | } 69 | } 70 | fn pick_height() -> usize { 71 | let z = rand::random::(); 72 | let mut k = 0; 73 | let mut m = 1; 74 | while (z & m) != 0 { 75 | k += 1; 76 | m <<= 1; 77 | } 78 | k 79 | } 80 | } 81 | 82 | impl SSet for SkiplistSSet { 83 | fn size(&self) -> usize { 84 | self.n 85 | } 86 | 87 | fn add(&mut self, x: T) -> bool { 88 | match self.head { 89 | Some(ref sentinel) => { 90 | let mut stack: Vec> = vec![None; sentinel.borrow().next.len()]; 91 | let mut n = Rc::clone(sentinel); 92 | for r in (0..=self.h).rev() { 93 | loop { 94 | let u = Rc::clone(&n); 95 | match u.borrow().next[r] { 96 | Some(ref u) if u.borrow().x < x => n = Rc::clone(u), 97 | Some(ref u) if u.borrow().x == x => return false, 98 | _ => break, 99 | }; 100 | } 101 | stack[r] = Some(Rc::clone(&n)); 102 | } 103 | let w = Node::new(x, Self::pick_height()); 104 | let height = w.borrow().next.len() - 1; 105 | while self.h < height { 106 | if let Some(sentinel) = self 107 | .head 108 | .as_ref() 109 | .filter(|sentinel| sentinel.borrow().next.len() < w.borrow().next.len()) 110 | { 111 | sentinel.borrow_mut().next.push(None); 112 | } 113 | self.h += 1; 114 | if let Some(e) = stack.get_mut(self.h) { 115 | e.replace(Rc::clone(sentinel)); 116 | } else { 117 | stack.push(Some(Rc::clone(sentinel))); 118 | } 119 | } 120 | for (i, item) in stack.iter_mut().enumerate().take(height + 1) { 121 | match item.take() { 122 | Some(ref u) => { 123 | w.borrow_mut().next[i] = u.borrow_mut().next[i].take(); 124 | u.borrow_mut().next[i] = Some(Rc::clone(&w)); 125 | } 126 | None => break, 127 | } 128 | } 129 | self.n += 1; 130 | true 131 | } 132 | None => false, 133 | } 134 | } 135 | 136 | fn remove(&mut self, x: &T) -> Option { 137 | match self.head { 138 | Some(ref sentinel) => { 139 | let mut n = Rc::clone(sentinel); 140 | let mut del = None; 141 | let rh = self.h; 142 | for r in (0..=rh).rev() { 143 | let removed = loop { 144 | let u = Rc::clone(&n); 145 | match u.borrow().next[r] { 146 | Some(ref u) if u.borrow().x < *x => n = Rc::clone(u), 147 | Some(ref u) if u.borrow().x == *x => break true, 148 | _ => break false, 149 | }; 150 | }; 151 | if removed { 152 | del = n.borrow_mut().next[r].take(); 153 | if let Some(del) = del.as_ref() { 154 | if let Some(next) = del.borrow_mut().next[r].take() { 155 | n.borrow_mut().next[r] = Some(next); 156 | } else if Rc::ptr_eq(&n, self.head.as_ref().unwrap()) && self.h > 0 { 157 | self.h -= 1; 158 | } 159 | } 160 | } 161 | } 162 | del.map(|del| { 163 | self.n -= 1; 164 | Rc::try_unwrap(del).ok().unwrap().into_inner().x 165 | }) 166 | } 167 | None => None, 168 | } 169 | } 170 | 171 | fn find(&self, x: &T) -> Option { 172 | match self.find_pred_node(x) { 173 | Some(ref u) if u.borrow().next[0].is_some() => { 174 | u.borrow().next[0].as_ref().map(|u| u.borrow().x.clone()) 175 | } 176 | _ => None, 177 | } 178 | } 179 | } 180 | 181 | #[cfg(test)] 182 | mod test { 183 | use super::SkiplistSSet; 184 | use chapter01::interface::SSet; 185 | use rand::{thread_rng, Rng}; 186 | #[test] 187 | fn test_skiplistsset() { 188 | let mut skiplistsset: SkiplistSSet = SkiplistSSet::new(); 189 | skiplistsset.add(0); 190 | skiplistsset.add(1); 191 | skiplistsset.add(2); 192 | skiplistsset.add(3); 193 | skiplistsset.add(5); 194 | skiplistsset.add(6); 195 | skiplistsset.add(7); 196 | for i in 0..8 { 197 | if i == 4 { 198 | continue; 199 | } 200 | assert_eq!(skiplistsset.find(&i), Some(i)); 201 | } 202 | assert_eq!(skiplistsset.size(), 7); 203 | skiplistsset.add(4); 204 | for i in 0..8 { 205 | assert_eq!(skiplistsset.find(&i), Some(i)); 206 | } 207 | assert_eq!(skiplistsset.remove(&4), Some(4)); 208 | for i in 0..8 { 209 | if i == 4 { 210 | continue; 211 | } 212 | assert_eq!(skiplistsset.find(&i), Some(i)); 213 | } 214 | assert_eq!(skiplistsset.remove(&9), None); 215 | let mut skiplistsset: SkiplistSSet = SkiplistSSet::new(); 216 | let n = 200; 217 | let mut rng = thread_rng(); 218 | for _ in 0..5 { 219 | for _ in 0..n { 220 | let x = rng.gen_range(0, 5 * n); 221 | skiplistsset.add(x); 222 | } 223 | for _ in 0..n { 224 | let x = rng.gen_range(0, 5 * n); 225 | skiplistsset.remove(&x); 226 | } 227 | } 228 | 229 | // test large linked list for stack overflow. 230 | let mut skiplistsset: SkiplistSSet = SkiplistSSet::new(); 231 | let num = 100000; 232 | for i in 0..num { 233 | skiplistsset.add(i); 234 | } 235 | println!("fin"); 236 | } 237 | } 238 | -------------------------------------------------------------------------------- /chapter06/src/binarysearchtree.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::SSet; 3 | use std::cell::RefCell; 4 | use std::rc::{Rc, Weak}; 5 | 6 | type Tree = Option>>; 7 | 8 | #[derive(Clone, Debug, Default)] 9 | pub struct BSTNode { 10 | x: RefCell, 11 | left: RefCell>>>, 12 | right: RefCell>>>, 13 | parent: RefCell>>>, 14 | } 15 | 16 | #[derive(Clone, Debug, Default)] 17 | pub struct BinarySearchTree { 18 | n: usize, 19 | r: Option>>, 20 | } 21 | 22 | impl Drop for BinarySearchTree { 23 | fn drop(&mut self) { 24 | while let Some(r) = self.r.clone() { 25 | self.splice(r); 26 | } 27 | } 28 | } 29 | 30 | impl BSTNode { 31 | pub fn new(x: T) -> Self { 32 | Self { 33 | x: RefCell::new(x), 34 | ..Default::default() 35 | } 36 | } 37 | } 38 | 39 | impl BinarySearchTree { 40 | pub fn new() -> Self { 41 | Self { n: 0, r: None } 42 | } 43 | fn height_u(u: &Tree) -> i32 { 44 | match u { 45 | Some(n) => { 46 | 1 + std::cmp::max( 47 | Self::height_u(&n.left.borrow()), 48 | Self::height_u(&n.right.borrow()), 49 | ) 50 | } 51 | None => -1, 52 | } 53 | } 54 | 55 | pub fn height(&self) -> i32 { 56 | Self::height_u(&self.r) 57 | } 58 | 59 | pub fn find_eq(&self, x: &T) -> Option { 60 | let mut w = self.r.clone(); 61 | let mut next; 62 | loop { 63 | match w { 64 | Some(ref u) if x < &*u.x.borrow() => next = u.left.borrow().clone(), 65 | Some(ref u) if x > &*u.x.borrow() => next = u.right.borrow().clone(), 66 | Some(ref u) if x == &*u.x.borrow() => break Some(u.x.borrow().clone()), 67 | _ => break None, 68 | } 69 | w = next; 70 | } 71 | } 72 | fn find_last(&self, x: &T) -> Tree { 73 | let mut w = self.r.clone(); 74 | let mut prev = None; 75 | let mut next; 76 | loop { 77 | match w { 78 | Some(ref u) => { 79 | prev = w.clone(); 80 | if x < &*u.x.borrow() { 81 | next = u.left.borrow().clone(); 82 | } else if x > &*u.x.borrow() { 83 | next = u.right.borrow().clone(); 84 | } else { 85 | break Some(u.clone()); 86 | } 87 | } 88 | _ => break prev, 89 | } 90 | w = next; 91 | } 92 | } 93 | fn add_child(&mut self, p: &Tree, u: Rc>) -> bool { 94 | match p { 95 | Some(p) => { 96 | if *p.x.borrow() > *u.x.borrow() { 97 | p.left.borrow_mut().replace(u.clone()); 98 | } else if *p.x.borrow() < *u.x.borrow() { 99 | p.right.borrow_mut().replace(u.clone()); 100 | } else { 101 | return false; 102 | } 103 | u.parent.borrow_mut().replace(Rc::downgrade(p)); 104 | } 105 | None => self.r = Some(u), 106 | } 107 | self.n += 1; 108 | true 109 | } 110 | fn splice(&mut self, u: Rc>) -> Option { 111 | let s: Tree; 112 | let mut p: Tree = None; 113 | if u.left.borrow().is_some() { 114 | s = u.left.borrow_mut().take(); 115 | } else { 116 | s = u.right.borrow_mut().take(); 117 | } 118 | if let Some(r) = &self.r { 119 | if Rc::ptr_eq(&u, r) { 120 | self.r = s.clone(); 121 | p = None; 122 | } else { 123 | p = u.parent.borrow_mut().take().and_then(|p| p.upgrade()); 124 | if let Some(p) = p.as_ref() { 125 | let left = p.left.borrow().clone(); 126 | match left { 127 | Some(ref left) if Rc::ptr_eq(left, &u) => { 128 | *p.left.borrow_mut() = s.clone(); 129 | } 130 | _ => { 131 | *p.right.borrow_mut() = s.clone(); 132 | } 133 | } 134 | } 135 | } 136 | } 137 | match (s, p) { 138 | (Some(ref s), Some(ref p)) => { 139 | s.parent.borrow_mut().replace(Rc::downgrade(p)); 140 | } 141 | (Some(ref s), None) => { 142 | s.parent.borrow_mut().take(); 143 | } 144 | _ => (), 145 | } 146 | self.n -= 1; 147 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 148 | } 149 | fn remove_u(&mut self, u: Rc>) -> Option { 150 | if u.left.borrow().is_none() || u.right.borrow().is_none() { 151 | self.splice(u) 152 | } else { 153 | let mut w = u.right.borrow().clone(); 154 | loop { 155 | let mut next = None; 156 | if let Some(ref w) = w { 157 | match *w.left.borrow() { 158 | Some(ref left) => next = Some(left.clone()), 159 | None => break, 160 | } 161 | } 162 | w = next; 163 | } 164 | u.x.swap(&w.as_ref().unwrap().x); 165 | self.splice(w.unwrap()) 166 | } 167 | } 168 | } 169 | 170 | impl SSet for BinarySearchTree 171 | where 172 | T: Ord + Clone + Default, 173 | { 174 | fn size(&self) -> usize { 175 | self.n 176 | } 177 | fn add(&mut self, x: T) -> bool { 178 | let p = self.find_last(&x); 179 | let u = Rc::new(BSTNode::::new(x)); 180 | self.add_child(&p, u) 181 | } 182 | fn remove(&mut self, x: &T) -> Option { 183 | match self.find_last(x) { 184 | Some(u) if &*u.x.borrow() == x => self.remove_u(u), 185 | _ => None, 186 | } 187 | } 188 | fn find(&self, x: &T) -> Option { 189 | let mut w = self.r.clone(); 190 | let mut z: Tree = None; 191 | let mut next; 192 | loop { 193 | match w { 194 | Some(ref u) if x < &*u.x.borrow() => { 195 | z = w.clone(); 196 | next = u.left.borrow().clone() 197 | } 198 | Some(ref u) if x > &*u.x.borrow() => next = u.right.borrow().clone(), 199 | Some(ref u) if x == &*u.x.borrow() => break Some(u.x.borrow().clone()), 200 | _ => { 201 | break match z { 202 | Some(z) => Some(z.x.borrow().clone()), 203 | None => None, 204 | } 205 | } 206 | } 207 | w = next; 208 | } 209 | } 210 | } 211 | 212 | #[cfg(test)] 213 | mod test { 214 | use super::*; 215 | use chapter01::interface::SSet; 216 | #[test] 217 | fn test_binarysearchtree() { 218 | let mut binarysearchtree = BinarySearchTree::::new(); 219 | binarysearchtree.add(7); 220 | binarysearchtree.add(3); 221 | binarysearchtree.add(11); 222 | binarysearchtree.add(1); 223 | binarysearchtree.add(5); 224 | binarysearchtree.add(9); 225 | binarysearchtree.add(13); 226 | binarysearchtree.add(4); 227 | binarysearchtree.add(6); 228 | binarysearchtree.add(8); 229 | binarysearchtree.add(12); 230 | binarysearchtree.add(14); 231 | assert_eq!(false, binarysearchtree.add(8)); 232 | assert_eq!(Some(6), binarysearchtree.remove(&6)); 233 | assert_eq!(Some(9), binarysearchtree.remove(&9)); 234 | assert_eq!(Some(11), binarysearchtree.remove(&11)); 235 | assert_eq!(None, binarysearchtree.remove(&11)); 236 | assert_eq!(Some(12), binarysearchtree.find(&12)); 237 | assert_eq!(9, binarysearchtree.size()); 238 | //println!("{:?}", binarysearchtree); 239 | 240 | // test large linked list for stack overflow. 241 | let mut bst = BinarySearchTree::::new(); 242 | let num = 10000; 243 | for i in 0..num { 244 | bst.add(i); 245 | } 246 | println!("fin"); 247 | } 248 | } 249 | -------------------------------------------------------------------------------- /chapter04/src/skiplistlist.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::List; 3 | use std::cell::RefCell; 4 | use std::rc::Rc; 5 | 6 | type Link = Option>>>; 7 | 8 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 9 | pub struct SkiplistList { 10 | head: Link, 11 | h: usize, 12 | n: usize, 13 | } 14 | 15 | impl Drop for SkiplistList 16 | where 17 | T: Clone + Default, 18 | { 19 | fn drop(&mut self) { 20 | while self.remove(0).is_some() {} 21 | } 22 | } 23 | 24 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 25 | struct Node { 26 | x: T, 27 | length: Vec, 28 | next: Vec>, 29 | } 30 | 31 | impl Node { 32 | fn new(x: T, h: usize) -> Rc>> { 33 | Rc::new(RefCell::new(Node { 34 | x, 35 | length: vec![0; h + 1], 36 | next: vec![None; h + 1], 37 | })) 38 | } 39 | } 40 | 41 | impl SkiplistList { 42 | pub fn new() -> Self { 43 | let sentinel = Node::new(Default::default(), 32); 44 | Self { 45 | head: Some(sentinel), 46 | h: 0, 47 | n: 0, 48 | } 49 | } 50 | fn pick_height() -> usize { 51 | let z = rand::random::(); 52 | let mut k = 0; 53 | let mut m = 1; 54 | while (z & m) != 0 { 55 | k += 1; 56 | m <<= 1; 57 | } 58 | k 59 | } 60 | fn find_pred_node(&self, i: usize) -> Link { 61 | match self.head { 62 | Some(ref sentinel) => { 63 | let mut n = Rc::clone(sentinel); 64 | let mut j = 0; 65 | for r in (0..=self.h).rev() { 66 | loop { 67 | let u = Rc::clone(&n); 68 | match u.borrow().next[r] { 69 | Some(ref u) if j + n.borrow().length[r] - 1 < i => { 70 | j += n.borrow().length[r]; 71 | n = Rc::clone(u) 72 | } 73 | _ => break, 74 | }; 75 | } 76 | } 77 | Some(n) 78 | } 79 | None => None, 80 | } 81 | } 82 | fn add_node(&mut self, i: usize, w: Rc>>) { 83 | if let Some(ref sentinel) = self.head { 84 | let mut n = Rc::clone(sentinel); 85 | let mut j = 0; 86 | for r in (0..=self.h).rev() { 87 | loop { 88 | let u = Rc::clone(&n); 89 | match u.borrow().next[r] { 90 | Some(ref u) if j + n.borrow().length[r] - 1 < i => { 91 | j += n.borrow().length[r]; 92 | n = Rc::clone(u); 93 | } 94 | _ => break, 95 | }; 96 | } 97 | n.borrow_mut().length[r] += 1; 98 | if r < w.borrow().next.len() { 99 | let next = n.borrow_mut().next[r].take(); 100 | if let Some(u) = next { 101 | w.borrow_mut().next[r] = Some(u); 102 | w.borrow_mut().length[r] = n.borrow().length[r] + j - i - 1; 103 | } 104 | n.borrow_mut().next[r] = Some(Rc::clone(&w)); 105 | n.borrow_mut().length[r] = i + 1 - j; 106 | } 107 | } 108 | self.n += 1; 109 | } 110 | } 111 | } 112 | 113 | impl List for SkiplistList { 114 | fn size(&self) -> usize { 115 | self.n 116 | } 117 | fn get(&self, i: usize) -> Option { 118 | match self.find_pred_node(i) { 119 | Some(ref u) if u.borrow().next[0].is_some() => { 120 | u.borrow().next[0].as_ref().map(|u| u.borrow().x.clone()) 121 | } 122 | _ => None, 123 | } 124 | } 125 | fn set(&mut self, i: usize, x: T) -> Option { 126 | match self.find_pred_node(i) { 127 | Some(ref u) if u.borrow().next[0].is_some() => u.borrow().next[0].as_ref().map(|u| { 128 | let y = u.borrow().x.clone(); 129 | u.borrow_mut().x = x; 130 | y 131 | }), 132 | _ => None, 133 | } 134 | } 135 | fn add(&mut self, i: usize, x: T) { 136 | assert!(i <= self.size()); 137 | let w = Node::new(x, Self::pick_height()); 138 | if w.borrow().next.len() - 1 > self.h { 139 | if let Some(sentinel) = self 140 | .head 141 | .as_ref() 142 | .filter(|sentinel| sentinel.borrow().next.len() < w.borrow().next.len()) 143 | { 144 | let height = sentinel.borrow().next.len(); 145 | sentinel 146 | .borrow_mut() 147 | .next 148 | .extend_from_slice(&vec![None; w.borrow().next.len() - height]); 149 | sentinel.borrow_mut().length.extend_from_slice(&vec![ 150 | 0; 151 | w.borrow().length.len() 152 | - height 153 | ]); 154 | } 155 | self.h = w.borrow().next.len() - 1; 156 | } 157 | self.add_node(i, w); 158 | } 159 | fn remove(&mut self, i: usize) -> Option { 160 | match self.head { 161 | Some(ref sentinel) => { 162 | let mut n = Rc::clone(sentinel); 163 | let mut del = None; 164 | let rh = self.h; 165 | let mut j = 0; 166 | for r in (0..=rh).rev() { 167 | let removed = loop { 168 | let u = Rc::clone(&n); 169 | match u.borrow().next[r] { 170 | Some(ref u) if j + n.borrow().length[r] - 1 < i => { 171 | j += n.borrow().length[r]; 172 | n = Rc::clone(u); 173 | } 174 | Some(ref _u) if j + n.borrow().length[r] - 1 == i => { 175 | break true; 176 | } 177 | _ => break false, 178 | }; 179 | }; 180 | if n.borrow().length[r] > 0 { 181 | n.borrow_mut().length[r] -= 1; 182 | } 183 | if removed { 184 | del = n.borrow_mut().next[r].take(); 185 | if let Some(del) = del.as_ref() { 186 | let length = del.borrow().length[r]; 187 | if let Some(next) = del.borrow_mut().next[r].take() { 188 | n.borrow_mut().next[r] = Some(next); 189 | n.borrow_mut().length[r] += length; 190 | } else if Rc::ptr_eq(&n, self.head.as_ref().unwrap()) { 191 | if let Some(sentinel) = self.head.as_ref() { 192 | sentinel.borrow_mut().next.pop(); 193 | sentinel.borrow_mut().length.pop(); 194 | } 195 | if self.h > 0 { 196 | self.h -= 1; 197 | } 198 | } 199 | } 200 | } 201 | } 202 | del.map(|del| { 203 | self.n -= 1; 204 | Rc::try_unwrap(del).ok().unwrap().into_inner().x 205 | }) 206 | } 207 | None => None, 208 | } 209 | } 210 | } 211 | 212 | #[cfg(test)] 213 | mod test { 214 | use super::SkiplistList; 215 | use chapter01::interface::List; 216 | #[test] 217 | fn test_skiplistlist() { 218 | let mut skiplistlist: SkiplistList = SkiplistList::new(); 219 | skiplistlist.add(0, '0'); 220 | skiplistlist.add(1, '1'); 221 | skiplistlist.add(2, '2'); 222 | skiplistlist.add(3, '3'); 223 | skiplistlist.add(4, '4'); 224 | skiplistlist.add(5, '5'); 225 | skiplistlist.add(6, '6'); 226 | skiplistlist.add(4, 'x'); 227 | skiplistlist.set(4, 'y'); 228 | for (i, elem) in "012345678".chars().enumerate() { 229 | match i { 230 | 0..=3 => assert_eq!(skiplistlist.get(i), Some(elem)), 231 | 4 => { 232 | assert_eq!(skiplistlist.get(i), Some('y')); 233 | assert_eq!(skiplistlist.get(i + 1), Some(elem)); 234 | } 235 | 5..=6 => assert_eq!(skiplistlist.get(i + 1), Some(elem)), 236 | _ => break, 237 | } 238 | } 239 | let mut skiplistlist: SkiplistList = SkiplistList::new(); 240 | skiplistlist.add(0, '0'); 241 | skiplistlist.add(1, '1'); 242 | skiplistlist.add(2, '2'); 243 | skiplistlist.add(3, '3'); 244 | skiplistlist.add(4, '4'); 245 | skiplistlist.add(5, '5'); 246 | skiplistlist.add(6, '6'); 247 | assert_eq!(skiplistlist.remove(3), Some('3')); 248 | assert_eq!(skiplistlist.get(0), Some('0')); 249 | assert_eq!(skiplistlist.get(1), Some('1')); 250 | assert_eq!(skiplistlist.get(2), Some('2')); 251 | assert_eq!(skiplistlist.get(3), Some('4')); 252 | assert_eq!(skiplistlist.get(4), Some('5')); 253 | assert_eq!(skiplistlist.get(5), Some('6')); 254 | 255 | // test large linked list for stack overflow. 256 | let mut skiplistlist: SkiplistList = SkiplistList::new(); 257 | let num = 100000; 258 | for i in 0..num { 259 | skiplistlist.add(skiplistlist.size(), i); 260 | } 261 | println!("fin"); 262 | } 263 | } 264 | -------------------------------------------------------------------------------- /chapter13/src/binarytrie.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use crate::USizeV; 3 | use chapter01::interface::SSet; 4 | use std::cell::RefCell; 5 | use std::rc::{Rc, Weak}; 6 | 7 | #[derive(Clone, Debug, Default)] 8 | pub struct BTNode { 9 | x: RefCell, 10 | child: [RefCell>>>; 2], // 0 = left, 1 = right 11 | jump: RefCell>>>, 12 | parent: RefCell>>>, 13 | prev: RefCell>>>, // left 14 | next: RefCell>>>, // right 15 | } 16 | 17 | impl BTNode { 18 | pub fn new() -> Self { 19 | Default::default() 20 | } 21 | } 22 | 23 | #[derive(Clone, Debug, Default)] 24 | pub struct BinaryTrie { 25 | n: usize, 26 | r: Rc>, 27 | head: Option>>, // dummy1 28 | tail: Option>>, // dummy2 29 | } 30 | 31 | impl Drop for BinaryTrie { 32 | fn drop(&mut self) { 33 | while let Some(ref x) = self.head.as_ref().and_then(|s| { 34 | s.next 35 | .borrow() 36 | .as_ref() 37 | .filter(|n| n.next.borrow().is_some()) 38 | .map(|n| n.x.borrow().clone()) 39 | }) { 40 | self.remove(x); 41 | } 42 | } 43 | } 44 | 45 | impl BinaryTrie { 46 | const W: usize = 64; 47 | pub fn new() -> Self { 48 | let r = Rc::new(BTNode::new()); 49 | let dummy1: Rc> = Default::default(); 50 | let dummy2: Rc> = Default::default(); 51 | *dummy1.next.borrow_mut() = Some(dummy2.clone()); 52 | *dummy2.prev.borrow_mut() = Some(Rc::downgrade(&dummy1)); 53 | *r.jump.borrow_mut() = Some(dummy2.clone()); 54 | Self { 55 | r, 56 | n: 0, 57 | head: Some(dummy1), 58 | tail: Some(Rc::downgrade(&dummy2)), 59 | } 60 | } 61 | } 62 | 63 | impl SSet for BinaryTrie { 64 | fn size(&self) -> usize { 65 | self.n 66 | } 67 | fn add(&mut self, x: T) -> bool { 68 | let mut c = 0; 69 | let ix = x.usize_value(); 70 | let mut u = self.r.clone(); 71 | 72 | // 1 - search for ix until falling out of the trie 73 | let mut i = 0; 74 | let mut next; 75 | for _ in 0..Self::W { 76 | c = (ix >> (Self::W - i - 1)) & 1; 77 | match *u.child[c].borrow() { 78 | Some(ref c) => next = c.clone(), 79 | None => break, 80 | } 81 | u = next; 82 | i += 1; 83 | } 84 | if i == Self::W { 85 | return false; // already contains x - abort 86 | } 87 | let pred = match c { 88 | 0 => { 89 | let j = u.jump.borrow_mut().take(); 90 | match j { 91 | Some(ref j) => j.prev.borrow().as_ref().and_then(|p| p.upgrade()), 92 | None => None, 93 | } 94 | } 95 | _ => u.jump.borrow_mut().take(), // right 96 | }; 97 | // 2 - add path to ix 98 | while i < Self::W { 99 | c = (ix >> (Self::W - i - 1)) & 1; 100 | let n = Rc::new(BTNode::new()); 101 | n.parent.borrow_mut().replace(Rc::downgrade(&u)); 102 | u.child[c].borrow_mut().replace(n); 103 | let uc = u.child[c].borrow().clone().unwrap(); 104 | u = uc; 105 | i += 1; 106 | } 107 | *u.x.borrow_mut() = x; 108 | 109 | // 3 - add u to linked list 110 | *u.prev.borrow_mut() = pred.as_ref().map(|p| Rc::downgrade(&p)); 111 | *u.next.borrow_mut() = pred.as_ref().and_then(|p| p.next.borrow().clone()); 112 | u.prev 113 | .borrow() 114 | .as_ref() 115 | .map(|p| p.upgrade().map(|p| p.next.borrow_mut().replace(u.clone()))); 116 | u.next 117 | .borrow() 118 | .as_ref() 119 | .map(|n| n.prev.borrow_mut().replace(Rc::downgrade(&u))); 120 | 121 | // 4 - walk back up, updating jump pointers 122 | let mut v = u.parent.borrow().as_ref().and_then(|p| p.upgrade()); 123 | while let Some(vi) = v { 124 | if (vi.child[0].borrow().is_none() 125 | && (vi.jump.borrow().is_none() 126 | || vi 127 | .jump 128 | .borrow() 129 | .as_ref() 130 | .filter(|j| (*j.x.borrow()).usize_value() > ix) 131 | .is_some())) 132 | || (vi.child[1].borrow().is_none() 133 | && (vi.jump.borrow().is_none() 134 | || vi 135 | .jump 136 | .borrow() 137 | .as_ref() 138 | .filter(|j| (*j.x.borrow()).usize_value() < ix) 139 | .is_some())) 140 | { 141 | vi.jump.borrow_mut().replace(u.clone()); 142 | } 143 | v = vi.parent.borrow().as_ref().and_then(|p| p.upgrade()); 144 | } 145 | self.n += 1; 146 | true 147 | } 148 | fn remove(&mut self, x: &T) -> Option { 149 | let mut c; 150 | let ix = x.usize_value(); 151 | let mut u = self.r.clone(); 152 | 153 | // 1 - find leaf, u, containing x 154 | let mut i = 0; 155 | let mut next; 156 | for _ in 0..Self::W { 157 | c = (ix >> (Self::W - i - 1)) & 1; 158 | match *u.child[c].borrow() { 159 | Some(ref c) => next = c.clone(), 160 | None => return None, 161 | } 162 | u = next; 163 | i += 1; 164 | } 165 | 166 | // 2 - remove u from linked list 167 | let next = u.next.borrow_mut().take(); 168 | let prev = u.prev.borrow_mut().take(); 169 | if let Some(n) = next.as_ref() { 170 | *n.prev.borrow_mut() = prev.clone(); 171 | } 172 | if let Some(p) = prev.as_ref() { 173 | *p.upgrade().unwrap().next.borrow_mut() = next.clone(); 174 | } 175 | let mut v = u.clone(); 176 | 177 | // 3 - delete nodes on path to u 178 | for i in (0..Self::W).rev() { 179 | c = (ix >> (Self::W - i - 1)) & 1; 180 | let vp = v 181 | .parent 182 | .borrow() 183 | .as_ref() 184 | .and_then(|p| p.upgrade()) 185 | .unwrap(); 186 | v = vp; 187 | v.child[c].borrow_mut().take(); 188 | if v.child[1 - c].borrow().is_some() { 189 | break; 190 | } 191 | } 192 | 193 | // 4 - update jump pointers 194 | c = if v.child[0].borrow().is_none() { 1 } else { 0 }; 195 | *v.jump.borrow_mut() = if c == 0 { 196 | prev.as_ref().and_then(|p| p.upgrade()) 197 | } else { 198 | next.clone() 199 | }; 200 | let mut v = v.parent.borrow().as_ref().and_then(|p| p.upgrade()); 201 | while let Some(vi) = v { 202 | if vi 203 | .jump 204 | .borrow() 205 | .as_ref() 206 | .filter(|j| Rc::ptr_eq(j, &u)) 207 | .is_some() 208 | { 209 | let c = if vi.child[0].borrow().is_none() { 1 } else { 0 }; 210 | *vi.jump.borrow_mut() = if c == 0 { 211 | prev.as_ref().and_then(|p| p.upgrade()) 212 | } else { 213 | next.clone() 214 | }; 215 | } 216 | v = vi.parent.borrow().as_ref().and_then(|p| p.upgrade()); 217 | } 218 | self.n -= 1; 219 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 220 | } 221 | fn find(&self, x: &T) -> Option { 222 | let mut i = 0; 223 | let mut c = 0; 224 | let ix = x.usize_value(); 225 | let mut u = self.r.clone(); 226 | let mut next; 227 | for _ in 0..Self::W { 228 | c = (ix >> (Self::W - i - 1)) & 1; 229 | match *u.child[c].borrow() { 230 | Some(ref c) => next = c.clone(), 231 | None => break, 232 | } 233 | u = next; 234 | i += 1; 235 | } 236 | if i == Self::W { 237 | return Some(u.x.borrow().clone()); 238 | } 239 | let n = if c == 0 { 240 | u.jump.borrow().clone() 241 | } else { 242 | let j = u.jump.borrow().clone(); 243 | match j { 244 | Some(ref j) => j.next.borrow().clone(), 245 | None => None, 246 | } 247 | }; 248 | match n { 249 | Some(ref n) if n.next.borrow().is_none() => None, 250 | Some(ref n) if n.prev.borrow().is_none() => None, 251 | _ => n.as_ref().map(|u| u.x.borrow().clone()), 252 | } 253 | } 254 | } 255 | 256 | #[cfg(test)] 257 | mod test { 258 | use super::*; 259 | use chapter01::interface::SSet; 260 | use chapter09::redblacktree::RedBlackTree; 261 | use rand::{thread_rng, Rng}; 262 | #[test] 263 | fn test_binarytrie() { 264 | let mut rng = thread_rng(); 265 | let n = 200; 266 | let mut redblacktree = RedBlackTree::::new(); 267 | let mut binarytrie = BinaryTrie::new(); 268 | 269 | for _ in 0..5 { 270 | for _ in 0..n { 271 | let x = rng.gen_range(0, 5 * n); 272 | redblacktree.add(x); 273 | binarytrie.add(x); 274 | assert_eq!(redblacktree.size(), binarytrie.size()); 275 | } 276 | for _ in 0..n { 277 | let x = rng.gen_range(0, 5 * n); 278 | let y1 = redblacktree.find(&x); 279 | let y2 = binarytrie.find(&x); 280 | assert_eq!(y1, y2); 281 | } 282 | for _ in 0..n { 283 | let x = rng.gen_range(0, 5 * n); 284 | let b1 = redblacktree.remove(&x); 285 | let b2 = binarytrie.remove(&x); 286 | assert_eq!(b1, b2); 287 | } 288 | assert_eq!(redblacktree.size(), binarytrie.size()); 289 | for _ in 0..n { 290 | let x = rng.gen_range(0, 5 * n); 291 | let y1 = redblacktree.find(&x); 292 | let y2 = binarytrie.find(&x); 293 | assert_eq!(y1, y2); 294 | } 295 | } 296 | 297 | // test large linked list for stack overflow. 298 | let mut bst = BinaryTrie::::new(); 299 | let num = 100000; 300 | for i in 0..num { 301 | bst.add(i); 302 | } 303 | println!("fin"); 304 | } 305 | } 306 | -------------------------------------------------------------------------------- /chapter07/src/treap.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::SSet; 3 | use std::cell::RefCell; 4 | use std::rc::{Rc, Weak}; 5 | 6 | type Tree = Option>>; 7 | 8 | #[derive(Clone, Debug, Default)] 9 | pub struct TreapNode { 10 | p: RefCell, 11 | x: RefCell, 12 | left: RefCell>>>, 13 | right: RefCell>>>, 14 | parent: RefCell>>>, 15 | } 16 | 17 | #[derive(Clone, Debug, Default)] 18 | pub struct Treap { 19 | n: usize, 20 | r: Option>>, 21 | } 22 | 23 | impl Drop for Treap { 24 | fn drop(&mut self) { 25 | while let Some(r) = self.r.clone() { 26 | self.splice(r); 27 | } 28 | } 29 | } 30 | 31 | impl TreapNode { 32 | pub fn new(x: T) -> Self { 33 | Self { 34 | x: RefCell::new(x), 35 | ..Default::default() 36 | } 37 | } 38 | } 39 | 40 | impl Treap 41 | where 42 | T: PartialOrd + Clone, 43 | { 44 | pub fn new() -> Self { 45 | Self { n: 0, r: None } 46 | } 47 | fn rotate_left(&mut self, u: &Rc>) { 48 | let w = u.right.borrow_mut().take().unwrap(); 49 | *w.parent.borrow_mut() = u.parent.borrow_mut().take(); 50 | let p = w.parent.borrow().as_ref().and_then(|p| p.upgrade()); 51 | if let Some(p) = p { 52 | let left = p.left.borrow().clone(); 53 | match left { 54 | Some(ref left) if Rc::ptr_eq(left, u) => { 55 | p.left.borrow_mut().replace(w.clone()); 56 | } 57 | _ => { 58 | p.right.borrow_mut().replace(w.clone()); 59 | } 60 | } 61 | } 62 | *u.right.borrow_mut() = w.left.borrow_mut().take(); 63 | if let Some(ref right) = *u.right.borrow() { 64 | right.parent.borrow_mut().replace(Rc::downgrade(u)); 65 | } 66 | u.parent.borrow_mut().replace(Rc::downgrade(&w)); 67 | w.left.borrow_mut().replace(u.clone()); 68 | if Rc::ptr_eq(u, self.r.as_ref().unwrap()) { 69 | self.r.replace(w); 70 | } 71 | } 72 | fn rotate_right(&mut self, u: &Rc>) { 73 | let w = u.left.borrow_mut().take().unwrap(); 74 | *w.parent.borrow_mut() = u.parent.borrow_mut().take(); 75 | let p = w.parent.borrow().as_ref().and_then(|p| p.upgrade()); 76 | if let Some(p) = p { 77 | let left = p.left.borrow().clone(); 78 | match left { 79 | Some(ref left) if Rc::ptr_eq(left, u) => { 80 | p.left.borrow_mut().replace(w.clone()); 81 | } 82 | _ => { 83 | p.right.borrow_mut().replace(w.clone()); 84 | } 85 | } 86 | } 87 | *u.left.borrow_mut() = w.right.borrow_mut().take(); 88 | if let Some(ref left) = *u.left.borrow() { 89 | left.parent.borrow_mut().replace(Rc::downgrade(u)); 90 | } 91 | u.parent.borrow_mut().replace(Rc::downgrade(&w)); 92 | w.right.borrow_mut().replace(u.clone()); 93 | if Rc::ptr_eq(u, self.r.as_ref().unwrap()) { 94 | self.r.replace(w); 95 | } 96 | } 97 | fn bubbleup(&mut self, u: &Rc>) { 98 | loop { 99 | let parent = u.parent.borrow().as_ref().and_then(|p| p.upgrade()); 100 | match parent { 101 | Some(ref p) if *p.p.borrow() > *u.p.borrow() => { 102 | let right = p.right.borrow().clone(); 103 | match right { 104 | Some(ref r) if Rc::ptr_eq(r, u) => self.rotate_left(p), 105 | _ => self.rotate_right(p), 106 | } 107 | } 108 | _ => break, 109 | } 110 | } 111 | if u.parent.borrow().is_none() { 112 | self.r.replace(u.clone()); 113 | } 114 | } 115 | fn find_last(&self, x: &T) -> Tree { 116 | let mut w = self.r.clone(); 117 | let mut prev = None; 118 | let mut next; 119 | loop { 120 | match w { 121 | Some(ref u) => { 122 | prev = w.clone(); 123 | if x < &*u.x.borrow() { 124 | next = u.left.borrow().clone(); 125 | } else if x > &*u.x.borrow() { 126 | next = u.right.borrow().clone(); 127 | } else { 128 | break Some(u.clone()); 129 | } 130 | } 131 | _ => break prev, 132 | } 133 | w = next; 134 | } 135 | } 136 | fn add_child(&mut self, p: &Tree, u: Rc>) -> bool { 137 | match p { 138 | Some(p) => { 139 | if *p.x.borrow() > *u.x.borrow() { 140 | p.left.borrow_mut().replace(u.clone()); 141 | } else if *p.x.borrow() < *u.x.borrow() { 142 | p.right.borrow_mut().replace(u.clone()); 143 | } else { 144 | return false; 145 | } 146 | u.parent.borrow_mut().replace(Rc::downgrade(p)); 147 | } 148 | None => self.r = Some(u), 149 | } 150 | self.n += 1; 151 | true 152 | } 153 | fn add_u(&mut self, u: Rc>) -> bool { 154 | let p = self.find_last(&*u.x.borrow()); 155 | self.add_child(&p, u) 156 | } 157 | fn splice(&mut self, u: Rc>) -> Option { 158 | let s: Tree; 159 | let mut p: Tree = None; 160 | if u.left.borrow().is_some() { 161 | s = u.left.borrow_mut().take(); 162 | } else { 163 | s = u.right.borrow_mut().take(); 164 | } 165 | if let Some(r) = &self.r { 166 | if Rc::ptr_eq(&u, r) { 167 | self.r = s.clone(); 168 | p = None; 169 | } else { 170 | p = u.parent.borrow_mut().take().and_then(|p| p.upgrade()); 171 | if let Some(p) = p.as_ref() { 172 | let left = p.left.borrow().clone(); 173 | match left { 174 | Some(ref left) if Rc::ptr_eq(left, &u) => { 175 | *p.left.borrow_mut() = s.clone(); 176 | } 177 | _ => { 178 | *p.right.borrow_mut() = s.clone(); 179 | } 180 | } 181 | } 182 | } 183 | } 184 | match (s, p) { 185 | (Some(ref s), Some(ref p)) => { 186 | s.parent.borrow_mut().replace(Rc::downgrade(p)); 187 | } 188 | (Some(ref s), None) => { 189 | s.parent.borrow_mut().take(); 190 | } 191 | _ => (), 192 | } 193 | self.n -= 1; 194 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 195 | } 196 | fn trickle_down(&mut self, u: &Rc>) { 197 | while u.left.borrow().is_some() || u.right.borrow().is_some() { 198 | let left = u.left.borrow().clone(); 199 | let right = u.right.borrow().clone(); 200 | match (left, right) { 201 | (None, _) => self.rotate_left(u), 202 | (_, None) => self.rotate_right(u), 203 | (Some(l), Some(r)) if *l.p.borrow() < *r.p.borrow() => self.rotate_right(u), 204 | _ => self.rotate_left(u), 205 | } 206 | if Rc::ptr_eq(u, self.r.as_ref().unwrap()) { 207 | let p = u.parent.borrow().as_ref().and_then(|p| p.upgrade()); 208 | self.r = p; 209 | } 210 | } 211 | } 212 | } 213 | 214 | impl Treap 215 | where 216 | T: PartialOrd + Clone + Default, 217 | { 218 | pub fn split(&mut self, x: T) -> Treap { 219 | let mut u = self.find_last(&x); 220 | let s = Rc::new(TreapNode::::new(Default::default())); 221 | match u { 222 | Some(ref u) if u.right.borrow().is_none() => { 223 | u.right.borrow_mut().replace(s.clone()); 224 | } 225 | _ => { 226 | let ur = u.as_ref().and_then(|u| u.right.borrow().clone()); 227 | u = ur; 228 | while let Some(v) = u.as_ref().and_then(|u| u.left.borrow().clone()) { 229 | u = Some(v); 230 | } 231 | if let Some(u) = u.as_ref() { 232 | u.left.borrow_mut().replace(s.clone()); 233 | } 234 | } 235 | } 236 | *s.parent.borrow_mut() = u.as_ref().map(|u| Rc::downgrade(&u)); 237 | *s.p.borrow_mut() = usize::MIN; 238 | self.bubbleup(&s); 239 | self.r = s.right.borrow_mut().take(); 240 | if let Some(ref r) = self.r { 241 | *r.parent.borrow_mut() = None; 242 | } 243 | let mut ret = Treap::::new(); 244 | ret.r = s.left.borrow_mut().take(); 245 | if let Some(ref r) = ret.r { 246 | *r.parent.borrow_mut() = None; 247 | } 248 | ret.n = self.n; 249 | ret 250 | } 251 | pub fn absorb(&mut self, mut t: Treap) { 252 | let s = Rc::new(TreapNode::::new(Default::default())); 253 | *s.right.borrow_mut() = self.r.clone(); 254 | if let Some(r) = self.r.take() { 255 | r.parent.borrow_mut().replace(Rc::downgrade(&s)); 256 | } 257 | *s.left.borrow_mut() = t.r.clone(); 258 | if let Some(r2) = t.r.take() { 259 | r2.parent.borrow_mut().replace(Rc::downgrade(&s)); 260 | } 261 | self.r.replace(s.clone()); 262 | self.trickle_down(&s); 263 | self.splice(s); 264 | } 265 | } 266 | 267 | impl SSet for Treap 268 | where 269 | T: PartialOrd + Clone + Default, 270 | { 271 | fn size(&self) -> usize { 272 | self.n 273 | } 274 | fn add(&mut self, x: T) -> bool { 275 | let u = Rc::new(TreapNode::new(x)); 276 | *u.p.borrow_mut() = rand::random(); 277 | if self.add_u(u.clone()) { 278 | self.bubbleup(&u); 279 | true 280 | } else { 281 | false 282 | } 283 | } 284 | fn remove(&mut self, x: &T) -> Option { 285 | match self.find_last(x) { 286 | Some(u) if &*u.x.borrow() == x => { 287 | self.trickle_down(&u); 288 | self.splice(u) 289 | } 290 | _ => None, 291 | } 292 | } 293 | fn find(&self, x: &T) -> Option { 294 | let mut w = self.r.clone(); 295 | let mut z: Tree = None; 296 | let mut next; 297 | loop { 298 | match w { 299 | Some(ref u) if x < &*u.x.borrow() => { 300 | z = w.clone(); 301 | next = u.left.borrow().clone() 302 | } 303 | Some(ref u) if x > &*u.x.borrow() => next = u.right.borrow().clone(), 304 | Some(ref u) if x == &*u.x.borrow() => break Some(u.x.borrow().clone()), 305 | _ => { 306 | break match z { 307 | Some(z) => Some(z.x.borrow().clone()), 308 | None => None, 309 | } 310 | } 311 | } 312 | w = next; 313 | } 314 | } 315 | } 316 | 317 | #[cfg(test)] 318 | mod test { 319 | use super::*; 320 | use chapter01::interface::SSet; 321 | use chapter09::redblacktree::RedBlackTree; 322 | use rand::{thread_rng, Rng}; 323 | #[test] 324 | fn test_treap() { 325 | let mut treap = Treap::::new(); 326 | treap.add(3); 327 | treap.add(1); 328 | treap.add(5); 329 | treap.add(0); 330 | treap.add(2); 331 | treap.add(4); 332 | treap.add(9); 333 | treap.add(7); 334 | treap.add(6); 335 | treap.add(8); 336 | assert_eq!(false, treap.add(8)); 337 | assert_eq!(Some(3), treap.find(&3)); 338 | assert_eq!(None, treap.find(&10)); 339 | assert_eq!(Some(9), treap.remove(&9)); 340 | assert_eq!(Some(8), treap.remove(&8)); 341 | assert_eq!(None, treap.remove(&8)); 342 | //println!("{:?}", treap); 343 | let mut rng = thread_rng(); 344 | let n = 200; 345 | let mut redblacktree = RedBlackTree::::new(); 346 | let mut treap = Treap::::new(); 347 | 348 | for _ in 0..5 { 349 | for _ in 0..n { 350 | let x = rng.gen_range(0, 5 * n); 351 | redblacktree.add(x); 352 | treap.add(x); 353 | assert_eq!(redblacktree.size(), treap.size()); 354 | } 355 | for _ in 0..n { 356 | let x = rng.gen_range(0, 5 * n); 357 | let y1 = redblacktree.find(&x); 358 | let y2 = treap.find(&x); 359 | assert_eq!(y1, y2); 360 | } 361 | for _ in 0..n { 362 | let x = rng.gen_range(0, 5 * n); 363 | let b1 = redblacktree.remove(&x); 364 | let b2 = treap.remove(&x); 365 | assert_eq!(b1, b2); 366 | } 367 | assert_eq!(redblacktree.size(), treap.size()); 368 | for _ in 0..n { 369 | let x = rng.gen_range(0, 5 * n); 370 | let y1 = redblacktree.find(&x); 371 | let y2 = treap.find(&x); 372 | assert_eq!(y1, y2); 373 | } 374 | } 375 | 376 | // test large linked list for stack overflow. 377 | let mut bst = Treap::::new(); 378 | let num = 100000; 379 | for i in 0..num { 380 | bst.add(i); 381 | } 382 | println!("fin"); 383 | } 384 | } 385 | -------------------------------------------------------------------------------- /chapter03/src/selist.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use chapter01::interface::List; 3 | use chapter02::boundeddeque::Array as BDeque; 4 | use std::cell::RefCell; 5 | use std::rc::{Rc, Weak}; 6 | 7 | type Link = Option>>>; 8 | type Wink = Option>>>; 9 | type Loc = (Link, usize); 10 | 11 | #[derive(Clone, Debug, Default)] 12 | pub struct SEList { 13 | head: Link, 14 | tail: Wink, 15 | n: usize, 16 | b: usize, 17 | } 18 | 19 | impl Drop for SEList 20 | where 21 | T: Clone + Default, 22 | { 23 | fn drop(&mut self) { 24 | while self.remove(0).is_some() {} 25 | } 26 | } 27 | 28 | #[derive(Clone, Debug, Default)] 29 | pub struct Node { 30 | block: BDeque, 31 | next: Link, 32 | prev: Wink, 33 | } 34 | 35 | impl Node { 36 | fn new(b: usize) -> Rc> { 37 | Rc::new(RefCell::new(Self { 38 | block: BDeque::new(b + 1), 39 | next: None, 40 | prev: None, 41 | })) 42 | } 43 | } 44 | 45 | impl SEList { 46 | pub fn new(b: usize) -> Self { 47 | let dummy1: Rc>> = Default::default(); 48 | let dummy2: Rc>> = Default::default(); 49 | dummy1.borrow_mut().next = Some(dummy2.clone()); 50 | dummy2.borrow_mut().prev = Some(Rc::downgrade(&dummy1)); 51 | Self { 52 | head: Some(dummy1), 53 | tail: Some(Rc::downgrade(&dummy2)), 54 | n: 0, 55 | b, 56 | } 57 | } 58 | 59 | fn get_loc(&self, mut i: usize) -> Loc { 60 | let mut p: Link; 61 | if i < self.n / 2 { 62 | p = self.head.as_ref().and_then(|d| d.borrow().next.clone()); 63 | while i >= p.as_ref().map(|p| p.borrow().block.size()).unwrap() { 64 | i -= p.as_ref().map(|p| p.borrow().block.size()).unwrap(); 65 | p = p.as_ref().and_then(|p| p.borrow().next.clone()); 66 | } 67 | (p, i) 68 | } else { 69 | let mut idx = self.n; 70 | p = self.tail.as_ref().and_then(|p| p.upgrade()); 71 | while i < idx { 72 | p = p 73 | .as_ref() 74 | .and_then(|p| p.borrow().prev.as_ref().and_then(|p| p.upgrade())); 75 | idx -= p.as_ref().map(|p| p.borrow().block.size()).unwrap(); 76 | } 77 | (p, i - idx) 78 | } 79 | } 80 | 81 | fn add_before(&mut self, w: Link) -> Link { 82 | let u = Node::new(self.b); 83 | u.borrow_mut().prev = w.as_ref().and_then(|p| p.borrow().prev.clone()); 84 | if let Some(p) = w.as_ref() { 85 | p.borrow_mut().prev = Some(Rc::downgrade(&u)) 86 | } 87 | u.borrow_mut().next = w; 88 | u.borrow() 89 | .prev 90 | .as_ref() 91 | .and_then(|p| p.upgrade().map(|p| p.borrow_mut().next = Some(u.clone()))); 92 | Some(u) 93 | } 94 | 95 | fn remove_link(&mut self, w: Link) { 96 | let prev = w.as_ref().and_then(|p| p.borrow_mut().prev.take()); 97 | let next = w.and_then(|p| p.borrow_mut().next.take()); 98 | prev.as_ref() 99 | .and_then(|p| p.upgrade().map(|p| p.borrow_mut().next = next.clone())); 100 | if let Some(p) = next { 101 | p.borrow_mut().prev = prev 102 | } 103 | } 104 | 105 | fn add_last(&mut self, x: T) { 106 | let mut last = self 107 | .tail 108 | .as_ref() 109 | .and_then(|p| p.upgrade()) 110 | .and_then(|p| p.borrow().prev.as_ref().and_then(|p| p.upgrade())); 111 | if let Some(ref p) = last { 112 | if p.borrow().prev.is_none() || p.borrow().block.size() == self.b + 1 { 113 | last = self.add_before(self.tail.as_ref().and_then(|p| p.upgrade())); 114 | } 115 | if let Some(p) = last { 116 | let s = p.borrow().block.size(); 117 | p.borrow_mut().block.add(s, x); 118 | self.n += 1; 119 | } 120 | } 121 | } 122 | 123 | fn spread(&mut self, u: Link) { 124 | let mut w = u.clone(); 125 | for _j in 0..self.b { 126 | w = w.as_ref().and_then(|p| p.borrow().next.clone()); 127 | } 128 | w = self.add_before(w); 129 | while !Rc::ptr_eq(w.as_ref().unwrap(), u.as_ref().unwrap()) { 130 | while w.as_ref().map(|p| p.borrow().block.size()).unwrap() < self.b { 131 | if let Some(p) = w.as_ref() { 132 | let l = p.borrow().prev.as_ref().and_then(|p| p.upgrade()); 133 | let s = l.as_ref().map(|p| p.borrow().block.size()).unwrap(); 134 | let x = l.and_then(|p| p.borrow_mut().block.remove(s - 1)).unwrap(); 135 | p.borrow_mut().block.add(0, x); 136 | } 137 | } 138 | w = w.and_then(|p| p.borrow().prev.as_ref().and_then(|p| p.upgrade())); 139 | } 140 | } 141 | fn gather(&mut self, u: Link) { 142 | let mut w = u; 143 | for _j in 0..self.b - 1 { 144 | while w.as_ref().map(|p| p.borrow().block.size()).unwrap() < self.b { 145 | if let Some(p) = w.as_ref() { 146 | let l = p.borrow().next.clone(); 147 | let s = p.borrow().block.size(); 148 | let x = l.and_then(|p| p.borrow_mut().block.remove(0)).unwrap(); 149 | p.borrow_mut().block.add(s, x); 150 | } 151 | } 152 | w = w.and_then(|p| p.borrow().next.clone()); 153 | } 154 | self.remove_link(w); 155 | } 156 | } 157 | 158 | impl List for SEList { 159 | fn size(&self) -> usize { 160 | self.n 161 | } 162 | fn get(&self, index: usize) -> Option { 163 | if self.n == 0 || index > self.n { 164 | None 165 | } else { 166 | let (p, j) = self.get_loc(index); 167 | p.and_then(|p| p.borrow().block.get(j)) 168 | } 169 | } 170 | fn set(&mut self, i: usize, x: T) -> Option { 171 | if self.n > 0 && i < self.n { 172 | let (p, j) = self.get_loc(i); 173 | p.and_then(|p| p.borrow_mut().block.set(j, x)) 174 | } else { 175 | None 176 | } 177 | } 178 | fn add(&mut self, i: usize, x: T) { 179 | if i == self.n { 180 | self.add_last(x); 181 | return; 182 | } 183 | let (mut u, j) = self.get_loc(i); 184 | let v = u.clone(); 185 | let mut r = 0; 186 | while r < self.b 187 | && u.as_ref() 188 | .filter(|p| p.borrow().next.is_some() && p.borrow().prev.is_some()) 189 | .is_some() 190 | && u.as_ref().map(|p| p.borrow().block.size()).unwrap() == self.b + 1 191 | { 192 | u = u.and_then(|p| p.borrow().next.clone()); 193 | r += 1; 194 | } 195 | if r == self.b { 196 | self.spread(v.clone()); 197 | u = v.clone(); 198 | } 199 | if u.as_ref() 200 | .map(|p| p.borrow().next.is_none()) 201 | .filter(|b| b == &true) 202 | .is_some() 203 | { 204 | u = self.add_before(u); 205 | } 206 | while !Rc::ptr_eq(u.as_ref().unwrap(), v.as_ref().unwrap()) { 207 | if let Some(p) = u.as_ref() { 208 | let l = p.borrow().prev.as_ref().and_then(|p| p.upgrade()); 209 | let s = l.as_ref().map(|p| p.borrow().block.size()).unwrap(); 210 | let x = l.and_then(|p| p.borrow_mut().block.remove(s - 1)).unwrap(); 211 | p.borrow_mut().block.add(0, x); 212 | }; 213 | u = u 214 | .and_then(|p| p.borrow().prev.clone()) 215 | .and_then(|p| p.upgrade()); 216 | } 217 | if let Some(p) = u { 218 | p.borrow_mut().block.add(j, x) 219 | } 220 | self.n += 1; 221 | } 222 | 223 | fn remove(&mut self, i: usize) -> Option { 224 | if self.n > 0 { 225 | let (mut u, j) = self.get_loc(i); 226 | let v = u.clone(); 227 | let mut r = 0; 228 | while r < self.b 229 | && u.as_ref() 230 | .filter(|p| p.borrow().next.is_some() && p.borrow().prev.is_some()) 231 | .is_some() 232 | && u.as_ref().map(|p| p.borrow().block.size()).unwrap() == self.b - 1 233 | { 234 | u = u.and_then(|p| p.borrow().next.clone()); 235 | r += 1; 236 | } 237 | if r == self.b { 238 | self.gather(v.clone()); 239 | } 240 | u = v; 241 | let x = u.as_ref().and_then(|p| p.borrow_mut().block.remove(j)); 242 | while u.as_ref().map(|p| p.borrow().block.size()).unwrap() < self.b - 1 243 | && u.as_ref() 244 | .and_then(|p| p.borrow().next.clone()) 245 | .and_then(|p| p.borrow().next.clone()) 246 | .is_some() 247 | { 248 | if let Some(p) = u.clone() { 249 | let l = p.borrow().next.clone(); 250 | let s = p.borrow().block.size(); 251 | let x = l.and_then(|p| p.borrow_mut().block.remove(0)).unwrap(); 252 | p.borrow_mut().block.add(s, x); 253 | } 254 | u = u.and_then(|p| p.borrow().next.clone()); 255 | } 256 | if u.as_ref().map(|p| p.borrow().block.size()).unwrap() == 0 { 257 | self.remove_link(u); 258 | } 259 | self.n -= 1; 260 | x 261 | } else { 262 | None 263 | } 264 | } 265 | } 266 | 267 | #[cfg(test)] 268 | mod test { 269 | use super::SEList; 270 | use chapter01::interface::List; 271 | #[test] 272 | fn test_selist() { 273 | let mut selist: SEList = SEList::new(3); 274 | selist.add(0, 'a'); 275 | selist.add(1, 'b'); 276 | selist.add(2, 'c'); 277 | selist.add(3, 'd'); 278 | selist.add(4, 'e'); 279 | selist.add(5, 'f'); 280 | selist.add(6, 'g'); 281 | selist.add(7, 'h'); 282 | selist.add(8, 'i'); 283 | selist.add(9, 'j'); 284 | selist.add(1, 'x'); 285 | assert_eq!(selist.size(), 11); 286 | for (i, elem) in "axbcdefghij".chars().enumerate() { 287 | assert_eq!(selist.get(i), Some(elem)); 288 | } 289 | let mut selist: SEList = SEList::new(3); 290 | selist.add(0, 'a'); 291 | selist.add(1, 'b'); 292 | selist.add(2, 'c'); 293 | selist.add(3, 'd'); 294 | selist.add(4, 'e'); 295 | selist.add(5, 'f'); 296 | selist.add(6, 'g'); 297 | selist.add(7, 'h'); 298 | selist.add(1, 'x'); 299 | assert_eq!(selist.size(), 9); 300 | for (i, elem) in "axbcdefgh".chars().enumerate() { 301 | assert_eq!(selist.get(i), Some(elem)); 302 | } 303 | let mut selist: SEList = SEList::new(3); 304 | selist.add(0, 'a'); 305 | selist.add(1, 'b'); 306 | selist.add(2, 'c'); 307 | selist.add(3, 'd'); 308 | selist.add(4, 'e'); 309 | selist.add(5, 'f'); 310 | selist.add(6, 'g'); 311 | selist.add(7, 'h'); 312 | selist.add(8, 'i'); 313 | selist.add(9, 'j'); 314 | selist.add(10, 'k'); 315 | selist.add(11, 'l'); 316 | selist.add(1, 'x'); 317 | assert_eq!(selist.size(), 13); 318 | for (i, elem) in "axbcdefghijkl".chars().enumerate() { 319 | assert_eq!(selist.get(i), Some(elem)); 320 | } 321 | let mut selist: SEList = SEList::new(3); 322 | selist.add(0, 'a'); 323 | selist.add(1, 'b'); 324 | selist.add(2, 'c'); 325 | selist.add(3, 'd'); 326 | selist.add(4, 'e'); 327 | selist.add(5, 'f'); 328 | selist.add(6, 'g'); 329 | selist.add(7, 'h'); 330 | selist.add(8, 'i'); 331 | selist.add(9, 'j'); 332 | selist.add(10, 'k'); 333 | selist.add(11, 'l'); 334 | selist.add(12, 'm'); 335 | selist.add(13, 'n'); 336 | selist.add(14, 'o'); 337 | selist.add(15, 'p'); 338 | assert_eq!(selist.size(), 16); 339 | assert_eq!(selist.remove(7), Some('h')); 340 | assert_eq!(selist.size(), 15); 341 | assert_eq!(selist.remove(6), Some('g')); 342 | assert_eq!(selist.size(), 14); 343 | assert_eq!(selist.remove(5), Some('f')); 344 | assert_eq!(selist.size(), 13); 345 | assert_eq!(selist.remove(1), Some('b')); 346 | assert_eq!(selist.size(), 12); 347 | assert_eq!(selist.remove(2), Some('d')); 348 | assert_eq!(selist.size(), 11); 349 | for (i, elem) in "aceijklmnop".chars().enumerate() { 350 | assert_eq!(selist.get(i), Some(elem)); 351 | } 352 | //-- 353 | assert_eq!(selist.remove(1), Some('c')); 354 | assert_eq!(selist.size(), 10); 355 | selist.remove(1); 356 | assert_eq!(selist.size(), 9); 357 | assert_eq!(selist.remove(4), Some('l')); 358 | assert_eq!(selist.remove(4), Some('m')); 359 | selist.add(4, 'x'); 360 | assert_eq!(selist.remove(4), Some('x')); 361 | println!("\nSEList = {:?}\n", selist); 362 | let mut selist: SEList = SEList::new(3); 363 | let num = 10; 364 | for i in 0..num { 365 | selist.add(selist.size(), i); 366 | } 367 | while selist.remove(0).is_some() {} 368 | 369 | // test large linked list for stack overflow. 370 | let mut selist: SEList = SEList::new(3); 371 | let num = 100000; 372 | for i in 0..num { 373 | selist.add(selist.size(), i); 374 | } 375 | println!("fin"); 376 | } 377 | } 378 | -------------------------------------------------------------------------------- /chapter14/src/btree.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use crate::blockstore::BlockStore; 3 | use chapter01::interface::SSet; 4 | 5 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 6 | struct Node { 7 | id: usize, 8 | keys: Box<[Option]>, 9 | children: Box<[i32]>, 10 | } 11 | 12 | #[allow(non_snake_case)] 13 | #[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] 14 | pub struct BTree { 15 | b: usize, // the maximum number of children of a node (must be odd) 16 | B: usize, // d div 2 17 | n: usize, // number of elements stored in the tree 18 | ri: usize, // index of the root 19 | bs: BlockStore>, 20 | } 21 | 22 | impl Node { 23 | fn new(t: &mut BTree) -> Self { 24 | let b = t.b; 25 | let mut obj = Self { 26 | keys: vec![None; b].into_boxed_slice(), 27 | children: vec![-1i32; b + 1].into_boxed_slice(), 28 | id: 0, 29 | }; 30 | obj.id = t.bs.place_block(obj.clone()); 31 | obj 32 | } 33 | fn is_leaf(&self) -> bool { 34 | self.children[0] < 0 35 | } 36 | fn is_full(&self) -> bool { 37 | self.keys[self.keys.len() - 1].is_some() 38 | } 39 | fn size(&self) -> usize { 40 | let mut lo = 0; 41 | let mut hi = self.keys.len(); 42 | while hi != lo { 43 | let m = (hi + lo) / 2; 44 | if self.keys[m].is_none() { 45 | hi = m; 46 | } else { 47 | lo = m + 1; 48 | } 49 | } 50 | lo 51 | } 52 | fn add(&mut self, x: T, ci: i32) -> bool { 53 | let i = BTree::::find_it(&self.keys, &x); 54 | if i < 0 { 55 | return false; 56 | } 57 | let i = i as usize; 58 | let n = self.keys.len(); 59 | if i >= n - 1 { 60 | self.keys[n - 1] = Some(x); 61 | } else { 62 | self.keys[i..(n - 1)].rotate_right(1); 63 | let end = self.keys[i].replace(x); 64 | self.keys[n - 1] = end; 65 | } 66 | let n = self.children.len(); 67 | if i + 1 >= n - 1 { 68 | self.children[n - 1] = ci; 69 | } else { 70 | self.children[(i + 1)..(n - 1)].rotate_right(1); 71 | self.children[n - 1] = ci; 72 | self.children.swap(i + 1, n - 1); 73 | } 74 | true 75 | } 76 | fn remove(&mut self, i: usize) -> Option { 77 | let n = self.keys.len(); 78 | let y = self.keys.get_mut(i)?.take(); 79 | self.keys[i..n].rotate_left(1); 80 | y 81 | } 82 | fn split(&mut self, t: &mut BTree) -> Option> { 83 | let mut w = Self::new(t); 84 | let j = self.keys.len() / 2; 85 | for (i, key) in self.keys[j..].iter_mut().enumerate() { 86 | w.keys[i] = key.take(); 87 | } 88 | for (i, chd) in self.children[(j + 1)..].iter_mut().enumerate() { 89 | w.children[i] = *chd; 90 | *chd = -1; 91 | } 92 | t.bs.write_block(self.id, self.clone()); 93 | Some(w) 94 | } 95 | } 96 | 97 | impl BTree { 98 | pub fn new(b: usize) -> Self { 99 | let mut tree = Self { 100 | b: b | 1, 101 | B: b / 2, 102 | bs: BlockStore::new(), 103 | ri: 0, 104 | n: 0, 105 | }; 106 | tree.ri = Node::::new(&mut tree).id; 107 | tree 108 | } 109 | fn find_it(a: &[Option], x: &T) -> i32 { 110 | let mut lo = 0; 111 | let mut hi = a.len(); 112 | while hi != lo { 113 | let m = (hi + lo) / 2; 114 | match &a[m] { 115 | None => hi = m, 116 | Some(v) if x < v => hi = m, 117 | Some(v) if x > v => lo = m + 1, 118 | _ => return -(m as i32) - 1, 119 | } 120 | } 121 | lo as i32 122 | } 123 | fn add_recursive(&mut self, mut x: T, ui: usize) -> Result>, ()> { 124 | if let Some(mut u) = self.bs.read_block(ui) { 125 | let i = Self::find_it(&u.keys, &x); 126 | if i < 0 { 127 | return Err(()); 128 | } 129 | if u.children[i as usize] < 0 { 130 | u.add(x, -1); 131 | self.bs.write_block(u.id, u.clone()); 132 | } else { 133 | let w = self.add_recursive(x, u.children[i as usize] as usize)?; 134 | if let Some(mut w) = w { 135 | x = w.remove(0).unwrap(); 136 | u.add(x, w.id as i32); 137 | self.bs.write_block(w.id, w); 138 | self.bs.write_block(u.id, u.clone()); 139 | } 140 | } 141 | if u.is_full() { 142 | Ok(u.split(self)) 143 | } else { 144 | Ok(None) 145 | } 146 | } else { 147 | Err(()) 148 | } 149 | } 150 | fn merge(&mut self, u: &mut Node, i: usize, v: &mut Node, w: &mut Node) { 151 | assert_eq!(v.id, u.children[i] as usize); 152 | assert_eq!(w.id, u.children[i + 1] as usize); 153 | let sv = v.size(); 154 | let sw = w.size(); 155 | 156 | for (i, key) in w.keys[0..sw].iter_mut().enumerate() { 157 | v.keys[sv + 1 + i] = key.take(); 158 | } 159 | for (i, chd) in w.children[0..(sw + 1)].iter_mut().enumerate() { 160 | v.children[sv + 1 + i] = *chd; 161 | *chd = -1; 162 | } 163 | 164 | v.keys[sv] = u.keys[i].take(); 165 | for j in (i + 1)..self.b { 166 | u.keys.swap(j - 1, j); 167 | } 168 | u.keys[self.b - 1].take(); 169 | for j in (i + 2)..(self.b + 1) { 170 | u.children.swap(j - 1, j); 171 | } 172 | u.children[self.b] = -1; 173 | 174 | self.bs.write_block(u.id, u.clone()); 175 | self.bs.write_block(v.id, v.clone()); 176 | self.bs.free_block(w.id); 177 | } 178 | fn shift_lr(&mut self, u: &mut Node, i: usize, v: &mut Node, w: &mut Node) { 179 | let sv = v.size(); 180 | let sw = w.size(); 181 | let shift = (sw + sv) / 2 - sw; // num. keys to shift from v to w 182 | 183 | // make space for new keys 184 | w.keys.rotate_right(shift); 185 | w.children.rotate_right(shift); 186 | 187 | // move keys and children out of v and into w (and u) 188 | w.keys[shift - 1] = u.keys[i].take(); 189 | u.keys[i] = v.keys[sv - shift].take(); 190 | for (i, key) in v.keys[(sv - shift + 1)..sv].iter_mut().enumerate() { 191 | w.keys[i] = key.take(); 192 | } 193 | for (i, chd) in v.children[(sv - shift + 1)..(sv + 1)] 194 | .iter_mut() 195 | .enumerate() 196 | { 197 | w.children[i] = *chd; 198 | *chd = -1; 199 | } 200 | self.bs.write_block(u.id, u.clone()); 201 | self.bs.write_block(v.id, v.clone()); 202 | self.bs.write_block(w.id, w.clone()); 203 | } 204 | fn shift_rl(&mut self, u: &mut Node, i: usize, v: &mut Node, w: &mut Node) { 205 | let sv = v.size(); 206 | let sw = w.size(); 207 | let shift = (sw + sv) / 2 - sw; // num. keys to shift from v to w 208 | 209 | // shift keys and children from v to w 210 | w.keys[sw] = u.keys[i].take(); 211 | for (i, key) in v.keys[0..(shift - 1)].iter_mut().enumerate() { 212 | w.keys[sw + 1 + i] = key.take(); 213 | } 214 | for (i, chd) in v.children[0..shift].iter_mut().enumerate() { 215 | w.children[sw + 1 + i] = *chd; 216 | *chd = -1; 217 | } 218 | u.keys[i] = v.keys[shift - 1].take(); 219 | 220 | // delete keys and children from v 221 | for i in 0..(self.b - shift) { 222 | v.keys.swap(i, shift + i); 223 | } 224 | for key in v.keys[(sv - shift)..self.b].iter_mut() { 225 | key.take(); 226 | } 227 | for i in 0..(self.b - shift + 1) { 228 | v.children.swap(i, shift + i); 229 | } 230 | for chd in v.children[(sv - shift + 1)..(self.b + 1)].iter_mut() { 231 | *chd = -1; 232 | } 233 | self.bs.write_block(u.id, u.clone()); 234 | self.bs.write_block(v.id, v.clone()); 235 | self.bs.write_block(w.id, w.clone()); 236 | } 237 | fn check_underflow_zero(&mut self, u: &mut Node, i: usize) { 238 | if let Some(ref mut w) = self.bs.read_block(u.children[i] as usize) { 239 | if w.size() < self.B - 1 { 240 | if let Some(ref mut v) = self.bs.read_block(u.children[i + 1] as usize) { 241 | if v.size() > self.B { 242 | self.shift_rl(u, i, v, w); 243 | } else { 244 | self.merge(u, i, w, v); 245 | u.children[i] = w.id as i32; 246 | self.bs.write_block(u.id, u.clone()); 247 | } 248 | } 249 | } 250 | } 251 | } 252 | fn check_underflow_nonzero(&mut self, u: &mut Node, i: usize) { 253 | if let Some(ref mut w) = self.bs.read_block(u.children[i] as usize) { 254 | if w.size() < self.B - 1 { 255 | if let Some(ref mut v) = self.bs.read_block(u.children[i - 1] as usize) { 256 | if v.size() > self.B { 257 | self.shift_lr(u, i - 1, v, w); 258 | } else { 259 | self.merge(u, i - 1, v, w); 260 | } 261 | } 262 | } 263 | } 264 | } 265 | fn check_underflow(&mut self, u: &mut Node, i: usize) { 266 | if u.children[i] < 0 { 267 | return; 268 | } 269 | if i == 0 { 270 | self.check_underflow_zero(u, i); 271 | } else { 272 | self.check_underflow_nonzero(u, i); 273 | } 274 | } 275 | fn remove_smallest(&mut self, ui: i32) -> Option { 276 | let mut u = self.bs.read_block(ui as usize); 277 | if let Some(ref mut u) = u { 278 | if u.is_leaf() { 279 | let y = u.remove(0); 280 | self.bs.write_block(u.id, u.clone()); 281 | y 282 | } else { 283 | let y = self.remove_smallest(u.children[0]); 284 | self.check_underflow(u, 0); 285 | y 286 | } 287 | } else { 288 | None 289 | } 290 | } 291 | fn remove_recursive(&mut self, x: &T, ui: i32) -> Option { 292 | if ui < 0 { 293 | return None; 294 | } 295 | let mut u = self.bs.read_block(ui as usize); 296 | match u { 297 | Some(ref mut u) => { 298 | let mut i = Self::find_it(&u.keys, x); 299 | if i < 0 { 300 | i = -(i + 1); 301 | if u.is_leaf() { 302 | let y = u.remove(i as usize); 303 | self.bs.write_block(u.id, u.clone()); 304 | y 305 | } else { 306 | let x = self.remove_smallest(u.children[i as usize + 1]); 307 | let y = u.keys[i as usize].take(); 308 | u.keys[i as usize] = x; 309 | self.bs.write_block(u.id, u.clone()); 310 | self.check_underflow(u, i as usize + 1); 311 | y 312 | } 313 | } else { 314 | let y = self.remove_recursive(x, u.children[i as usize]); 315 | if y.is_some() { 316 | self.check_underflow(u, i as usize); 317 | y 318 | } else { 319 | None 320 | } 321 | } 322 | } 323 | None => None, 324 | } 325 | } 326 | } 327 | 328 | impl SSet for BTree 329 | where 330 | T: Clone + PartialOrd, 331 | { 332 | fn size(&self) -> usize { 333 | self.n 334 | } 335 | fn add(&mut self, x: T) -> bool { 336 | match self.add_recursive(x, self.ri) { 337 | Ok(w) => { 338 | if let Some(mut w) = w { 339 | let mut newroot = Node::new(self); 340 | let x = w.remove(0); 341 | newroot.children[0] = self.ri as i32; 342 | newroot.keys[0] = x; 343 | newroot.children[1] = w.id as i32; 344 | self.bs.write_block(w.id, w); 345 | self.ri = newroot.id; 346 | self.bs.write_block(self.ri, newroot); 347 | } 348 | self.n += 1; 349 | true 350 | } 351 | Err(()) => false, 352 | } 353 | } 354 | fn remove(&mut self, x: &T) -> Option { 355 | match self.remove_recursive(x, self.ri as i32) { 356 | Some(y) => { 357 | self.n -= 1; 358 | let r = self.bs.read_block(self.ri); 359 | if let Some(r) = r { 360 | if r.size() == 0 && self.n > 0 { 361 | self.ri = r.children[0] as usize; 362 | } 363 | } 364 | Some(y) 365 | } 366 | None => None, 367 | } 368 | } 369 | fn find(&self, x: &T) -> Option { 370 | let mut z = None; 371 | let mut ui = self.ri as i32; 372 | while ui >= 0 { 373 | let u = self.bs.read_block(ui as usize)?; 374 | let i = Self::find_it(&u.keys, &x); 375 | if i < 0 { 376 | return u.keys[(-(i + 1)) as usize].clone(); 377 | } 378 | if u.keys[i as usize].is_some() { 379 | z = u.keys[i as usize].clone() 380 | } 381 | ui = u.children[i as usize]; 382 | } 383 | z 384 | } 385 | } 386 | 387 | #[cfg(test)] 388 | mod test { 389 | use super::*; 390 | use chapter01::interface::SSet; 391 | use chapter09::redblacktree::RedBlackTree; 392 | use rand::{thread_rng, Rng}; 393 | #[test] 394 | fn test_btree() { 395 | let mut rng = thread_rng(); 396 | let n = 200; 397 | let mut redblacktree = RedBlackTree::::new(); 398 | let mut btree = BTree::::new(11); 399 | 400 | for _ in 0..5 { 401 | for _ in 0..n { 402 | let x = rng.gen_range(0, 5 * n); 403 | redblacktree.add(x); 404 | btree.add(x); 405 | assert_eq!(redblacktree.size(), btree.size()); 406 | } 407 | for _ in 0..n { 408 | let x = rng.gen_range(0, 5 * n); 409 | let y1 = redblacktree.find(&x); 410 | let y2 = btree.find(&x); 411 | assert_eq!(y1, y2); 412 | } 413 | for _ in 0..n { 414 | let x = rng.gen_range(0, 5 * n); 415 | let b1 = redblacktree.remove(&x); 416 | let b2 = btree.remove(&x); 417 | assert_eq!(b1, b2); 418 | assert_eq!(redblacktree.size(), btree.size()); 419 | } 420 | 421 | for _ in 0..n { 422 | let x = rng.gen_range(0, 5 * n); 423 | let y1 = redblacktree.find(&x); 424 | let y2 = btree.find(&x); 425 | assert_eq!(y1, y2); 426 | } 427 | } 428 | } 429 | } 430 | -------------------------------------------------------------------------------- /chapter13/src/xfasttrie.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop)] 2 | use crate::USizeV; 3 | use chapter01::interface::{SSet, USet}; 4 | use chapter05::linearhashtable::LinearHashTable; 5 | use std::cell::RefCell; 6 | use std::hash::{Hash, Hasher}; 7 | use std::rc::{Rc, Weak}; 8 | 9 | #[derive(Clone, Debug, Default)] 10 | pub struct BTNode { 11 | pub x: RefCell, 12 | prefix: RefCell, 13 | child: [RefCell>>>; 2], // 0 = left, 1 = right 14 | jump: RefCell>>>, 15 | parent: RefCell>>>, 16 | prev: RefCell>>>, // left 17 | pub next: RefCell>>>, // right 18 | } 19 | 20 | impl BTNode { 21 | pub fn new() -> Self { 22 | Default::default() 23 | } 24 | } 25 | 26 | impl PartialEq for BTNode { 27 | fn eq(&self, other: &Self) -> bool { 28 | *self.prefix.borrow() == *other.prefix.borrow() 29 | } 30 | } 31 | 32 | impl Hash for BTNode { 33 | fn hash(&self, state: &mut H) { 34 | self.prefix.borrow().hash(state); 35 | } 36 | } 37 | 38 | #[derive(Clone, Debug, Default)] 39 | pub struct XFastTrie { 40 | n: usize, 41 | r: Rc>, 42 | head: Option>>, // dummy1 43 | tail: Option>>, // dummy2 44 | t: Box<[LinearHashTable>>]>, 45 | } 46 | 47 | impl Drop for XFastTrie { 48 | fn drop(&mut self) { 49 | while let Some(ref x) = self.head.as_ref().and_then(|s| { 50 | s.next 51 | .borrow() 52 | .as_ref() 53 | .filter(|n| n.next.borrow().is_some()) 54 | .map(|n| n.x.borrow().clone()) 55 | }) { 56 | self.remove(x); 57 | } 58 | } 59 | } 60 | 61 | impl XFastTrie { 62 | const W: usize = 64; 63 | pub fn new() -> Self { 64 | let r = Rc::new(BTNode::new()); 65 | let dummy1: Rc> = Default::default(); 66 | let dummy2: Rc> = Default::default(); 67 | *dummy1.next.borrow_mut() = Some(dummy2.clone()); 68 | *dummy2.prev.borrow_mut() = Some(Rc::downgrade(&dummy1)); 69 | *r.jump.borrow_mut() = Some(dummy2.clone()); 70 | Self { 71 | r, 72 | n: 0, 73 | head: Some(dummy1), 74 | tail: Some(Rc::downgrade(&dummy2)), 75 | t: vec![LinearHashTable::new(); Self::W + 1].into_boxed_slice(), 76 | } 77 | } 78 | pub fn find_node(&self, ix: usize) -> Option>> { 79 | let mut l = 0; 80 | let mut h = Self::W + 1; 81 | let mut u = self.r.clone(); 82 | let q = Rc::new(BTNode::new()); 83 | while h - l > 1 { 84 | let i = (l + h) / 2; 85 | *q.prefix.borrow_mut() = ix >> (Self::W - i); 86 | match self.t[i].find(&q) { 87 | None => h = i, 88 | Some(v) => { 89 | u = v; 90 | l = i; 91 | } 92 | } 93 | } 94 | if l == Self::W { 95 | return Some(u); 96 | } 97 | let c = (ix >> (Self::W - l - 1)) & 1; 98 | let pred = if c == 1 { 99 | u.jump.borrow().clone() 100 | } else { 101 | let j = u.jump.borrow().clone(); 102 | match j { 103 | Some(ref j) => j.prev.borrow().as_ref().and_then(|p| p.upgrade()), 104 | None => None, 105 | } 106 | }; 107 | match pred { 108 | Some(pred) => match &*pred.next.borrow() { 109 | Some(n) if n.next.borrow().is_none() => None, 110 | Some(n) if n.prev.borrow().is_none() => None, 111 | _ => pred.next.borrow().clone(), 112 | }, 113 | _ => None, 114 | } 115 | } 116 | pub fn remove_node(&mut self, u: Rc>) -> Option { 117 | let ix = u.x.borrow().usize_value(); 118 | let mut c; 119 | // 2 - remove u from linked list 120 | let next = u.next.borrow_mut().take(); 121 | let prev = u.prev.borrow_mut().take(); 122 | if let Some(n) = next.as_ref() { 123 | *n.prev.borrow_mut() = prev.clone(); 124 | } 125 | if let Some(p) = prev.as_ref() { 126 | *p.upgrade().unwrap().next.borrow_mut() = next.clone(); 127 | } 128 | let mut v = u.clone(); 129 | 130 | // 3 - delete nodes on path to u 131 | for i in (0..Self::W).rev() { 132 | c = (ix >> (Self::W - i - 1)) & 1; 133 | let vp = v 134 | .parent 135 | .borrow() 136 | .as_ref() 137 | .and_then(|p| p.upgrade()) 138 | .unwrap(); 139 | v = vp; 140 | self.t[i + 1].remove(v.child[c].borrow_mut().take().as_ref().unwrap()); 141 | if v.child[1 - c].borrow().is_some() { 142 | break; 143 | } 144 | } 145 | 146 | // 4 - update jump pointers 147 | c = if v.child[0].borrow().is_none() { 1 } else { 0 }; 148 | *v.jump.borrow_mut() = if c == 0 { 149 | prev.as_ref().and_then(|p| p.upgrade()) 150 | } else { 151 | next.clone() 152 | }; 153 | let mut v = v.parent.borrow().as_ref().and_then(|p| p.upgrade()); 154 | while let Some(vi) = v { 155 | if vi 156 | .jump 157 | .borrow() 158 | .as_ref() 159 | .filter(|j| Rc::ptr_eq(j, &u)) 160 | .is_some() 161 | { 162 | let c = if vi.child[0].borrow().is_none() { 1 } else { 0 }; 163 | *vi.jump.borrow_mut() = if c == 0 { 164 | prev.as_ref().and_then(|p| p.upgrade()) 165 | } else { 166 | next.clone() 167 | }; 168 | } 169 | v = vi.parent.borrow().as_ref().and_then(|p| p.upgrade()); 170 | } 171 | self.n -= 1; 172 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 173 | } 174 | } 175 | 176 | impl SSet for XFastTrie { 177 | fn size(&self) -> usize { 178 | self.n 179 | } 180 | 181 | fn add(&mut self, x: T) -> bool { 182 | let mut c = 0; 183 | let ix = x.usize_value(); 184 | let mut u = self.r.clone(); 185 | 186 | // 1 - search for ix until falling out of the trie 187 | let mut i = 0; 188 | let mut next; 189 | for _ in 0..Self::W { 190 | c = (ix >> (Self::W - i - 1)) & 1; 191 | match *u.child[c].borrow() { 192 | Some(ref c) => next = c.clone(), 193 | None => break, 194 | } 195 | u = next; 196 | i += 1; 197 | } 198 | if i == Self::W { 199 | return false; // already contains x - abort 200 | } 201 | let pred = match c { 202 | 0 => { 203 | let j = u.jump.borrow_mut().take(); 204 | match j { 205 | Some(ref j) => j.prev.borrow().as_ref().and_then(|p| p.upgrade()), 206 | None => None, 207 | } 208 | } 209 | _ => u.jump.borrow_mut().take(), // right 210 | }; 211 | 212 | // 2 - add path to ix 213 | while i < XFastTrie::::W { 214 | c = (ix >> (Self::W - i - 1)) & 1; 215 | let n = Rc::new(BTNode::new()); 216 | *n.prefix.borrow_mut() = ix >> (Self::W - i - 1); 217 | self.t[i + 1].add(n.clone()); 218 | n.parent.borrow_mut().replace(Rc::downgrade(&u)); 219 | u.child[c].borrow_mut().replace(n); 220 | let uc = u.child[c].borrow().clone().unwrap(); 221 | u = uc; 222 | i += 1; 223 | } 224 | *u.x.borrow_mut() = x; 225 | 226 | // 3 - add u to linked list 227 | *u.prev.borrow_mut() = pred.as_ref().map(|p| Rc::downgrade(&p)); 228 | *u.next.borrow_mut() = pred.as_ref().and_then(|p| p.next.borrow().clone()); 229 | u.prev 230 | .borrow() 231 | .as_ref() 232 | .map(|p| p.upgrade().map(|p| p.next.borrow_mut().replace(u.clone()))); 233 | u.next 234 | .borrow() 235 | .as_ref() 236 | .map(|n| n.prev.borrow_mut().replace(Rc::downgrade(&u))); 237 | 238 | // 4 - walk back up, updating jump pointers 239 | let mut v = u.parent.borrow().as_ref().and_then(|p| p.upgrade()); 240 | while let Some(vi) = v { 241 | if (vi.child[0].borrow().is_none() 242 | && (vi.jump.borrow().is_none() 243 | || vi 244 | .jump 245 | .borrow() 246 | .as_ref() 247 | .filter(|j| (*j.x.borrow()).usize_value() > ix) 248 | .is_some())) 249 | || (vi.child[1].borrow().is_none() 250 | && (vi.jump.borrow().is_none() 251 | || vi 252 | .jump 253 | .borrow() 254 | .as_ref() 255 | .filter(|j| (*j.x.borrow()).usize_value() < ix) 256 | .is_some())) 257 | { 258 | vi.jump.borrow_mut().replace(u.clone()); 259 | } 260 | v = vi.parent.borrow().as_ref().and_then(|p| p.upgrade()); 261 | } 262 | self.n += 1; 263 | true 264 | } 265 | fn remove(&mut self, x: &T) -> Option { 266 | let mut c; 267 | let ix = x.usize_value(); 268 | let mut u = self.r.clone(); 269 | 270 | // 1 - find leaf, u, containing x 271 | let mut i = 0; 272 | let mut next; 273 | for _ in 0..Self::W { 274 | c = (ix >> (Self::W - i - 1)) & 1; 275 | match *u.child[c].borrow() { 276 | Some(ref c) => next = c.clone(), 277 | None => return None, 278 | } 279 | u = next; 280 | i += 1; 281 | } 282 | 283 | // 2 - remove u from linked list 284 | let next = u.next.borrow_mut().take(); 285 | let prev = u.prev.borrow_mut().take(); 286 | if let Some(n) = next.as_ref() { 287 | *n.prev.borrow_mut() = prev.clone(); 288 | } 289 | if let Some(p) = prev.as_ref() { 290 | *p.upgrade().unwrap().next.borrow_mut() = next.clone(); 291 | } 292 | let mut v = u.clone(); 293 | 294 | // 3 - delete nodes on path to u 295 | for i in (0..Self::W).rev() { 296 | c = (ix >> (Self::W - i - 1)) & 1; 297 | let vp = v 298 | .parent 299 | .borrow() 300 | .as_ref() 301 | .and_then(|p| p.upgrade()) 302 | .unwrap(); 303 | v = vp; 304 | self.t[i + 1].remove(v.child[c].borrow_mut().take().as_ref().unwrap()); 305 | if v.child[1 - c].borrow().is_some() { 306 | break; 307 | } 308 | } 309 | 310 | // 4 - update jump pointers 311 | c = if v.child[0].borrow().is_none() { 1 } else { 0 }; 312 | *v.jump.borrow_mut() = if c == 0 { 313 | prev.as_ref().and_then(|p| p.upgrade()) 314 | } else { 315 | next.clone() 316 | }; 317 | let mut v = v.parent.borrow().as_ref().and_then(|p| p.upgrade()); 318 | while let Some(vi) = v { 319 | if vi 320 | .jump 321 | .borrow() 322 | .as_ref() 323 | .filter(|j| Rc::ptr_eq(j, &u)) 324 | .is_some() 325 | { 326 | let c = if vi.child[0].borrow().is_none() { 1 } else { 0 }; 327 | *vi.jump.borrow_mut() = if c == 0 { 328 | prev.as_ref().and_then(|p| p.upgrade()) 329 | } else { 330 | next.clone() 331 | }; 332 | } 333 | v = vi.parent.borrow().as_ref().and_then(|p| p.upgrade()); 334 | } 335 | self.n -= 1; 336 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 337 | } 338 | 339 | fn find(&self, x: &T) -> Option { 340 | let mut l = 0; 341 | let mut h = Self::W + 1; 342 | let ix = x.usize_value(); 343 | let mut u = self.r.clone(); 344 | let q = Rc::new(BTNode::new()); 345 | while h - l > 1 { 346 | let i = (l + h) / 2; 347 | *q.prefix.borrow_mut() = ix >> (Self::W - i); 348 | match self.t[i].find(&q) { 349 | None => h = i, 350 | Some(v) => { 351 | u = v; 352 | l = i; 353 | } 354 | } 355 | } 356 | if l == Self::W { 357 | return Some(u.x.borrow().clone()); 358 | } 359 | let c = (ix >> (Self::W - l - 1)) & 1; 360 | let pred = if c == 1 { 361 | u.jump.borrow().clone() 362 | } else { 363 | let j = u.jump.borrow().clone(); 364 | match j { 365 | Some(ref j) => j.prev.borrow().as_ref().and_then(|p| p.upgrade()), 366 | None => None, 367 | } 368 | }; 369 | match pred { 370 | Some(pred) => match &*pred.next.borrow() { 371 | Some(n) if n.next.borrow().is_none() => None, 372 | Some(n) if n.prev.borrow().is_none() => None, 373 | _ => pred.next.borrow().as_ref().map(|u| u.x.borrow().clone()), 374 | }, 375 | _ => None, 376 | } 377 | } 378 | } 379 | 380 | #[cfg(test)] 381 | mod test { 382 | use super::*; 383 | use chapter01::interface::SSet; 384 | use chapter09::redblacktree::RedBlackTree; 385 | use rand::{thread_rng, Rng}; 386 | #[test] 387 | fn test_xfasttrie() { 388 | let mut rng = thread_rng(); 389 | let n = 200; 390 | let mut redblacktree = RedBlackTree::::new(); 391 | let mut xfasttrie = XFastTrie::new(); 392 | for _ in 0..5 { 393 | for _ in 0..n { 394 | let x = rng.gen_range(0, 5 * n); 395 | redblacktree.add(x); 396 | xfasttrie.add(x); 397 | assert_eq!(redblacktree.size(), xfasttrie.size()); 398 | } 399 | for _ in 0..n { 400 | let x = rng.gen_range(0, 5 * n); 401 | let y1 = redblacktree.find(&x); 402 | let y2 = xfasttrie.find(&x); 403 | assert_eq!(y1, y2); 404 | } 405 | for _ in 0..n { 406 | let x = rng.gen_range(0, 5 * n); 407 | let b1 = redblacktree.remove(&x); 408 | let b2 = xfasttrie.remove(&x); 409 | assert_eq!(b1, b2); 410 | } 411 | assert_eq!(redblacktree.size(), xfasttrie.size()); 412 | for _ in 0..n { 413 | let x = rng.gen_range(0, 5 * n); 414 | let y1 = redblacktree.find(&x); 415 | let y2 = xfasttrie.find(&x); 416 | assert_eq!(y1, y2); 417 | } 418 | } 419 | // test large linked list for stack overflow. 420 | let mut bst = XFastTrie::::new(); 421 | let num = 100000; 422 | for i in 0..num { 423 | bst.add(i); 424 | } 425 | println!("fin"); 426 | } 427 | } 428 | -------------------------------------------------------------------------------- /chapter08/src/scapegoattree.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::many_single_char_names,clippy::explicit_counter_loop, clippy::redundant_closure)] 2 | use chapter01::interface::SSet; 3 | use std::cell::RefCell; 4 | use std::rc::{Rc, Weak}; 5 | 6 | type Tree = Option>>; 7 | #[derive(Clone, Debug, Default)] 8 | pub struct BSTNode { 9 | x: RefCell, 10 | left: RefCell>>>, 11 | right: RefCell>>>, 12 | parent: RefCell>>>, 13 | } 14 | 15 | #[derive(Clone, Debug, Default)] 16 | pub struct ScapegoatTree { 17 | n: usize, 18 | q: usize, 19 | r: Option>>, 20 | } 21 | 22 | impl Drop for ScapegoatTree { 23 | fn drop(&mut self) { 24 | while let Some(r) = self.r.clone() { 25 | self.splice(r); 26 | } 27 | } 28 | } 29 | 30 | impl BSTNode { 31 | pub fn new(x: T) -> Self { 32 | Self { 33 | x: RefCell::new(x), 34 | ..Default::default() 35 | } 36 | } 37 | } 38 | 39 | impl ScapegoatTree 40 | where 41 | T: PartialOrd + Clone, 42 | { 43 | pub fn new() -> Self { 44 | Self { 45 | n: 0, 46 | q: 0, 47 | r: None, 48 | } 49 | } 50 | fn size_u(u: &Tree) -> usize { 51 | match u { 52 | Some(n) => 1 + Self::size_u(&n.left.borrow()) + Self::size_u(&n.right.borrow()), 53 | None => 0, 54 | } 55 | } 56 | fn find_last(&self, x: &T) -> Tree { 57 | let mut w = self.r.clone(); 58 | let mut prev = None; 59 | let mut next; 60 | loop { 61 | match w { 62 | Some(ref u) => { 63 | prev = w.clone(); 64 | if x < &*u.x.borrow() { 65 | next = u.left.borrow().clone(); 66 | } else if x > &*u.x.borrow() { 67 | next = u.right.borrow().clone(); 68 | } else { 69 | break Some(u.clone()); 70 | } 71 | } 72 | _ => break prev, 73 | } 74 | w = next; 75 | } 76 | } 77 | fn build_balanced(a: &[Tree], i: usize, ns: usize) -> Tree { 78 | if ns == 0 { 79 | return None; 80 | } 81 | let m = ns / 2; 82 | let elem = a[i + m].clone(); 83 | if let Some(ref u) = elem { 84 | *u.left.borrow_mut() = Self::build_balanced(a, i, m); 85 | if let Some(left) = &*u.left.borrow() { 86 | left.parent.borrow_mut().replace(Rc::downgrade(u)); 87 | } 88 | *u.right.borrow_mut() = Self::build_balanced(a, i + m + 1, ns - m - 1); 89 | if let Some(right) = &*u.right.borrow() { 90 | right.parent.borrow_mut().replace(Rc::downgrade(u)); 91 | } 92 | } 93 | elem 94 | } 95 | fn rebuild(&mut self, u: &Tree) { 96 | let ns = Self::size_u(u); 97 | let p = match u { 98 | Some(u) => u.parent.borrow().as_ref().and_then(|p| p.upgrade()), 99 | None => None, 100 | }; 101 | let mut a: Vec> = vec![None; ns]; 102 | Self::pack_into_array(u, &mut a, 0); 103 | match p { 104 | None => { 105 | self.r = Self::build_balanced(&a, 0, ns); 106 | if let Some(r) = self.r.as_ref() { 107 | r.parent.borrow_mut().take(); 108 | } 109 | } 110 | Some(p) => { 111 | let right = p.right.borrow().clone(); 112 | match right { 113 | Some(ref right) if Rc::ptr_eq(right, u.as_ref().unwrap()) => { 114 | *p.right.borrow_mut() = Self::build_balanced(&a, 0, ns); 115 | if let Some(right) = &*p.right.borrow() { 116 | right.parent.borrow_mut().replace(Rc::downgrade(&p)); 117 | } 118 | } 119 | _ => { 120 | *p.left.borrow_mut() = Self::build_balanced(&a, 0, ns); 121 | if let Some(left) = &*p.left.borrow() { 122 | left.parent.borrow_mut().replace(Rc::downgrade(&p)); 123 | } 124 | } 125 | } 126 | } 127 | } 128 | } 129 | fn pack_into_array(u: &Tree, a: &mut [Tree], mut i: usize) -> usize { 130 | match u { 131 | None => i, 132 | Some(u) => { 133 | i = Self::pack_into_array(&u.left.borrow(), a, i); 134 | if let Some(elem) = a.get_mut(i) { 135 | elem.replace(u.clone()); 136 | } 137 | i += 1; 138 | Self::pack_into_array(&u.right.borrow(), a, i) 139 | } 140 | } 141 | } 142 | fn add_with_depth(&mut self, u: Rc>) -> i64 { 143 | let mut w = self.r.clone(); 144 | if w.is_none() { 145 | self.r = Some(u.clone()); 146 | } 147 | let mut d = 0; 148 | let mut next; 149 | loop { 150 | match w { 151 | Some(ref w) => { 152 | if *u.x.borrow() < *w.x.borrow() { 153 | let left = w.left.borrow().clone(); 154 | match left { 155 | None => { 156 | *w.left.borrow_mut() = Some(u.clone()); 157 | *u.parent.borrow_mut() = Some(Rc::downgrade(w)); 158 | next = None; 159 | } 160 | Some(left) => next = Some(left.clone()), 161 | } 162 | } else if *u.x.borrow() > *w.x.borrow() { 163 | let right = w.right.borrow().clone(); 164 | match right { 165 | None => { 166 | *w.right.borrow_mut() = Some(u.clone()); 167 | *u.parent.borrow_mut() = Some(Rc::downgrade(w)); 168 | next = None; 169 | } 170 | Some(right) => next = Some(right.clone()), 171 | } 172 | } else { 173 | return -1; 174 | } 175 | d += 1; 176 | } 177 | None => { 178 | self.n += 1; 179 | self.q += 1; 180 | break d; 181 | } 182 | } 183 | w = next; 184 | } 185 | } 186 | fn splice(&mut self, u: Rc>) -> Option { 187 | let s: Tree; 188 | let mut p: Tree = None; 189 | if u.left.borrow().is_some() { 190 | s = u.left.borrow_mut().take(); 191 | } else { 192 | s = u.right.borrow_mut().take(); 193 | } 194 | if let Some(r) = &self.r { 195 | if Rc::ptr_eq(&u, r) { 196 | self.r = s.clone(); 197 | p = None; 198 | } else { 199 | p = u.parent.borrow_mut().take().and_then(|p| p.upgrade()); 200 | if let Some(p) = p.as_ref() { 201 | let left = p.left.borrow().clone(); 202 | match left { 203 | Some(ref left) if Rc::ptr_eq(left, &u) => { 204 | *p.left.borrow_mut() = s.clone(); 205 | } 206 | _ => { 207 | *p.right.borrow_mut() = s.clone(); 208 | } 209 | } 210 | } 211 | } 212 | } 213 | match (s, p) { 214 | (Some(ref s), Some(ref p)) => { 215 | s.parent.borrow_mut().replace(Rc::downgrade(p)); 216 | } 217 | (Some(ref s), None) => { 218 | s.parent.borrow_mut().take(); 219 | } 220 | _ => (), 221 | } 222 | self.n -= 1; 223 | Some(Rc::try_unwrap(u).ok().unwrap().x.into_inner()) 224 | } 225 | fn remove_u(&mut self, u: Rc>) -> Option { 226 | if u.left.borrow().is_none() || u.right.borrow().is_none() { 227 | self.splice(u) 228 | } else { 229 | let mut w = u.right.borrow().clone(); 230 | loop { 231 | let mut next = None; 232 | if let Some(ref w) = w { 233 | match *w.left.borrow() { 234 | Some(ref left) => next = Some(left.clone()), 235 | None => break, 236 | } 237 | } 238 | w = next; 239 | } 240 | u.x.swap(&w.as_ref().unwrap().x); 241 | self.splice(w.unwrap()) 242 | } 243 | } 244 | fn bst_remove(&mut self, x: &T) -> Option { 245 | match self.find_last(x) { 246 | Some(u) if &*u.x.borrow() == x => self.remove_u(u), 247 | _ => None, 248 | } 249 | } 250 | } 251 | 252 | impl SSet for ScapegoatTree 253 | where 254 | T: PartialOrd + Clone + Default, 255 | { 256 | fn size(&self) -> usize { 257 | self.n 258 | } 259 | fn add(&mut self, x: T) -> bool { 260 | let u = Rc::new(BSTNode::new(x)); 261 | let d = self.add_with_depth(u.clone()); 262 | if d > crate::log32(self.q) { 263 | let mut w = u.parent.borrow().as_ref().and_then(|p| p.upgrade()); 264 | let mut wp = w 265 | .as_ref() 266 | .and_then(|w| w.parent.borrow().as_ref().and_then(|wp| wp.upgrade())); 267 | let mut a = Self::size_u(&w); 268 | let mut b = Self::size_u(&wp); 269 | while 3 * a <= 2 * b { 270 | w = wp; 271 | wp = w 272 | .as_ref() 273 | .and_then(|w| w.parent.borrow().as_ref().and_then(|wp| wp.upgrade())); 274 | a = Self::size_u(&w); 275 | b = Self::size_u(&wp); 276 | } 277 | self.rebuild(&wp); 278 | true 279 | } else { 280 | d >= 0 281 | } 282 | } 283 | fn remove(&mut self, x: &T) -> Option { 284 | match self.bst_remove(x) { 285 | Some(x) => { 286 | if 2 * self.n < self.q { 287 | if self.r.is_some() { 288 | self.rebuild(&self.r.clone()); 289 | } 290 | self.q = self.n; 291 | } 292 | Some(x) 293 | } 294 | None => None, 295 | } 296 | } 297 | fn find(&self, x: &T) -> Option { 298 | let mut w = self.r.clone(); 299 | let mut z: Tree = None; 300 | let mut next; 301 | loop { 302 | match w { 303 | Some(ref u) if x < &*u.x.borrow() => { 304 | z = w.clone(); 305 | next = u.left.borrow().clone() 306 | } 307 | Some(ref u) if x > &*u.x.borrow() => next = u.right.borrow().clone(), 308 | Some(ref u) if x == &*u.x.borrow() => break Some(u.x.borrow().clone()), 309 | _ => { 310 | break match z { 311 | Some(z) => Some(z.x.borrow().clone()), 312 | None => None, 313 | } 314 | } 315 | } 316 | w = next; 317 | } 318 | } 319 | } 320 | 321 | #[cfg(test)] 322 | mod test { 323 | use super::*; 324 | use chapter01::interface::SSet; 325 | use chapter09::redblacktree::RedBlackTree; 326 | use rand::{thread_rng, Rng}; 327 | #[test] 328 | fn test_scapegoattree() { 329 | let mut scapegoattree = ScapegoatTree::::new(); 330 | scapegoattree.add(9); 331 | scapegoattree.add(8); 332 | scapegoattree.add(10); 333 | scapegoattree.add(7); 334 | scapegoattree.add(11); 335 | scapegoattree.add(3); 336 | scapegoattree.add(1); 337 | scapegoattree.add(6); 338 | scapegoattree.add(0); 339 | scapegoattree.add(4); 340 | scapegoattree.add(5); 341 | let u = scapegoattree.find_last(&4).unwrap(); 342 | let p = u 343 | .parent 344 | .borrow() 345 | .as_ref() 346 | .and_then(|p| p.upgrade()) 347 | .unwrap(); 348 | assert_eq!(8, *p.x.borrow()); 349 | assert_eq!(1, *u.left.borrow().as_ref().unwrap().x.borrow()); 350 | assert_eq!(6, *u.right.borrow().as_ref().unwrap().x.borrow()); 351 | let u = scapegoattree.find_last(&1).unwrap(); 352 | let p = u 353 | .parent 354 | .borrow() 355 | .as_ref() 356 | .and_then(|p| p.upgrade()) 357 | .unwrap(); 358 | assert_eq!(4, *p.x.borrow()); 359 | assert_eq!(0, *u.left.borrow().as_ref().unwrap().x.borrow()); 360 | assert_eq!(3, *u.right.borrow().as_ref().unwrap().x.borrow()); 361 | let u = scapegoattree.find_last(&6).unwrap(); 362 | let p = u 363 | .parent 364 | .borrow() 365 | .as_ref() 366 | .and_then(|p| p.upgrade()) 367 | .unwrap(); 368 | assert_eq!(4, *p.x.borrow()); 369 | assert_eq!(5, *u.left.borrow().as_ref().unwrap().x.borrow()); 370 | assert_eq!(7, *u.right.borrow().as_ref().unwrap().x.borrow()); 371 | let mut scapegoattree = ScapegoatTree::::new(); 372 | scapegoattree.add(9); 373 | scapegoattree.add(8); 374 | scapegoattree.add(10); 375 | scapegoattree.add(7); 376 | scapegoattree.add(11); 377 | scapegoattree.add(3); 378 | scapegoattree.add(1); 379 | scapegoattree.add(6); 380 | scapegoattree.add(0); 381 | scapegoattree.add(4); 382 | scapegoattree.add(5); 383 | assert_eq!(Some(5), scapegoattree.remove(&5)); 384 | assert_eq!(None, scapegoattree.remove(&5)); 385 | assert_eq!(Some(8), scapegoattree.remove(&8)); 386 | assert_eq!(None, scapegoattree.remove(&8)); 387 | assert_eq!(Some(9), scapegoattree.remove(&9)); 388 | assert_eq!(Some(10), scapegoattree.remove(&10)); 389 | assert_eq!(Some(4), scapegoattree.remove(&4)); 390 | assert_eq!(Some(1), scapegoattree.remove(&1)); 391 | println!("{:?}", scapegoattree); 392 | 393 | let mut rng = thread_rng(); 394 | let n = 200; 395 | let mut redblacktree = RedBlackTree::::new(); 396 | let mut scapegoattree = ScapegoatTree::::new(); 397 | 398 | for _ in 0..5 { 399 | for _ in 0..n { 400 | let x = rng.gen_range(0, 5 * n); 401 | redblacktree.add(x); 402 | scapegoattree.add(x); 403 | assert_eq!(redblacktree.size(), scapegoattree.size()); 404 | } 405 | for _ in 0..n { 406 | let x = rng.gen_range(0, 5 * n); 407 | let y1 = redblacktree.find(&x); 408 | let y2 = scapegoattree.find(&x); 409 | assert_eq!(y1, y2); 410 | } 411 | for _ in 0..n { 412 | let x = rng.gen_range(0, 5 * n); 413 | let b1 = redblacktree.remove(&x); 414 | let b2 = scapegoattree.remove(&x); 415 | assert_eq!(b1, b2); 416 | } 417 | assert_eq!(redblacktree.size(), scapegoattree.size()); 418 | for _ in 0..n { 419 | let x = rng.gen_range(0, 5 * n); 420 | let y1 = redblacktree.find(&x); 421 | let y2 = scapegoattree.find(&x); 422 | assert_eq!(y1, y2); 423 | } 424 | } 425 | 426 | // test large linked list for stack overflow. 427 | let mut bst = ScapegoatTree::::new(); 428 | let num = 100000; 429 | for i in 0..num { 430 | bst.add(i); 431 | } 432 | println!("fin"); 433 | } 434 | } 435 | --------------------------------------------------------------------------------