mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-05 15:18:49 +00:00
Remove unneeded semicolons from the core library
This commit is contained in:
gingerBill
+209
-209
@@ -1,9 +1,9 @@
|
||||
package slice
|
||||
|
||||
import "core:intrinsics"
|
||||
_ :: intrinsics;
|
||||
_ :: intrinsics
|
||||
|
||||
ORD :: intrinsics.type_is_ordered;
|
||||
ORD :: intrinsics.type_is_ordered
|
||||
|
||||
Ordering :: enum {
|
||||
Less = -1,
|
||||
@@ -14,23 +14,23 @@ Ordering :: enum {
|
||||
cmp :: proc(a, b: $E) -> Ordering where ORD(E) {
|
||||
switch {
|
||||
case a < b:
|
||||
return .Less;
|
||||
return .Less
|
||||
case a > b:
|
||||
return .Greater;
|
||||
return .Greater
|
||||
}
|
||||
return .Equal;
|
||||
return .Equal
|
||||
}
|
||||
|
||||
cmp_proc :: proc($E: typeid) -> (proc(E, E) -> Ordering) where ORD(E) {
|
||||
return proc(a, b: E) -> Ordering {
|
||||
switch {
|
||||
case a < b:
|
||||
return .Less;
|
||||
return .Less
|
||||
case a > b:
|
||||
return .Greater;
|
||||
return .Greater
|
||||
}
|
||||
return .Equal;
|
||||
};
|
||||
return .Equal
|
||||
}
|
||||
}
|
||||
|
||||
// sort sorts a slice
|
||||
@@ -38,7 +38,7 @@ cmp_proc :: proc($E: typeid) -> (proc(E, E) -> Ordering) where ORD(E) {
|
||||
sort :: proc(data: $T/[]$E) where ORD(E) {
|
||||
when size_of(E) != 0 {
|
||||
if n := len(data); n > 1 {
|
||||
_quick_sort(data, 0, n, _max_depth(n));
|
||||
_quick_sort(data, 0, n, _max_depth(n))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -48,7 +48,7 @@ sort :: proc(data: $T/[]$E) where ORD(E) {
|
||||
sort_by :: proc(data: $T/[]$E, less: proc(i, j: E) -> bool) {
|
||||
when size_of(E) != 0 {
|
||||
if n := len(data); n > 1 {
|
||||
_quick_sort_less(data, 0, n, _max_depth(n), less);
|
||||
_quick_sort_less(data, 0, n, _max_depth(n), less)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -56,7 +56,7 @@ sort_by :: proc(data: $T/[]$E, less: proc(i, j: E) -> bool) {
|
||||
sort_by_cmp :: proc(data: $T/[]$E, cmp: proc(i, j: E) -> Ordering) {
|
||||
when size_of(E) != 0 {
|
||||
if n := len(data); n > 1 {
|
||||
_quick_sort_cmp(data, 0, n, _max_depth(n), cmp);
|
||||
_quick_sort_cmp(data, 0, n, _max_depth(n), cmp)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,124 +64,124 @@ sort_by_cmp :: proc(data: $T/[]$E, cmp: proc(i, j: E) -> Ordering) {
|
||||
is_sorted :: proc(array: $T/[]$E) -> bool where ORD(E) {
|
||||
for i := len(array)-1; i > 0; i -= 1 {
|
||||
if array[i] < array[i-1] {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
is_sorted_by :: proc(array: $T/[]$E, less: proc(i, j: E) -> bool) -> bool {
|
||||
for i := len(array)-1; i > 0; i -= 1 {
|
||||
if less(array[i], array[i-1]) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
is_sorted_cmp :: proc(array: $T/[]$E, cmp: proc(i, j: E) -> Ordering) -> bool {
|
||||
for i := len(array)-1; i > 0; i -= 1 {
|
||||
if cmp(array[i], array[i-1]) == .Equal {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
|
||||
reverse_sort :: proc(data: $T/[]$E) where ORD(E) {
|
||||
sort_by(data, proc(i, j: E) -> bool {
|
||||
return j < i;
|
||||
});
|
||||
return j < i
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
reverse_sort_by :: proc(data: $T/[]$E, less: proc(i, j: E) -> bool) where ORD(E) {
|
||||
context._internal = rawptr(less);
|
||||
context._internal = rawptr(less)
|
||||
sort_by(data, proc(i, j: E) -> bool {
|
||||
k := (proc(i, j: E) -> bool)(context._internal);
|
||||
return k(j, i);
|
||||
});
|
||||
k := (proc(i, j: E) -> bool)(context._internal)
|
||||
return k(j, i)
|
||||
})
|
||||
}
|
||||
|
||||
reverse_sort_by_cmp :: proc(data: $T/[]$E, cmp: proc(i, j: E) -> Ordering) where ORD(E) {
|
||||
context._internal = rawptr(cmp);
|
||||
context._internal = rawptr(cmp)
|
||||
sort_by_cmp(data, proc(i, j: E) -> Ordering {
|
||||
k := (proc(i, j: E) -> Ordering)(context._internal);
|
||||
return k(j, i);
|
||||
});
|
||||
k := (proc(i, j: E) -> Ordering)(context._internal)
|
||||
return k(j, i)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
// TODO(bill): Should `sort_by_key` exist or is `sort_by` more than enough?
|
||||
sort_by_key :: proc(data: $T/[]$E, key: proc(E) -> $K) where ORD(K) {
|
||||
context._internal = rawptr(key);
|
||||
context._internal = rawptr(key)
|
||||
sort_by(data, proc(i, j: E) -> bool {
|
||||
k := (proc(E) -> K)(context._internal);
|
||||
return k(i) < k(j);
|
||||
});
|
||||
k := (proc(E) -> K)(context._internal)
|
||||
return k(i) < k(j)
|
||||
})
|
||||
}
|
||||
|
||||
reverse_sort_by_key :: proc(data: $T/[]$E, key: proc(E) -> $K) where ORD(K) {
|
||||
context._internal = rawptr(key);
|
||||
context._internal = rawptr(key)
|
||||
sort_by(data, proc(i, j: E) -> bool {
|
||||
k := (proc(E) -> K)(context._internal);
|
||||
return k(j) < k(i);
|
||||
});
|
||||
k := (proc(E) -> K)(context._internal)
|
||||
return k(j) < k(i)
|
||||
})
|
||||
}
|
||||
|
||||
is_sorted_by_key :: proc(array: $T/[]$E, key: proc(E) -> $K) -> bool where ORD(K) {
|
||||
for i := len(array)-1; i > 0; i -= 1 {
|
||||
if key(array[i]) < key(array[i-1]) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
|
||||
@(private)
|
||||
_max_depth :: proc(n: int) -> int { // 2*ceil(log2(n+1))
|
||||
depth: int;
|
||||
depth: int
|
||||
for i := n; i > 0; i >>= 1 {
|
||||
depth += 1;
|
||||
depth += 1
|
||||
}
|
||||
return depth * 2;
|
||||
return depth * 2
|
||||
}
|
||||
|
||||
@(private)
|
||||
_quick_sort :: proc(data: $T/[]$E, a, b, max_depth: int) where ORD(E) {
|
||||
median3 :: proc(data: T, m1, m0, m2: int) {
|
||||
if data[m1] < data[m0] {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
if data[m2] < data[m1] {
|
||||
swap(data, m2, m1);
|
||||
swap(data, m2, m1)
|
||||
if data[m1] < data[m0] {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
do_pivot :: proc(data: T, lo, hi: int) -> (midlo, midhi: int) {
|
||||
m := int(uint(lo+hi)>>1);
|
||||
m := int(uint(lo+hi)>>1)
|
||||
if hi-lo > 40 {
|
||||
s := (hi-lo)/8;
|
||||
median3(data, lo, lo+s, lo+s*2);
|
||||
median3(data, m, m-s, m+s);
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2);
|
||||
s := (hi-lo)/8
|
||||
median3(data, lo, lo+s, lo+s*2)
|
||||
median3(data, m, m-s, m+s)
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2)
|
||||
}
|
||||
median3(data, lo, m, hi-1);
|
||||
median3(data, lo, m, hi-1)
|
||||
|
||||
|
||||
pivot := lo;
|
||||
a, c := lo+1, hi-1;
|
||||
pivot := lo
|
||||
a, c := lo+1, hi-1
|
||||
|
||||
for ; a < c && data[a] < data[pivot]; a += 1 {
|
||||
}
|
||||
b := a;
|
||||
b := a
|
||||
|
||||
for {
|
||||
for ; b < c && !(data[pivot] < data[b]); b += 1 { // data[b] <= pivot
|
||||
@@ -189,33 +189,33 @@ _quick_sort :: proc(data: $T/[]$E, a, b, max_depth: int) where ORD(E) {
|
||||
for ; b < c && data[pivot] < data[c-1]; c -=1 { // data[c-1] > pivot
|
||||
}
|
||||
if b >= c {
|
||||
break;
|
||||
break
|
||||
}
|
||||
|
||||
swap(data, b, c-1);
|
||||
b += 1;
|
||||
c -= 1;
|
||||
swap(data, b, c-1)
|
||||
b += 1
|
||||
c -= 1
|
||||
}
|
||||
|
||||
protect := hi-c < 5;
|
||||
protect := hi-c < 5
|
||||
if !protect && hi-c < (hi-lo)/4 {
|
||||
dups := 0;
|
||||
dups := 0
|
||||
if !(data[pivot] < data[hi-1]) {
|
||||
swap(data, c, hi-1);
|
||||
c += 1;
|
||||
dups += 1;
|
||||
swap(data, c, hi-1)
|
||||
c += 1
|
||||
dups += 1
|
||||
}
|
||||
if !(data[b-1] < data[pivot]) {
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
|
||||
if !(data[m] < data[pivot]) {
|
||||
swap(data, m, b-1);
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
swap(data, m, b-1)
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
protect = dups > 1;
|
||||
protect = dups > 1
|
||||
}
|
||||
if protect {
|
||||
for {
|
||||
@@ -224,43 +224,43 @@ _quick_sort :: proc(data: $T/[]$E, a, b, max_depth: int) where ORD(E) {
|
||||
for ; a < b && data[a] < data[pivot]; a += 1 {
|
||||
}
|
||||
if a >= b {
|
||||
break;
|
||||
break
|
||||
}
|
||||
swap(data, a, b-1);
|
||||
a += 1;
|
||||
b -= 1;
|
||||
swap(data, a, b-1)
|
||||
a += 1
|
||||
b -= 1
|
||||
}
|
||||
}
|
||||
swap(data, pivot, b-1);
|
||||
return b-1, c;
|
||||
swap(data, pivot, b-1)
|
||||
return b-1, c
|
||||
}
|
||||
|
||||
|
||||
a, b, max_depth := a, b, max_depth;
|
||||
a, b, max_depth := a, b, max_depth
|
||||
|
||||
if b-a > 12 { // only use shell sort for lengths <= 12
|
||||
if max_depth == 0 {
|
||||
_heap_sort(data, a, b);
|
||||
return;
|
||||
_heap_sort(data, a, b)
|
||||
return
|
||||
}
|
||||
max_depth -= 1;
|
||||
mlo, mhi := do_pivot(data, a, b);
|
||||
max_depth -= 1
|
||||
mlo, mhi := do_pivot(data, a, b)
|
||||
if mlo-a < b-mhi {
|
||||
_quick_sort(data, a, mlo, max_depth);
|
||||
a = mhi;
|
||||
_quick_sort(data, a, mlo, max_depth)
|
||||
a = mhi
|
||||
} else {
|
||||
_quick_sort(data, mhi, b, max_depth);
|
||||
b = mlo;
|
||||
_quick_sort(data, mhi, b, max_depth)
|
||||
b = mlo
|
||||
}
|
||||
}
|
||||
if b-a > 1 {
|
||||
// Shell short with gap 6
|
||||
for i in a+6..<b {
|
||||
if data[i] < data[i-6] {
|
||||
swap(data, i, i-6);
|
||||
swap(data, i, i-6)
|
||||
}
|
||||
}
|
||||
_insertion_sort(data, a, b);
|
||||
_insertion_sort(data, a, b)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -268,7 +268,7 @@ _quick_sort :: proc(data: $T/[]$E, a, b, max_depth: int) where ORD(E) {
|
||||
_insertion_sort :: proc(data: $T/[]$E, a, b: int) where ORD(E) {
|
||||
for i in a+1..<b {
|
||||
for j := i; j > a && data[j] < data[j-1]; j -= 1 {
|
||||
swap(data, j, j-1);
|
||||
swap(data, j, j-1)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -276,33 +276,33 @@ _insertion_sort :: proc(data: $T/[]$E, a, b: int) where ORD(E) {
|
||||
@(private)
|
||||
_heap_sort :: proc(data: $T/[]$E, a, b: int) where ORD(E) {
|
||||
sift_down :: proc(data: T, lo, hi, first: int) {
|
||||
root := lo;
|
||||
root := lo
|
||||
for {
|
||||
child := 2*root + 1;
|
||||
child := 2*root + 1
|
||||
if child >= hi {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if child+1 < hi && data[first+child] < data[first+child+1] {
|
||||
child += 1;
|
||||
child += 1
|
||||
}
|
||||
if !(data[first+root] < data[first+child]) {
|
||||
return;
|
||||
return
|
||||
}
|
||||
swap(data, first+root, first+child);
|
||||
root = child;
|
||||
swap(data, first+root, first+child)
|
||||
root = child
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
first, lo, hi := a, 0, b-a;
|
||||
first, lo, hi := a, 0, b-a
|
||||
|
||||
for i := (hi-1)/2; i >= 0; i -= 1 {
|
||||
sift_down(data, i, hi, first);
|
||||
sift_down(data, i, hi, first)
|
||||
}
|
||||
|
||||
for i := hi-1; i >= 0; i -= 1 {
|
||||
swap(data, first, first+i);
|
||||
sift_down(data, lo, i, first);
|
||||
swap(data, first, first+i)
|
||||
sift_down(data, lo, i, first)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -315,32 +315,32 @@ _heap_sort :: proc(data: $T/[]$E, a, b: int) where ORD(E) {
|
||||
_quick_sort_less :: proc(data: $T/[]$E, a, b, max_depth: int, less: proc(i, j: E) -> bool) {
|
||||
median3 :: proc(data: T, m1, m0, m2: int, less: proc(i, j: E) -> bool) {
|
||||
if less(data[m1], data[m0]) {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
if less(data[m2], data[m1]) {
|
||||
swap(data, m2, m1);
|
||||
swap(data, m2, m1)
|
||||
if less(data[m1], data[m0]) {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
do_pivot :: proc(data: T, lo, hi: int, less: proc(i, j: E) -> bool) -> (midlo, midhi: int) {
|
||||
m := int(uint(lo+hi)>>1);
|
||||
m := int(uint(lo+hi)>>1)
|
||||
if hi-lo > 40 {
|
||||
s := (hi-lo)/8;
|
||||
median3(data, lo, lo+s, lo+s*2, less);
|
||||
median3(data, m, m-s, m+s, less);
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2, less);
|
||||
s := (hi-lo)/8
|
||||
median3(data, lo, lo+s, lo+s*2, less)
|
||||
median3(data, m, m-s, m+s, less)
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2, less)
|
||||
}
|
||||
median3(data, lo, m, hi-1, less);
|
||||
median3(data, lo, m, hi-1, less)
|
||||
|
||||
pivot := lo;
|
||||
a, c := lo+1, hi-1;
|
||||
pivot := lo
|
||||
a, c := lo+1, hi-1
|
||||
|
||||
for ; a < c && less(data[a], data[pivot]); a += 1 {
|
||||
}
|
||||
b := a;
|
||||
b := a
|
||||
|
||||
for {
|
||||
for ; b < c && !less(data[pivot], data[b]); b += 1 { // data[b] <= pivot
|
||||
@@ -348,33 +348,33 @@ _quick_sort_less :: proc(data: $T/[]$E, a, b, max_depth: int, less: proc(i, j: E
|
||||
for ; b < c && less(data[pivot], data[c-1]); c -=1 { // data[c-1] > pivot
|
||||
}
|
||||
if b >= c {
|
||||
break;
|
||||
break
|
||||
}
|
||||
|
||||
swap(data, b, c-1);
|
||||
b += 1;
|
||||
c -= 1;
|
||||
swap(data, b, c-1)
|
||||
b += 1
|
||||
c -= 1
|
||||
}
|
||||
|
||||
protect := hi-c < 5;
|
||||
protect := hi-c < 5
|
||||
if !protect && hi-c < (hi-lo)/4 {
|
||||
dups := 0;
|
||||
dups := 0
|
||||
if !less(data[pivot], data[hi-1]) {
|
||||
swap(data, c, hi-1);
|
||||
c += 1;
|
||||
dups += 1;
|
||||
swap(data, c, hi-1)
|
||||
c += 1
|
||||
dups += 1
|
||||
}
|
||||
if !less(data[b-1], data[pivot]) {
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
|
||||
if !less(data[m], data[pivot]) {
|
||||
swap(data, m, b-1);
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
swap(data, m, b-1)
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
protect = dups > 1;
|
||||
protect = dups > 1
|
||||
}
|
||||
if protect {
|
||||
for {
|
||||
@@ -383,43 +383,43 @@ _quick_sort_less :: proc(data: $T/[]$E, a, b, max_depth: int, less: proc(i, j: E
|
||||
for ; a < b && less(data[a], data[pivot]); a += 1 {
|
||||
}
|
||||
if a >= b {
|
||||
break;
|
||||
break
|
||||
}
|
||||
swap(data, a, b-1);
|
||||
a += 1;
|
||||
b -= 1;
|
||||
swap(data, a, b-1)
|
||||
a += 1
|
||||
b -= 1
|
||||
}
|
||||
}
|
||||
swap(data, pivot, b-1);
|
||||
return b-1, c;
|
||||
swap(data, pivot, b-1)
|
||||
return b-1, c
|
||||
}
|
||||
|
||||
|
||||
a, b, max_depth := a, b, max_depth;
|
||||
a, b, max_depth := a, b, max_depth
|
||||
|
||||
if b-a > 12 { // only use shell sort for lengths <= 12
|
||||
if max_depth == 0 {
|
||||
_heap_sort_less(data, a, b, less);
|
||||
return;
|
||||
_heap_sort_less(data, a, b, less)
|
||||
return
|
||||
}
|
||||
max_depth -= 1;
|
||||
mlo, mhi := do_pivot(data, a, b, less);
|
||||
max_depth -= 1
|
||||
mlo, mhi := do_pivot(data, a, b, less)
|
||||
if mlo-a < b-mhi {
|
||||
_quick_sort_less(data, a, mlo, max_depth, less);
|
||||
a = mhi;
|
||||
_quick_sort_less(data, a, mlo, max_depth, less)
|
||||
a = mhi
|
||||
} else {
|
||||
_quick_sort_less(data, mhi, b, max_depth, less);
|
||||
b = mlo;
|
||||
_quick_sort_less(data, mhi, b, max_depth, less)
|
||||
b = mlo
|
||||
}
|
||||
}
|
||||
if b-a > 1 {
|
||||
// Shell short with gap 6
|
||||
for i in a+6..<b {
|
||||
if less(data[i], data[i-6]) {
|
||||
swap(data, i, i-6);
|
||||
swap(data, i, i-6)
|
||||
}
|
||||
}
|
||||
_insertion_sort_less(data, a, b, less);
|
||||
_insertion_sort_less(data, a, b, less)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -427,7 +427,7 @@ _quick_sort_less :: proc(data: $T/[]$E, a, b, max_depth: int, less: proc(i, j: E
|
||||
_insertion_sort_less :: proc(data: $T/[]$E, a, b: int, less: proc(i, j: E) -> bool) {
|
||||
for i in a+1..<b {
|
||||
for j := i; j > a && less(data[j], data[j-1]); j -= 1 {
|
||||
swap(data, j, j-1);
|
||||
swap(data, j, j-1)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -435,33 +435,33 @@ _insertion_sort_less :: proc(data: $T/[]$E, a, b: int, less: proc(i, j: E) -> bo
|
||||
@(private)
|
||||
_heap_sort_less :: proc(data: $T/[]$E, a, b: int, less: proc(i, j: E) -> bool) {
|
||||
sift_down :: proc(data: T, lo, hi, first: int, less: proc(i, j: E) -> bool) {
|
||||
root := lo;
|
||||
root := lo
|
||||
for {
|
||||
child := 2*root + 1;
|
||||
child := 2*root + 1
|
||||
if child >= hi {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if child+1 < hi && less(data[first+child], data[first+child+1]) {
|
||||
child += 1;
|
||||
child += 1
|
||||
}
|
||||
if !less(data[first+root], data[first+child]) {
|
||||
return;
|
||||
return
|
||||
}
|
||||
swap(data, first+root, first+child);
|
||||
root = child;
|
||||
swap(data, first+root, first+child)
|
||||
root = child
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
first, lo, hi := a, 0, b-a;
|
||||
first, lo, hi := a, 0, b-a
|
||||
|
||||
for i := (hi-1)/2; i >= 0; i -= 1 {
|
||||
sift_down(data, i, hi, first, less);
|
||||
sift_down(data, i, hi, first, less)
|
||||
}
|
||||
|
||||
for i := hi-1; i >= 0; i -= 1 {
|
||||
swap(data, first, first+i);
|
||||
sift_down(data, lo, i, first, less);
|
||||
swap(data, first, first+i)
|
||||
sift_down(data, lo, i, first, less)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -474,32 +474,32 @@ _heap_sort_less :: proc(data: $T/[]$E, a, b: int, less: proc(i, j: E) -> bool) {
|
||||
_quick_sort_cmp :: proc(data: $T/[]$E, a, b, max_depth: int, cmp: proc(i, j: E) -> Ordering) {
|
||||
median3 :: proc(data: T, m1, m0, m2: int, cmp: proc(i, j: E) -> Ordering) {
|
||||
if cmp(data[m1], data[m0]) == .Less {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
if cmp(data[m2], data[m1]) == .Less {
|
||||
swap(data, m2, m1);
|
||||
swap(data, m2, m1)
|
||||
if cmp(data[m1], data[m0]) == .Less {
|
||||
swap(data, m1, m0);
|
||||
swap(data, m1, m0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
do_pivot :: proc(data: T, lo, hi: int, cmp: proc(i, j: E) -> Ordering) -> (midlo, midhi: int) {
|
||||
m := int(uint(lo+hi)>>1);
|
||||
m := int(uint(lo+hi)>>1)
|
||||
if hi-lo > 40 {
|
||||
s := (hi-lo)/8;
|
||||
median3(data, lo, lo+s, lo+s*2, cmp);
|
||||
median3(data, m, m-s, m+s, cmp);
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2, cmp);
|
||||
s := (hi-lo)/8
|
||||
median3(data, lo, lo+s, lo+s*2, cmp)
|
||||
median3(data, m, m-s, m+s, cmp)
|
||||
median3(data, hi-1, hi-1-s, hi-1-s*2, cmp)
|
||||
}
|
||||
median3(data, lo, m, hi-1, cmp);
|
||||
median3(data, lo, m, hi-1, cmp)
|
||||
|
||||
pivot := lo;
|
||||
a, c := lo+1, hi-1;
|
||||
pivot := lo
|
||||
a, c := lo+1, hi-1
|
||||
|
||||
for ; a < c && cmp(data[a], data[pivot]) == .Less; a += 1 {
|
||||
}
|
||||
b := a;
|
||||
b := a
|
||||
|
||||
for {
|
||||
for ; b < c && cmp(data[pivot], data[b]) >= .Equal; b += 1 { // data[b] <= pivot
|
||||
@@ -507,33 +507,33 @@ _quick_sort_cmp :: proc(data: $T/[]$E, a, b, max_depth: int, cmp: proc(i, j: E)
|
||||
for ; b < c && cmp(data[pivot], data[c-1]) == .Less; c -=1 { // data[c-1] > pivot
|
||||
}
|
||||
if b >= c {
|
||||
break;
|
||||
break
|
||||
}
|
||||
|
||||
swap(data, b, c-1);
|
||||
b += 1;
|
||||
c -= 1;
|
||||
swap(data, b, c-1)
|
||||
b += 1
|
||||
c -= 1
|
||||
}
|
||||
|
||||
protect := hi-c < 5;
|
||||
protect := hi-c < 5
|
||||
if !protect && hi-c < (hi-lo)/4 {
|
||||
dups := 0;
|
||||
dups := 0
|
||||
if cmp(data[pivot], data[hi-1]) != .Less {
|
||||
swap(data, c, hi-1);
|
||||
c += 1;
|
||||
dups += 1;
|
||||
swap(data, c, hi-1)
|
||||
c += 1
|
||||
dups += 1
|
||||
}
|
||||
if cmp(data[b-1], data[pivot]) != .Less {
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
|
||||
if cmp(data[m], data[pivot]) != .Less {
|
||||
swap(data, m, b-1);
|
||||
b -= 1;
|
||||
dups += 1;
|
||||
swap(data, m, b-1)
|
||||
b -= 1
|
||||
dups += 1
|
||||
}
|
||||
protect = dups > 1;
|
||||
protect = dups > 1
|
||||
}
|
||||
if protect {
|
||||
for {
|
||||
@@ -542,43 +542,43 @@ _quick_sort_cmp :: proc(data: $T/[]$E, a, b, max_depth: int, cmp: proc(i, j: E)
|
||||
for ; a < b && cmp(data[a], data[pivot]) == .Less; a += 1 {
|
||||
}
|
||||
if a >= b {
|
||||
break;
|
||||
break
|
||||
}
|
||||
swap(data, a, b-1);
|
||||
a += 1;
|
||||
b -= 1;
|
||||
swap(data, a, b-1)
|
||||
a += 1
|
||||
b -= 1
|
||||
}
|
||||
}
|
||||
swap(data, pivot, b-1);
|
||||
return b-1, c;
|
||||
swap(data, pivot, b-1)
|
||||
return b-1, c
|
||||
}
|
||||
|
||||
|
||||
a, b, max_depth := a, b, max_depth;
|
||||
a, b, max_depth := a, b, max_depth
|
||||
|
||||
if b-a > 12 { // only use shell sort for lengths <= 12
|
||||
if max_depth == 0 {
|
||||
_heap_sort_cmp(data, a, b, cmp);
|
||||
return;
|
||||
_heap_sort_cmp(data, a, b, cmp)
|
||||
return
|
||||
}
|
||||
max_depth -= 1;
|
||||
mlo, mhi := do_pivot(data, a, b, cmp);
|
||||
max_depth -= 1
|
||||
mlo, mhi := do_pivot(data, a, b, cmp)
|
||||
if mlo-a < b-mhi {
|
||||
_quick_sort_cmp(data, a, mlo, max_depth, cmp);
|
||||
a = mhi;
|
||||
_quick_sort_cmp(data, a, mlo, max_depth, cmp)
|
||||
a = mhi
|
||||
} else {
|
||||
_quick_sort_cmp(data, mhi, b, max_depth, cmp);
|
||||
b = mlo;
|
||||
_quick_sort_cmp(data, mhi, b, max_depth, cmp)
|
||||
b = mlo
|
||||
}
|
||||
}
|
||||
if b-a > 1 {
|
||||
// Shell short with gap 6
|
||||
for i in a+6..<b {
|
||||
if cmp(data[i], data[i-6]) == .Less {
|
||||
swap(data, i, i-6);
|
||||
swap(data, i, i-6)
|
||||
}
|
||||
}
|
||||
_insertion_sort_cmp(data, a, b, cmp);
|
||||
_insertion_sort_cmp(data, a, b, cmp)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -586,7 +586,7 @@ _quick_sort_cmp :: proc(data: $T/[]$E, a, b, max_depth: int, cmp: proc(i, j: E)
|
||||
_insertion_sort_cmp :: proc(data: $T/[]$E, a, b: int, cmp: proc(i, j: E) -> Ordering) {
|
||||
for i in a+1..<b {
|
||||
for j := i; j > a && cmp(data[j], data[j-1]) == .Less; j -= 1 {
|
||||
swap(data, j, j-1);
|
||||
swap(data, j, j-1)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -594,33 +594,33 @@ _insertion_sort_cmp :: proc(data: $T/[]$E, a, b: int, cmp: proc(i, j: E) -> Orde
|
||||
@(private)
|
||||
_heap_sort_cmp :: proc(data: $T/[]$E, a, b: int, cmp: proc(i, j: E) -> Ordering) {
|
||||
sift_down :: proc(data: T, lo, hi, first: int, cmp: proc(i, j: E) -> Ordering) {
|
||||
root := lo;
|
||||
root := lo
|
||||
for {
|
||||
child := 2*root + 1;
|
||||
child := 2*root + 1
|
||||
if child >= hi {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if child+1 < hi && cmp(data[first+child], data[first+child+1]) == .Less {
|
||||
child += 1;
|
||||
child += 1
|
||||
}
|
||||
if cmp(data[first+root], data[first+child]) >= .Equal {
|
||||
return;
|
||||
return
|
||||
}
|
||||
swap(data, first+root, first+child);
|
||||
root = child;
|
||||
swap(data, first+root, first+child)
|
||||
root = child
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
first, lo, hi := a, 0, b-a;
|
||||
first, lo, hi := a, 0, b-a
|
||||
|
||||
for i := (hi-1)/2; i >= 0; i -= 1 {
|
||||
sift_down(data, i, hi, first, cmp);
|
||||
sift_down(data, i, hi, first, cmp)
|
||||
}
|
||||
|
||||
for i := hi-1; i >= 0; i -= 1 {
|
||||
swap(data, first, first+i);
|
||||
sift_down(data, lo, i, first, cmp);
|
||||
swap(data, first, first+i)
|
||||
sift_down(data, lo, i, first, cmp)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user