go 排序sort的使用详解编程语言

func Sort(data 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) 
} 
 
func quickSort(data Interface, a, b, maxDepth int) { 
	for b-a > 12 { // Use ShellSort for slices <= 12 elements 
		if maxDepth == 0 { 
			heapSort(data, a, b) 
			return 
		} 
		maxDepth-- 
		mlo, mhi := doPivot(data, a, b) 
		// Avoiding recursion on the larger subproblem guarantees 
		// a stack depth of at most lg(b-a). 
		if mlo-a < b-mhi { 
			quickSort(data, a, mlo, maxDepth) 
			a = mhi // i.e., quickSort(data, mhi, b) 
		} else { 
			quickSort(data, mhi, b, maxDepth) 
			b = mlo // i.e., quickSort(data, a, mlo) 
		} 
	} 
	if b-a > 1 { 
		// Do ShellSort pass with gap 6 
		// It could be written in this simplified form cause b-a <= 12 
		for i := a + 6; i < b; i++ { 
			if data.Less(i, i-6) { 
				data.Swap(i, i-6) 
			} 
		} 
		insertionSort(data, a, b) 
	} 
} 

package main 
 
import ( 
    "sort"    
) 
 
type subInfo struct { 
	Count  uint   `json:"count"` 
} 
 
type SubList []*subInfo 
 
func (p SubList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] } 
func (p SubList) Len() int           { return len(p) } 
func (p SubList) Less(i, j int) bool { return p[i].Count > p[j].Count } 
 
func main() { 
	st_list := SubList{} 
	for i := 0; i < 10; i ++{ 
		_sub := &subInfo{ 
			Count:  uint(i), 
		} 
		st_list = append(st_list, _sub) 
	} 
	sort.Sort(st_list) 
	return 
}