Commit bdfd0e8e by Tom Almeida

### Added Rust examples and fixed Quicksort.md

parent 0ca80fd2
 ... ... @@ -20,7 +20,7 @@ function quicksort(array) quicksort(less) quicksort(greater) array := concatenate(less, equal, greater) ``` ``` A better quicksort algorithm works in place, by swapping elements within the array, to avoid the memory allocation of more arrays. ``` function quicksort(array) ... ... @@ -39,7 +39,7 @@ function quicksort(array) right := right - 1 quicksort(array from first index to right) quicksort(array from left to last index) ``` ``` Quicksort is often compared to Mergesort as they both have an average time complexity of O(nlogn). According to the perldoc: > On average, mergesort does fewer comparisons than quicksort, so it may be better when complicated comparison routines are used. Mergesort also takes advantage of pre-existing order, so it would be favored for using sort() to merge several sorted arrays. On the other hand, quicksort is often faster for small arrays, and on arrays of a few distinct values, repeated many times. ... ...
 // Using stdlib use std::collections::BinaryHeap; fn main() { let src = vec![6,2,3,6,1,2,7,8,3,2]; let sorted= BinaryHeap::from(src).into_sorted_vec(); println!("{:?}", sorted); } // Full code fn heap_sort(array: &mut [T], order: F) where F: Fn(&T,&T) -> bool { let len = array.len(); // Create heap for start in (0..len/2).rev() { sift_down(array,&order,start,len-1) } for end in (1..len).rev() { array.swap(0,end); sift_down(array,&order,0,end-1) } } fn sift_down(array: &mut [T], order: &F, start: usize, end: usize) where F: Fn(&T,&T) -> bool { let mut root = start; loop { let mut child = root * 2 + 1; if child > end { break; } if child + 1 <= end && order(&array[child], &array[child + 1]) { child += 1; } if order(&array[root], &array[child]) { array.swap(root,child); root = child } else { break; } } }
 // First argument is the array. Second argument is a comparison function fn quick_sort(v: &mut [T], f: &F) where F: Fn(&T,&T) -> bool { let len = v.len(); if len >= 2 { let pivot_index = partition(v, f); quick_sort(&mut v[0..pivot_index], f); quick_sort(&mut v[pivot_index + 1..len], f); } } fn partition(v: &mut [T], f: &F) -> usize where F: Fn(&T,&T) -> bool { let len = v.len(); let pivot_index = len / 2; v.swap(pivot_index, len - 1); let mut store_index = 0; for i in 0..len - 1 { if f(&v[i], &v[len - 1]) { v.swap(i, store_index); store_index += 1; } } v.swap(store_index, len - 1); store_index }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!