Chapeter 10 finished

Author: senrust

chapter_10/binary_heap/Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "binary_heap"
+version = "0.1.0"
+authors = ["Yohei Osawa <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_10/binary_heap/Cargo.toml

@@ -0,0 +1,26 @@
+
+fn main() {
+    let heap_size: usize = input::read_number();
+    let input_values: Vec<i32> = input::read_numline();
+    let mut heap_vec: Vec<Option<i32>> = Vec::new();
+    heap_vec.push(None);
+    for i in 0..heap_size {
+        let value: i32 = input_values[i];
+        heap_vec.push(Some(value));
+    }
+
+    for i in 1..heap_size+1{
+        print!("node {}: ", i);
+        print!("key = {}, ", heap_vec[i].unwrap());
+        if i != 1 {
+            print!("parent key = {}, ", heap_vec[i/2].unwrap());
+        }
+        if 2*i <= heap_size {
+            print!("left key = {}, ", heap_vec[2*i].unwrap());
+        }
+        if 2*i+1 <= heap_size {
+            print!("right key = {}, ", heap_vec[2*i+1].unwrap());
+        }
+        print!("\n");
+    }
+}

chapter_10/binary_heap/src/main.rs

@@ -0,0 +1,10 @@
+[package]
+name = "max_heap"
+version = "0.1.0"
+authors = ["Yohei Osawa <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_10/max_heap/Cargo.lock

@@ -0,0 +1,2 @@
+10
+4 1 3 2 16 9 10 14 8 7

chapter_10/max_heap/Cargo.toml

@@ -0,0 +1,34 @@
+fn maxheapfy(index: usize, heap: &mut Vec<i32>){
+    let mut largest_index = index;
+    if index*2 <=  heap.len() -1{
+        if heap[index] < heap[index*2] {
+            largest_index = index*2;
+        }
+    }
+    if index*2+1 <=  heap.len() -1{
+        if  heap[largest_index] < heap[index*2+1] {
+            largest_index = index*2+1;
+        }
+    }
+    if largest_index != index {
+        heap.swap(index, largest_index);
+        maxheapfy(largest_index, heap);
+    }
+}
+
+fn main() {
+    let heap_size: usize = input::read_number();
+    let input_values: Vec<i32> = input::read_numline();
+    let mut heap_vec: Vec<i32> = Vec::new();
+    heap_vec.push(0);
+    for i in 0..heap_size{
+        heap_vec.push(input_values[i]);
+    }
+    for i in (1..=heap_size/2).rev() {
+        maxheapfy(i, &mut heap_vec);
+    }
+    for i in 1..=heap_size{
+        print!("{}, ", heap_vec[i])
+    }
+    print!("\n");
+}

chapter_10/max_heap/input.txt

@@ -0,0 +1,10 @@
+[package]
+name = "priority_queue"
+version = "0.1.0"
+authors = ["Yohei Osawa <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_10/max_heap/src/main.rs

@@ -0,0 +1,9 @@
+insert 8
+insert 2
+extract
+insert 10
+extract
+insert 11
+extract
+extract
+end

chapter_10/priority_queue/Cargo.lock

@@ -0,0 +1,55 @@
+fn maxheapfy(index: usize, heap: &mut Vec<i32>){
+    let mut largest_index = index;
+    if index*2 <=  heap.len() -1{
+        if heap[index] < heap[index*2] {
+            largest_index = index*2;
+        }
+    }
+    if index*2+1 <=  heap.len() -1{
+        if  heap[largest_index] < heap[index*2+1] {
+            largest_index = index*2+1;
+        }
+    }
+    if largest_index != index {
+        heap.swap(index, largest_index);
+        maxheapfy(largest_index, heap);
+    }
+}
+
+fn order_insertion_key(index: usize, heap: &mut Vec<i32>) {
+    if index <= 1{
+        return;
+    }
+    while heap[index] > heap[index/2] && index > 1{
+        heap.swap(index, index/2);
+    }
+}
+
+fn insert(key: i32, heap: &mut Vec<i32>) {
+    heap.push(key);
+    order_insertion_key(heap.len() -1, heap);
+}
+
+fn extract(heap: &mut Vec<i32>) -> i32{
+    let heaplen = heap.len() - 1;
+    heap.swap(1, heaplen);
+    let value = heap.pop().unwrap();
+    maxheapfy(1, heap);
+    value
+}
+
+fn main() {
+    let mut heap_vec: Vec<i32> = Vec::new();
+    heap_vec.push(0);
+    loop {
+        let input_line: Vec<String> = input::read_numline();
+        if input_line[0] == "insert" {
+            insert(input_line[1].parse::<i32>().ok().unwrap(), &mut heap_vec);
+        } else if input_line[0] == "extract" {
+            let value = extract(&mut heap_vec);
+            println!("value is {}", value);
+        } else {
+            break;
+        }
+    }
+}

chapter_10/priority_queue/Cargo.toml

@@ -50,11 +50,16 @@ impl<T> BinaryTree<T> {
     fn locate_mut<K>(&mut self, key: &K) -> &mut Link<T> where T: Indexed<K>, K: Ord {
         let mut anchor = &mut self.root;
         loop {
-            match anchor.as_ref() {
+            match anchor {
+                Some(n)if key == n.value.key() => {
+                    let node = anchor.as_mut().unwrap(); anchor = &mut  node.left;
+                }
                 Some(n) if key != n.value.key() => {
-                    let node = anchor.as_mut().unwrap();
-                    anchor = if key < node.value.key() { &mut node.left } else { &mut node.right }
+                    // let node = anchor.as_mut().unwrap();
+                    anchor = if key < n.value.key() { &mut n.left } else { &mut n.right }
                 }
+                
+
                 _ => return anchor,
             }
         }