// Simple insertion sort for smaller data collections.
func insertionSort(data sort.Interface, lo, hi int) {
for i := lo + 1; i < hi+1; i++ {
for j := i; j > lo && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
// Partial quicksort algorithm due to Martínez (2004),
// http://www.cs.upc.edu/~conrado/research/reports/ALCOMFT-TR-03-50.pdf
func partialSort(data sort.Interface, k, lo, hi int) {
for hi-lo > 5 {
p := medianOfThree(data, lo, hi)
p = partition(data, lo, hi, p)
if p < k-1 {
partialSort(data, k, p+1, hi)
}
hi = p
}
// Finish off with a selection sort.
if hi-lo-1 < k {
k = hi - lo - 1
}
for ; k > 0; k-- {
min := lo
for i := lo + 1; i < hi; i++ {
if data.Less(i, min) {
min = i
}
}
data.Swap(lo, min)
lo++
}
}
// InsertionSort 插入排序，时间复杂度O(n^2)。
//
// 这个实现是拷贝的sort包下的 insertionSort()。
func InsertionSort(data sort.Interface, start, end int) {
for i := start + 1; i < end; i++ {
for j := i; j > start && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
// HeapSort sorts given data and has next properties:
//
// - Not stable
// - O(1) extra space
// - O(n*lg(n)) time
// - Not really adaptive
//
func HeapSort(data sort.Interface) {
// down restores order of heap.
down := func(root, n int) {
for {
lch := 2*root + 1
if lch >= n || lch < 0 { // child < 0 when int overflow.
break
}
if rch := lch + 1; rch < n && data.Less(lch, rch) { // lch+1 == 2*root + 2 // Right child.
lch = rch
}
if !data.Less(root, lch) { // Heap is ordered.
return
}
data.Swap(root, lch)
root = lch
}
}
// Heapify (build a max heap).
for i := (data.Len() - 1) / 2; i >= 0; i-- {
down(i, data.Len())
}
// Pop elements, largest first, into end of data.
// Loop invariant: data[i:] contains the data.Len()-1-i largest elements
// of maxHeap and the maxHeap contains i+1 smallest elements.
for i := data.Len() - 1; i >= 0; i-- {
data.Swap(0, i)
down(0, i)
}
}
func isort(A sort.Interface, a, b int) {
for j := a + 1; j < b; j++ {
for i := j; i > a && A.Less(i, i-1); i-- {
A.Swap(i, i-1)
}
}
}
// partition the subarray a[lo .. hi] by returning an index j
// so that a[lo .. j-1] <= a[j] <= a[j+1 .. hi]
func partition(a sort.Interface, lo, hi int) int {
i, j := lo+1, hi
// v = a[lo]
for {
for a.Less(i, lo) {
if i == hi {
break
}
i++
}
for a.Less(lo, j) {
if j == lo {
break
}
j--
}
if i >= j {
break
}
a.Swap(i, j)
i++
j--
}
// put v = a[j] into position
a.Swap(lo, j)
// with a[lo .. j-1] <= a[j] <= a[j+1 .. hi]
return j
}
// Insert adds in-order element of sort.Interface at index Tree.Len()
// It doesn't check for equality, so duplicates are inserted in
// stable order.
func (t *Tree) Insert(data sort.Interface) {
ix := len(t.nodes)
if ix == MaxSize {
panic("tree size exceed maximum")
}
t.nodes = append(t.nodes, node{null, null, null, 1})
if ix == 0 {
t.root, t.min, t.max = 0, 0, 0
return
}
var dir direction
cur := t.root
curnode := &t.nodes[cur]
for {
dir = direction(!data.Less(ix, int(cur)))
if curnode.link(dir) == null {
break
}
cur = curnode.link(dir)
curnode = &t.nodes[cur]
}
node := &t.nodes[ix]
node._parent = index(cur)
curnode.set_link(dir, ix)
if dir == right {
if cur == t.max {
t.max = ix
}
} else if cur == t.min {
t.min = ix
}
t.balance(cur)
}
func check(t *testing.T, data sort.Interface, tree *Tree, ix int) int8 {
node := &tree.nodes[ix]
l, r := int(node._left), int(node._right)
var lh, rh int8
if l != null {
if data.Less(ix, l) {
t.Fatalf("%d < %d", ix, l)
}
lh = check(t, data, tree, l)
} else {
lh = 0
}
if r != null {
if data.Less(r, ix) {
t.Fatalf("%d < %d", r, ix)
}
rh = check(t, data, tree, r)
} else {
rh = 0
}
bal := lh - rh
if bal < -1 || bal > 1 || tree.bal(ix) != bal {
t.Fatalf("height fails: %d [%d, %d]",
ix, lh, rh)
}
return max_i8(lh, rh) + 1
}
// TimSort sorts the data defined by sort.Interface.
func TimSort(a sort.Interface) (err error) {
indexes := make([]int, a.Len())
for i := 0; i < len(indexes); i++ {
indexes[i] = i
} // for i
err = Ints(indexes, func(i, j int) bool {
return a.Less(i, j)
})
if err != nil {
return err
} // if
for i := 0; i < len(indexes); i++ {
j := indexes[i]
if j == 0 {
continue
} // if
for k := i; j != i; {
a.Swap(j, k)
k, j, indexes[j] = j, indexes[j], 0
} // for j
} // for i
return nil
}
func insertionSort(a sort.Interface) {
for i := 1; i < a.Len(); i++ {
for j := i; j > 0 && a.Less(j, j-1); j-- {
a.Swap(j-1, j)
}
}
}
// Insertion sort
func insertionSort(data sort.Interface, a, b int) {
for i := a + 1; i < b; i++ {
for j := i; j > a && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
func Quicksort(sortable sort.Interface) {
partition := func(sortable sort.Interface, lo, hi int) int {
pivot := hi
i := lo
for j := lo; j < hi; j++ {
if sortable.Less(j, pivot) {
sortable.Swap(i, j)
i++
}
}
sortable.Swap(i, hi)
return i
}
var quicksortRecursive func(sortable sort.Interface, lo, hi int)
quicksortRecursive = func(sortable sort.Interface, lo, hi int) {
if lo < hi {
p := partition(sortable, lo, hi)
quicksortRecursive(sortable, lo, p-1)
quicksortRecursive(sortable, p+1, hi)
}
}
quicksortRecursive(sortable, 0, sortable.Len()-1)
}
// Make a random comparison with certain probability of correctness
func randLess(i, j int, cmp sort.Interface, pCorrect float64) bool {
if rand.Float64() <= pCorrect {
return cmp.Less(i, j)
} else {
return !cmp.Less(i, j)
}
}
// InsertionSort performs a simple insertion sort on the sort interface. In the
// case of ByDist it performs generally as fast as sort.Sort() except that it
// can exploit temporal coherence improving performance dramatically when the
// objects have not moved much.
func InsertionSort(data sort.Interface) {
for i := 0; i < data.Len(); i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
// Insertion sort
func Insertion(a sort.Interface) {
for i := 2; i < a.Len(); i++ {
// insert a[j] into sorted slice a[0:j]
for j := i; j > 0 && a.Less(j, j-1); j-- {
a.Swap(j, j-1)
}
}
}
func insertSort(data sort.Interface) {
r := data.Len() - 1
for i := 1; i <= r; i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
func Insertion(c sort.Interface) {
var l = c.Len()
for i := 1; i < l; i++ {
for j := i; j > 0 && c.Less(j, j-1); j-- {
c.Swap(j, j-1)
}
}
}
func IsPalindrome(s sort.Interface) bool {
for i, j := 0, s.Len()-1; i < j; i, j = i+1, j-1 {
if s.Less(i, j) || s.Less(j, i) {
return false
}
}
return true
}
// Insertion sort
func insertionSort(data sort.Interface) {
n := data.Len()
for i := 1; i < n; i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
// Proposition. For randomly ordered arrays of length N with with distinct keys,
// insertion sort uses ~N2/4 compares and ~N2/4 exchanges on the average.
// The worst case is ~ N2/2 compares and ~ N2/2 exchanges and the best case is N-1 compares and 0 exchanges.
func InsertionSort(a sort.Interface) {
n := a.Len()
for i := 1; i < n; i++ {
for j := i; j > 0 && a.Less(j, j-1); j-- {
a.Swap(j, j-1)
}
}
}
// IsUniqued reports whether the elements in data are sorted and unique.
func IsUniqued(data sort.Interface) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if !data.Less(i-1, i) {
return false
}
}
return true
}
// "sort" package has "IsSorted" function, but no "IsReversed";
func isReversed(data sort.Interface) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if !data.Less(i, i-1) {
return false
}
}
return true
}
func IsPalindrome(s sort.Interface) bool {
len := s.Len()
for i := 0; i < len/2; i++ {
if s.Less(i, len-(i+1)) || s.Less(len-(i+1), i) {
return false
}
}
return true
}
func IsPalindrome(s sort.Interface) bool {
for i := 0; i < s.Len()/2; i++ {
j := s.Len() - (i + 1)
if s.Less(i, j) || s.Less(j, i) {
return false
}
}
return true
}
func bubbleSort(data sort.Interface) {
r := data.Len() - 1
for i := 0; i < r; i++ {
for j := r; j > i; j-- {
if data.Less(j, j-1) {
data.Swap(j, j-1)
}
}
}
}
// BubbleSort implementation
func Bubble(a sort.Interface) {
for i := 0; i < a.Len(); i++ {
for j := a.Len() - 1; j > i; j-- {
if a.Less(j, j-1) {
a.Swap(j, j-1)
}
}
}
}
func up(h sort.Interface, left int) {
for {
parent := (left - 1) / 2 // parent
if parent == left || !h.Less(left, parent) {
break
}
h.Swap(parent, left)
left = parent
}
}
func isPalindrome(s sort.Interface) bool {
maxIndex := s.Len() - 1
for i := 0; i < maxIndex/2; i++ {
if !s.Less(i, maxIndex-i) && !s.Less(maxIndex-i, i) {
continue
}
return false
}
return true
}
// InsertionSort sorts given data and has next properties:
//
// - Stable
// - O(1) extra space
// - O(n*n) comparisons and swaps
// - Adaptive: O(n) time when nearly sorted
// - Very low overhead
//
func InsertionSort(data sort.Interface) {
// Loop invariant: at the start of each iteration, the data[0:i] consist
// of the elements originally in data[0:i], but in sorted order.
for i := 1; i < data.Len(); i++ {
// Loop invariant: data[k:i] will have the smallest element on position k.
for k := i; k > 0 && data.Less(k, k-1); k-- {
data.Swap(k, k-1)
}
}
}
func IsPalindrome(s sort.Interface) bool {
for i, j := 0, s.Len()-1; i < s.Len() || j > 0; i, j = i+1, j-1 {
if !s.Less(i, j) && !s.Less(j, i) { // equal
continue
} else {
return false
}
}
return true
}
