Initial data commit

Task/Sorting-algorithms-Merge-sort/Rust/sorting-algorithms-merge-sort-1.rust

@@ -0,0 +1,57 @@
+pub fn merge_sort1<T: Copy + Ord>(v: &mut [T]) {
+    sort(v, &mut Vec::new());
+
+    fn sort<T: Copy + Ord>(v: &mut [T], t: &mut Vec<T>) {
+        match v.len() {
+            0 | 1 => (),
+            // n if n <= 20 => insertion_sort(v),
+            n => {
+                if t.is_empty() {
+                    t.reserve_exact(n);
+                    t.resize(n, v[0]);
+                }
+                let m = n / 2;
+                sort(&mut v[..m], t);
+                sort(&mut v[m..], t);
+                if v[m - 1] <= v[m] {
+                    return;
+                }
+                copy(v, t);
+                merge(&t[..m], &t[m..n], v);
+            }
+        }
+    }
+
+    // merge a + b -> c
+    #[inline(always)]
+    fn merge<T: Copy + Ord>(a: &[T], b: &[T], c: &mut [T]) {
+        let (mut i, mut j) = (0, 0);
+        for k in 0..c.len() {
+            if i < a.len() && (j >= b.len() || a[i] <= b[j]) {
+                c[k] = a[i];
+                i += 1;
+            } else {
+                c[k] = b[j];
+                j += 1;
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn copy<T: Copy>(src: &[T], dst: &mut [T]) {
+        for i in 0..src.len() {
+            dst[i] = src[i];
+        }
+    }
+
+    #[inline(always)]
+    fn insertion_sort<T: Ord>(v: &mut [T]) {
+        for i in 1..v.len() {
+            let mut j = i;
+            while j > 0 && v[j] < v[j - 1] {
+                v.swap(j, j - 1);
+                j -= 1;
+            }
+        }
+    }
+}

Task/Sorting-algorithms-Merge-sort/Rust/sorting-algorithms-merge-sort-2.rust

@@ -0,0 +1,46 @@
+pub fn merge_sort2<T: Copy + Ord>(v: &mut [T]) {
+    sort(v, &mut Vec::new());
+
+    fn sort<T: Copy + Ord>(v: &mut [T], t: &mut Vec<T>) {
+        match v.len() {
+            0 | 1 => (),
+            // n if n <= 20 => insertion_sort(v),
+            n => {
+                let m = n / 2;
+                if t.is_empty() {
+                    t.reserve_exact(m);
+                    t.resize(m, v[0]);
+                }
+                sort(&mut v[..m], t);
+                sort(&mut v[m..], t);
+                if v[m - 1] <= v[m] {
+                    return;
+                }
+                copy(&v[..m], t);
+                merge(&t[..m], v);
+            }
+        }
+    }
+
+    // merge a + b[a.len..] -> b
+    #[inline(always)]
+    fn merge<T: Copy + Ord>(a: &[T], b: &mut [T]) {
+        let (mut i, mut j) = (0, a.len());
+        for k in 0..b.len() {
+            if i < a.len() && (j >= b.len() || a[i] <= b[j]) {
+                b[k] = a[i];
+                i += 1;
+            } else {
+                b[k] = b[j];
+                j += 1;
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn copy<T: Copy>(src: &[T], dst: &mut [T]) {
+        for i in 0..src.len() {
+            dst[i] = src[i];
+        }
+    }
+}

Task/Sorting-algorithms-Merge-sort/Rust/sorting-algorithms-merge-sort-3.rust

@@ -0,0 +1,63 @@
+pub fn merge_sort3<T: Copy + Ord>(v: &mut [T]) {
+    match v.len() {
+        0 | 1 => (),
+        n => {
+            let mut t = Vec::with_capacity(n);
+            t.resize(n, v[0]);
+            let mut p = 1;
+            while p < n {
+                p = merge_blocks(v, &mut t, p, n);
+                if p >= n {
+                    copy(&t, v);
+                    return;
+                }
+                p = merge_blocks(&t, v, p, n);
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn merge_blocks<T: Copy + Ord>(a: &[T], b: &mut [T], p: usize, n: usize) -> usize {
+        let mut i = 0;
+        while i < n {
+            if i + p >= n {
+                copy(&a[i..], &mut b[i..])
+            } else if i + p * 2 > n {
+                merge(&a[i..i + p], &a[i + p..], &mut b[i..]);
+            } else {
+                merge(&a[i..i + p], &a[i + p..i + p * 2], &mut b[i..i + p * 2]);
+            }
+            i += p * 2;
+        }
+        p * 2
+    }
+
+    // merge a + b -> c
+    #[inline(always)]
+    fn merge<T: Copy + Ord>(a: &[T], b: &[T], c: &mut [T]) {
+        let (mut i, mut j, mut k) = (0, 0, 0);
+        while i < a.len() && j < b.len() {
+            if a[i] < b[j] {
+                c[k] = a[i];
+                i += 1;
+            } else {
+                c[k] = b[j];
+                j += 1;
+            }
+            k += 1;
+        }
+        if i < a.len() {
+            copy(&a[i..], &mut c[k..]);
+        }
+        if j < b.len() {
+            copy(&b[j..], &mut c[k..]);
+        }
+    }
+
+    #[inline(always)]
+    fn copy<T: Copy>(src: &[T], dst: &mut [T]) {
+        for i in 0..src.len() {
+            dst[i] = src[i];
+        }
+    }
+}