Anson/Go-v-Rust-Quicksort
1
0
Fork 0
mirror of https://gitlab.com/Anson-Projects/anson-stuff/Go-v-Rust-Quicksort.git synced 2025-06-15 21:56:39 +00:00
Code Releases Activity

final code

Browse Source
This commit is contained in:
Anson Biggs 2022-04-25 21:02:23 -07:00
parent 934f5aa61b
commit b43510b33e
3 changed files with 27 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
golang/main.go
View File

@ -21,7 +21,6 @@ func quicksort(slice []int) {
} }
func par_quicksort(slice []int) { func par_quicksort(slice []int) {
if len(slice) <= 1 { if len(slice) <= 1 {
return return
} }
@ -89,7 +88,6 @@ func choose_pivot(slice []int) int {
} else { } else {
return mid return mid
} }
} }
func swap(slice []int, a int, b int) { func swap(slice []int, a int, b int) {
@ -103,18 +101,17 @@ func main() {
sortSize := 20000000 sortSize := 20000000
// MAXGOROUTINES := 1 // MAXGOROUTINES := 1
unsorted := make([]int, 0, sortSize) unsorted := make([]int, 0, sortSize)
unsorted = rand.Perm(sortSize)
start := time.Now() start := time.Now()
unsorted = rand.Perm(sortSize)
quicksort(unsorted) quicksort(unsorted)
duration := time.Since(start) duration := time.Since(start)
fmt.Println("single ", duration) fmt.Println("Single Threaded: ", duration)
unsorted = rand.Perm(sortSize)
start = time.Now() start = time.Now()
unsorted = rand.Perm(sortSize)
par_quicksort(unsorted) par_quicksort(unsorted)
duration = time.Since(start) duration = time.Since(start)
fmt.Println("Concurrent: ", duration)
fmt.Println(duration)
} }

1
rust/.rustfmt.toml Normal file
View File

@ -0,0 +1 @@
max_width = 60

37
rust/src/main.rs
View File

@ -3,7 +3,8 @@
use rayon::join; use rayon::join;
fn choose_pivot<T: Ord>(slice: &[T]) -> usize { fn choose_pivot<T: Ord>(slice: &[T]) -> usize {
let (mut left, mid, mut right) = (0, slice.len() / 2, slice.len() - 1); let (mut left, mid, mut right) =
(0, slice.len() / 2, slice.len() - 1);
if slice[right] < slice[left] { if slice[right] < slice[left] {
std::mem::swap(&mut right, &mut left); std::mem::swap(&mut right, &mut left);
} }
@ -16,7 +17,10 @@ fn choose_pivot<T: Ord>(slice: &[T]) -> usize {
} }
} }
fn partition<T: Ord>(slice: &mut [T], pivot: usize) -> usize { fn partition<T: Ord>(
slice: &mut [T],
pivot: usize,
) -> usize {
let mid = slice.len() - 1; let mid = slice.len() - 1;
slice.swap(pivot, mid); slice.swap(pivot, mid);
let (mut left, mut right) = (0, mid - 1); let (mut left, mut right) = (0, mid - 1);
@ -62,7 +66,8 @@ fn quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
} }
let pivot = partition(slice, choose_pivot(slice)); let pivot = partition(slice, choose_pivot(slice));
let (left_slice, right_slice) = slice.split_at_mut(pivot); let (left_slice, right_slice) =
slice.split_at_mut(pivot);
let right_slice = &mut right_slice[1..]; // want to exclude pivot let right_slice = &mut right_slice[1..]; // want to exclude pivot
@ -70,7 +75,9 @@ fn quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
quicksort(right_slice); quicksort(right_slice);
} }
fn par_quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) { fn par_quicksort<T: Ord + std::marker::Send>(
slice: &mut [T],
) {
if slice.len() <= 1 { if slice.len() <= 1 {
return; return;
} else if slice.len() == 2 { } else if slice.len() == 2 {
@ -81,30 +88,30 @@ fn par_quicksort<T: Ord + std::marker::Send>(slice: &mut [T]) {
} }
let pivot = partition(slice, choose_pivot(slice)); let pivot = partition(slice, choose_pivot(slice));
let (left_slice, right_slice) = slice.split_at_mut(pivot); let (left_slice, right_slice) =
slice.split_at_mut(pivot);
let right_slice = &mut right_slice[1..]; // want to exclude pivot let right_slice = &mut right_slice[1..]; // want to exclude pivot
join(|| quicksort(left_slice), || quicksort(right_slice)); join(
|| quicksort(left_slice),
|| quicksort(right_slice),
);
} }
use rand::distributions::{Distribution, Uniform}; use rand::prelude::SliceRandom;
use rand::thread_rng; use rand::thread_rng;
fn main() { fn main() {
let mut s: Vec<i32> = Uniform::from(0..1_000_000_000) let mut s = get_bench_vec();
.sample_iter(&mut thread_rng())
.take(100_000)
.collect();
quicksort(&mut s); quicksort(&mut s);
par_quicksort(&mut s);
} }
extern crate test; extern crate test;
use test::Bencher; use test::Bencher;
fn get_bench_vec() -> Vec<i32> { fn get_bench_vec() -> Vec<i32> {
let s = Uniform::from(0..1_000_000_000) let mut s = (0..20000000).collect::<Vec<i32>>();
.sample_iter(&mut thread_rng()) s.shuffle(&mut thread_rng());
.take(500_000)
.collect();
return s; return s;
} }