WHOLE: refactor into chapters

Author: andelf

Cargo.toml

@@ -18,8 +18,12 @@ adivon = "*"
 byteorder = "*"
 mtl = "*"
 
+
+# [dev-dependencies.piston_window]
+# piston_window = "*"
+
 [dev-dependencies.sdl2]
-sdl2 = "0.6.2"
+sdl2 = "0.9"
 
 [dev-dependencies.sdl2_gfx]
 sdl2_gfx = "0.6.2"

benches/geometric_search.rs

@@ -8,8 +8,8 @@ extern crate algs4;
 use test::Bencher;
 use rand::{thread_rng, Rng};
 
-use algs4::geometric_search::primitive::{Point2D, PointSet, RectHV};
-use algs4::symbol_tables::ST;
+use algs4::searching::ST;
+use algs4::fundamentals::primitive::{Point2D, PointSet, RectHV};
 use algs4::geometric_search::kd_tree::KdTree;
 
 const SIZE: usize = 1000;

benches/sorting.rs

@@ -7,11 +7,9 @@ extern crate algs4;
 
 use test::Bencher;
 use rand::{thread_rng, Rng};
-use algs4::elementary_sorts::*;
-use algs4::mergesort::*;
-use algs4::quicksort::*;
-use algs4::priority_queues::heapsort::heap_sort;
-
+use algs4::sorting::*;
+use algs4::sorting::quicksort::{quick_sort_3way, quick_sort_orig};
+use algs4::fundamentals::knuth_shuffle;
 
 static SIZE: usize = 1000;
 // for small array

benches/union_find.rs

@@ -7,11 +7,7 @@ extern crate algs4;
 
 use test::{black_box, Bencher};
 
-use algs4::union_find::UF;
-use algs4::union_find::quick_find;
-use algs4::union_find::quick_union;
-use algs4::union_find::weighted_quick_union;
-use algs4::union_find::improved;
+use algs4::fundamentals::union_find::*;
 
 const NUM_OF_OBJECTS: usize = 100;
 const NUM_OF_OPERATIONS: usize = 500;

examples/8puzzle.rs

@@ -6,8 +6,8 @@ use std::io;
 use std::fmt;
 use std::cmp::Ordering;
 
-use algs4::priority_queues::MinPQ;
-use algs4::priority_queues::binary_heaps::BinaryHeapMinPQ;
+use algs4::sorting::priority_queues::MinPQ;
+use algs4::sorting::priority_queues::binary_heaps::BinaryHeapMinPQ;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Board {

examples/bouncing_balls.rs

@@ -9,7 +9,7 @@ use sdl2::event::Event;
 use sdl2_gfx::primitives::DrawRenderer;
 
 use rand::{thread_rng, Rng};
-use algs4::priority_queues::event_driven_simulation::{Particle, CollisionSystem};
+use algs4::sorting::priority_queues::event_driven_simulation::{Particle, CollisionSystem};
 
 
 const BALLS: usize = 100;

examples/collinear.rs

@@ -6,9 +6,9 @@ use std::io;
 use std::fmt;
 use std::cmp::Ordering;
 
-use algs4::quicksort::quick_sort;
-use algs4::mergesort::comparator::Comparator;
-use algs4::mergesort::comparator::insertion_sort;
+use algs4::sorting::quick_sort;
+use algs4::sorting::comparator::Comparator;
+use algs4::sorting::comparator::insertion_sort;
 
 #[derive(Copy, Clone)]
 pub struct Point {

examples/kdtree.rs

@@ -5,8 +5,8 @@ extern crate rand;
 use std::io::prelude::*;
 use std::io;
 
-use algs4::geometric_search::primitive::{Point2D, PointSet, RectHV};
-use algs4::symbol_tables::ST;
+use algs4::fundamentals::primitive::{Point2D, PointSet, RectHV};
+use algs4::searching::ST;
 // FIXME: fails under input1M.txt
 use algs4::geometric_search::kd_tree::KdTree;
 

examples/orthogonal_line_segment_intersection.rs

@@ -5,9 +5,9 @@ use std::cmp::Ordering;
 use rand::{Rng, Rand};
 // use rand::thread_rng;
 
-use algs4::quicksort::quick_sort;
-use algs4::symbol_tables::ST;
-use algs4::symbol_tables::binary_search_tree::BST;
+use algs4::sorting::quick_sort;
+use algs4::searching::ST;
+use algs4::searching::binary_search_tree::BST;
 use algs4::geometric_search::RangeSearch1D;
 
 use self::Event::*;

examples/percolation.rs

@@ -9,8 +9,8 @@ use std::iter;
 use test::stats::Stats;
 use rand::{thread_rng, Rng};
 
-use algs4::union_find::UF;
-use algs4::union_find::weighted_quick_union::UnionFind;
+use algs4::fundamentals::union_find::UF;
+use algs4::fundamentals::union_find::weighted_quick_union::UnionFind;
 
 /// a percolation system using an N-by-N grid of sites
 pub struct Percolation {

examples/subset.rs

@@ -4,8 +4,8 @@ use std::env;
 use std::io::prelude::*;
 use std::io;
 
-use algs4::stacks_and_queues::RandomizedQueue;
-use algs4::stacks_and_queues::resizing_array_randomized_queue::ResizingArrayRandomizedQueue;
+use algs4::fundamentals::stacks_and_queues::RandomizedQueue;
+use algs4::fundamentals::stacks_and_queues::resizing_array_randomized_queue::ResizingArrayRandomizedQueue;
 
 
 fn main() {

examples/union_find.rs

@@ -4,11 +4,11 @@ extern crate algs4;
 use std::io::prelude::*;
 use std::io;
 
-use algs4::union_find::UF;
-use algs4::union_find::quick_find;
-use algs4::union_find::quick_union;
-use algs4::union_find::weighted_quick_union;
-use algs4::union_find::improved;
+use algs4::fundamentals::union_find::UF;
+use algs4::fundamentals::union_find::quick_find;
+use algs4::fundamentals::union_find::quick_union;
+use algs4::fundamentals::union_find::weighted_quick_union;
+use algs4::fundamentals::union_find::improved;
 
 fn main() {
     let mut lines = io::BufReader::new(io::stdin()).lines();

src/linear_programming/mod.rs renamed to src/context/linear_programming.rs

@@ -0,0 +1,3 @@
+pub mod linear_programming;
+pub mod maximum_flow;
+pub mod suffix_arrays;

src/maximum_flow/mod.rs renamed to src/context/maximum_flow/mod.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 use std::mem;
-use super::mergesort::comparator::Comparator;
+use super::sorting::comparator::Comparator;
 
 #[allow(non_snake_case)]
 pub struct Point2D {

src/context/mod.rs

@@ -0,0 +1,25 @@
+use rand::{thread_rng, Rng};
+
+/// Rearranges an array of objects in uniformly random order
+pub fn knuth_shuffle<T>(a: &mut [T]) {
+    let mut rng = thread_rng();
+    let n = a.len();
+
+    for i in 0 .. n {
+        let r = rng.gen_range(0, i+1);
+        a.swap(i, r);
+    }
+}
+
+#[test]
+fn test_knuth_shuffle() {
+    let array = thread_rng().gen_iter().take(10).collect::<Vec<f64>>();
+    let mut new_array = array.clone();
+    knuth_shuffle(&mut new_array);
+    assert!(array != new_array);
+}
+
+
+pub mod primitive;
+pub mod stacks_and_queues;
+pub mod union_find;

src/radix_sorts/suffix_arrays.rs renamed to src/context/suffix_arrays.rs

@@ -3,8 +3,8 @@ use std::vec::IntoIter;
 use std::f64;
 use rand::{Rand, Rng};
 use std::borrow::Borrow;
-use super::super::symbol_tables::ST;
-use super::super::balanced_search_trees::RedBlackBST;
+use super::super::searching::ST;
+use super::super::searching::red_black_tree::RedBlackBST;
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, Debug)]
 pub struct Point2D {

src/convex_hull.rs

@@ -137,7 +137,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
 
     fn next(&mut self) -> Option<&'a T> {
         unsafe {
-            if self.ptr < self.end {
+            if self.ptr <= self.end {
                 None
             } else {
                 self.ptr = self.ptr.offset(-1);

src/fundamentals/mod.rs

@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::iter;
 // use std::vec::IntoIter;
-use super::super::symbol_tables::ST;
+use super::super::searching::ST;
 
 
 pub struct Node<K: PartialOrd + Copy, V> {

src/geometric_search/primitive.rs renamed to src/fundamentals/primitive.rs

@@ -5,10 +5,10 @@ use std::vec::IntoIter;
 use std::cmp::Ordering;
 use std::borrow::Borrow;
 
-use super::super::symbol_tables::ST;
-use super::super::stacks_and_queues::Queue;
-use super::super::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
-use super::primitive::{Point2D, RectHV};
+use super::super::searching::ST;
+use super::super::fundamentals::stacks_and_queues::Queue;
+use super::super::fundamentals::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
+use super::super::fundamentals::primitive::{Point2D, RectHV};
 
 
 pub trait Point: Copy {

src/stacks_and_queues/bag.rs renamed to src/fundamentals/stacks_and_queues/bag.rs

@@ -1,7 +1,7 @@
-use super::symbol_tables::{ST, OrderedST};
-use super::symbol_tables::binary_search_tree::{BST, Node};
+use super::searching::{ST, OrderedST};
+use super::searching::binary_search_tree::{BST, Node};
 
-pub mod primitive;
+// pub mod primitive;
 
 pub mod kd_tree;
 

src/stacks_and_queues/fixed_capacity_stack.rs renamed to src/fundamentals/stacks_and_queues/fixed_capacity_stack.rs

@@ -1,8 +1,8 @@
 use std::iter;
-use super::stacks_and_queues::bag::Bag;
-use super::stacks_and_queues::{Stack, Queue};
-use super::stacks_and_queues::linked_stack;
-use super::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
+use super::super::fundamentals::stacks_and_queues::bag::Bag;
+use super::super::fundamentals::stacks_and_queues::{Stack, Queue};
+use super::super::fundamentals::stacks_and_queues::linked_stack;
+use super::super::fundamentals::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
 
 #[derive(Clone, Debug)]
 pub struct Digraph {

src/stacks_and_queues/linked_deque.rs renamed to src/fundamentals/stacks_and_queues/linked_deque.rs

@@ -4,13 +4,8 @@ use std::cmp;
 use std::f64;
 
 use adivon::priority_queue::IndexMinPQ;
-use super::stacks_and_queues::bag::Bag;
-use super::stacks_and_queues::Queue;
-use super::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
-use super::priority_queues::MinPQ;
-use super::priority_queues::binary_heaps::BinaryHeapMinPQ;
-use super::union_find::UF;
-use super::union_find::weighted_quick_union::UnionFind;
+use adivon::{Bag, Queue, MinPQ};
+use adivon::UnionFind;
 
 /// a weighted edge
 #[derive(Clone, Copy)]
@@ -182,21 +177,21 @@ fn test_edge_weighted_graph() {
 pub struct KruskalMST<'a> {
     graph: &'a EdgeWeightedGraph,
     weight: f64,
-    mst: ResizingArrayQueue<Edge>
+    mst: Queue<Edge>
 }
 
 impl<'a> KruskalMST<'a> {
     fn new<'b>(graph: &'b EdgeWeightedGraph) -> KruskalMST<'b> {
         let n = graph.v();
         let mut weight = 0f64;
-        let mut mst = ResizingArrayQueue::<Edge>::new();
-        let mut pq = BinaryHeapMinPQ::<Edge>::new();
+        let mut mst = Queue::<Edge>::new();
+        let mut pq = MinPQ::<Edge>::new();
         for e in graph.edges() {
             pq.insert(e);
         }
         let mut uf = UnionFind::new(n);
 
-        while !pq.is_empty() && mst.size() < n - 1 {
+        while !pq.is_empty() && mst.len() < n - 1 {
             let e = pq.del_min().unwrap();
             let v = e.either();
             let w = e.other(v);
@@ -229,17 +224,17 @@ impl EdgeWeightedGraph {
 pub struct LazyPrimMST<'a> {
     graph: &'a EdgeWeightedGraph,
     weight: f64,
-    mst: ResizingArrayQueue<Edge>,
+    mst: Queue<Edge>,
     marked: Vec<bool>,
-    pq: BinaryHeapMinPQ<Edge>
+    pq: MinPQ<Edge>
 }
 
 impl<'a> LazyPrimMST<'a> {
     fn new<'b>(graph: &'b EdgeWeightedGraph) -> LazyPrimMST<'b> {
         let n = graph.v();
         let marked = iter::repeat(false).take(n).collect();
-        let pq = BinaryHeapMinPQ::new();
-        let mst = ResizingArrayQueue::new();
+        let pq = MinPQ::new();
+        let mst = Queue::new();
 
         let mut ret = LazyPrimMST {
             graph: graph,
@@ -365,7 +360,7 @@ impl<'a> PrimMST<'a> {
     }
 
     pub fn edges(&self) -> Vec<Edge> {
-        let mut mst = ResizingArrayQueue::new();
+        let mut mst = Queue::new();
         for e in self.edge_to.iter() {
             e.map(|e| mst.enqueue(e.clone()));
         }

src/stacks_and_queues/linked_queue.rs renamed to src/fundamentals/stacks_and_queues/linked_queue.rs

@@ -0,0 +1,4 @@
+pub mod undirected_graphs;
+pub mod directed_graphs;
+
+pub mod minimum_spanning_trees;

src/stacks_and_queues/linked_stack.rs renamed to src/fundamentals/stacks_and_queues/linked_stack.rs

@@ -1,8 +1,8 @@
 use std::iter;
-use super::stacks_and_queues::bag::Bag;
-use super::stacks_and_queues::{Stack, Queue};
-use super::stacks_and_queues::linked_stack;
-use super::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
+use super::super::fundamentals::stacks_and_queues::bag::Bag;
+use super::super::fundamentals::stacks_and_queues::{Stack, Queue};
+use super::super::fundamentals::stacks_and_queues::linked_stack;
+use super::super::fundamentals::stacks_and_queues::resizing_array_queue::ResizingArrayQueue;
 
 #[derive(Clone, Debug)]
 pub struct Graph {

src/stacks_and_queues/mod.rs renamed to src/fundamentals/stacks_and_queues/mod.rs

@@ -6,41 +6,20 @@ extern crate adivon;
 #[macro_use]
 extern crate mtl;
 
-// part1
-pub mod union_find;
+pub mod fundamentals;
 
-pub mod stacks_and_queues;
-pub mod elementary_sorts;
+pub mod sorting;
 
-pub mod mergesort;
-pub mod quicksort;
+pub mod searching;
 
-pub mod convex_hull;
+pub mod graphs;
 
-pub mod priority_queues;
+pub mod strings;
 
-pub mod symbol_tables;
+pub mod convex_hull;
 
-pub mod balanced_search_trees;
 pub mod geometric_search;
 
-pub mod hash_tables;
 pub mod searching_application;
 
-// part2
-pub mod undirected_graphs;
-pub mod directed_graphs;
-
-pub mod minimum_spanning_trees;
-pub mod shortest_paths;
-
-pub mod maximum_flow;
-pub mod radix_sorts;
-
-pub mod tries;
-pub mod substring_search;
-
-pub mod regular_expressions;
-pub mod data_compression;
-
-pub mod linear_programming;
+pub mod context;