Example #1
0
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
}
Example #2
0
// 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)
		}
	}
}
Example #3
0
func reverse(data sort.Interface, a, b int) {
	for a < b {
		data.Swap(a, b)
		a++
		b--
	}
}
Example #4
0
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)
		}
	}
}
func heapSort(a sort.Interface) {
	helper := HeapHelper{a, a.Len()}
	heap.Init(&helper)
	for helper.length > 0 {
		heap.Pop(&helper)
	}
}
Example #6
0
// 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)
}
Example #7
0
File: cmp.go Project: jesand/crowds
// 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)
	}
}
Example #8
0
// 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 Sort(data sort.Interface) {
	done := make(chan bool)

	go parallelQuickSort(data, 0, data.Len()-1, done)

	<-done
}
// 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)
		}
	}
}
Example #11
0
func xcopy(data sort.Interface, i, j, k, l int) int {
	for i < k && j < l {
		data.Swap(i, j)
		i, j = i+1, j+1
	}
	return i
}
Example #12
0
// 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++
	}
}
Example #13
0
func reverse(seq sort.Interface, firstIndex int) {
	lastIndex := seq.Len() - 1

	numSwap := (lastIndex - firstIndex + 1) / 2
	for i := 0; i < numSwap; i++ {
		seq.Swap(firstIndex+i, lastIndex-i)
	}
}
Example #14
0
// Shuffle sorts data in a randomized order. It uses the default
// Source in math/rand, so if clients want to manipulate the outcome,
// they should call the appropriate functions in math/rand.
//
// TODO: Add ability to use custom Sources.
func Shuffle(data sort.Interface) {
	length := data.Len()

	for i := 0; i < length; i++ {
		i2 := rand.Intn(i + 1)
		data.Swap(i, i2)
	}
}
Example #15
0
File: sort.go Project: kho/easy
func NewWithIndex(sorter sort.Interface) *WithIndex {
	n := sorter.Len()
	newToOld := make([]int, n)
	for i := range newToOld {
		newToOld[i] = i
	}
	return &WithIndex{sorter, newToOld}
}
Example #16
0
// Flip reverses the order of items in a sort.Interface.
func Flip(data sort.Interface) {
	a, b := 0, data.Len()-1
	for b > a {
		data.Swap(a, b)
		a++
		b--
	}
}
Example #17
0
// 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
}
Example #18
0
// NewSub opaquely wraps a sub-sequence of the provided sort.Interface.
// NewSub(s,i,j) is semantically equivalent to s[i:j], though the underlying
// implementation does not need to use a slice.
// NewSub will panic unless 0 <= i <= j <= s.Len().
func NewSub(s sort.Interface, i, j int) sort.Interface {
	if i < 0 || j < i || j > s.Len() {
		panic(panicmsg)
	} else if v, ok := s.(sub); ok {
		// collapse subs of subs
		return sub{v.s, v.i + i, j - i}
	}
	return sub{s, i, j - i}
}
Example #19
0
func palindrome(s sort.Interface) bool {
	last := s.Len() - 1
	for i := 0; i < last/2; i++ {
		if !equals(s, i, last-i) {
			return false
		}
	}
	return true
}
Example #20
0
// NewProxy sorts comp, duplicating all swaps on each item of data.
// NewProxy will panic if any item in data has a different Len() than comp.
func NewProxy(comp sort.Interface, data ...sort.Interface) sort.Interface {
	l := comp.Len()
	for _, d := range data {
		if l != d.Len() {
			panic(panicmsg)
		}
	}
	return proxy{comp, data}
}
Example #21
0
// "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
}
Example #22
0
func IsPalindrome(s sort.Interface) bool {
	max := s.Len() - 1
	for i := 0; i < s.Len()/2; i++ {
		if !equal(i, max-i, s) {
			return false
		}
	}
	return true
}
Example #23
0
func sortStable(s sort.Interface) {
	ss := stableSort{
		s:   s,
		pos: make([]int, s.Len()),
	}
	for i := range ss.pos {
		ss.pos[i] = i
	}
	sort.Sort(&ss)
}
Example #24
0
// Quicksort performs a parallel quicksort on data.
func Quicksort(data sort.Interface) {
	a, b := 0, data.Len()
	n := b - a
	maxDepth := 0
	for i := n; i > 0; i >>= 1 {
		maxDepth++
	}
	maxDepth *= 2
	parallelSort(data, quickSortWorker, task{-maxDepth - 1, a, b})
}
Example #25
0
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
	}
}
Example #26
0
// Sort sorts data.
// It makes one call to data.Len to determine n, and O(n*log(n)) calls to
// data.Less and data.Swap. The sort is not guaranteed to be stable.
func Sort(data sort.Interface) {
	// Switch to heapsort if depth of 2*ceil(lg(n+1)) is reached.
	n := data.Len()
	maxDepth := 0
	for i := n; i > 0; i >>= 1 {
		maxDepth++
	}
	maxDepth *= 2
	quickSort(data, 0, n, maxDepth, nil)
}
Example #27
0
// NewStat initializes a *Stat for recording per-element call counts.
// NewStat makes a call to data.Len.
func NewStat(data sort.Interface) *Stat {
	l := 0
	if log, ok := data.(*Log); ok {
		l = log.I.Len()
	} else {
		l = data.Len()
	}
	return &Stat{
		I: data,
		O: make([]struct{ Less, Swap int }, l),
	}
}
Example #28
0
// SymDiff performs an in-place symmetric difference on the two sets
// [0:pivot] and [pivot:Len]; the resulting set will occupy [0:size].
// SymDiff is both associative and commutative.
func SymDiff(data sort.Interface, pivot int) (size int) {
	// BUG(extemporalgenome): SymDiff currently uses a multi-pass implementation

	i := Inter(data, pivot)
	l := data.Len()
	b := boundspan{data, span{i, l}}
	sort.Sort(b)
	size = Uniq(b)
	slide(data, 0, i, size)
	l = i + size
	sort.Sort(boundspan{data, span{size, l}})
	return Diff(data, size)
}
Example #29
0
// parallelSort calls the sorters with an asyncSort function that will hand
// the task off to another goroutine when possible.
func parallelSort(data sort.Interface, sorter sortFunc, initialTask task) {
	max := runtime.GOMAXPROCS(0)
	if MaxProcs > 0 && MaxProcs < max {
		max = MaxProcs
	}
	l := data.Len()
	if l < minParallel {
		max = 1
	}

	var syncSort func(t task)
	syncSort = func(t task) {
		sorter(data, t, syncSort)
	}
	if max == 1 {
		syncSort(initialTask)
		return
	}

	wg := new(sync.WaitGroup)
	// buffer up one extra task to keep each cpu busy
	sorts := make(chan task, int(float32(max)*bufferRatio))
	var asyncSort func(t task)
	asyncSort = func(t task) {
		if t.end-t.pos < minOffload {
			sorter(data, t, syncSort)
			return
		}
		wg.Add(1)
		select {
		case sorts <- t:
		default:
			sorter(data, t, asyncSort)
			wg.Done()
		}
	}
	doSortWork := func() {
		for task := range sorts {
			sorter(data, task, asyncSort)
			wg.Done()
		}
	}
	for i := 0; i < max; i++ {
		go doSortWork()
	}

	asyncSort(initialTask)

	wg.Wait()
	close(sorts)
}
Example #30
0
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)

}