十大经典排序

极力推荐 跟小吴师兄学算法

冒泡

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

• 针对所有的元素重复以上的步骤，除了最后一个。

• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

func BubbleSort(l []int)[]int{
	n := len(l)-1
	for i:=0;i<n;i++{
		for j:=0;j<n-i;j++{
			if l[j] > l[j+1]{
				l[j],l[j+1]=l[j+1],l[j]
			}
		}
	}
	return l
}

选择

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

• 重复第二步，直到所有元素均排序完毕。

func SelectSort(l []int)[]int{
	n := len(l)-1
	for i:=0;i<n;i++{
		min := l[i]
		for j:=i+1;j<n;j++{
			if min > l[i]{
				min = j
			}
		}
		if(min != i){
			min,l[i] = l[i],min
		}
	}
	return l
}

插入

• 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

• 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面

func InsertSort(l []int)[]int{
	n := len(l)
	for i:=1;i<n;i++{
		min := l[i]
		for(i>0&&min<l[i-1]){
			min,l[i-1]=l[i-1],min
			i--
		}
	}
}

希尔

• 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

func HillSort(l []int)[]int{
	n := len(l)
	gap := 1
	for gap<n{
		gap = gap*3+1
	}
	for gap>0{
		for i:=gap;i<n;i++{
			tmp := l[i]
			j := i-gap
			for j>0 && l[j]>tmp{
				l[j],tmp = tmp,l[j]
				j-=gap
			}
		}
		gap /= 3
	}
	return l
}

归并

• 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

• 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

• 重复步骤 2 直到某一指针达到序列尾；

• 将另一序列剩下的所有元素直接复制到合并序列尾。

思想参考

//go
//递归，自顶向下
func MergeSorter(l []int){
	MergeSort(l,0, len(l))
}
func MergeSort(l []int,low int,high int)[]int{
	mid := high/2
	MergeSort(l,low,mid)
	MergeSort(l,mid+1,high)
	return merge(l,low,mid,high)
}
//非递归，自底向上
func MergeSort1(l []int){
	for i:=1;i<len(l);i*=2{
		for low:=0;low<len(l);low+=2*i{
			merge(l, low, low+i, math.Min(low+2*i-1,len(l)))
		}
	}
}

// 通过low,mid height 将[low:mid) [mid:height)提取出来
func merge(s []int,low int,mid int,high int)(result []int){
	left := s[low:mid]
	right := s[mid:high]
	l,r := 0,0
	for len(left)>0 && len(right)>0{
		if left[0] <= right[0]{
			result = append(result,left[0])
			l++
		}else{
			result = append(result,right[0])
			r++
		}
	}
	for len(left)>0{
		result = append(result,left...)
	}
	for len(right)>0{
		result = append(result,right...)
	}
	return
}

#python 递归
def merge(a, b):
    c = []
    i = j = 0
    while i < len(a) and j < len(b):
        if a[i] < b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
    while i < len(a):
        c.append(a[i])
        i += 1
    while j < len(b):
        c.append(b[j])
        j += 1
    return c

def merge_sort(lists):
    if len(lists) <= 1:
        return lists
    middle = len(lists) // 2
    left = merge_sort(lists[:middle])
    right = merge_sort(lists[middle:])
    return merge(left, right)



#python 非递归
def merge(seq, low, mid, high):
    left = seq[low: mid]
    right = seq[mid: high]
    k = 0 
    j = 0
    result = []
    while k < len(left) and j < len(right):
        if left[k] <= right[j]:
            result.append(left[k])
            k += 1
        else:
            result.append(right[j])
            j += 1
    result += left[k:]
    result += right[j:]
    seq[low: high] = result

def merge_sort(seq):
    i = 1 # i是步长
    while i < len(seq):
        low = 0
        while low < len(seq):
            mid = low + i #mid前后均为有序
            high = min(low+2*i,len(seq))
            if mid < high: 
                merge(seq, low, mid, high)
            low += 2*i
        i *= 2

快排

• 从数列中挑出一个元素，称为 “基准”（pivot）;

• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

//递归
func QuickSort(l []int){
	n := len(l)-1
	pivot := l[0]
	i:=0;j:=n
	for i<j {
		for pivot > l[i] && i < j {
			j--
		}
		for pivot < l[i] && i < j {
			i++
		}
		l[i], l[j] = l[j], l[i]
	}
	QuickSort(l[:i])
	QuickSort(l[i:])
}
//非递归
import "container/list"
func QuickSort(s []int){
	stack := list.New()
	stack.PushBack(len(s)-1)
	stack.PushBack(0)
	for stack.Len() != 0{
		l := (stack.Back().Value).(int)
		r := (stack.Back().Value).(int)
		index := partition(s,l,r)
		if l < index{
			stack.PushBack(index-1)
			stack.PushBack(l)
		}
		if l > index{
			stack.PushBack(r)
			stack.PushBack(index+1)
		}
	}

}
func partition(s []int,start int, end int)int{
	pivot := s[start]
	for start < end{
		for start < end && s[end] >= pivot{end--}
		s[start] = s[end]
		for start < end && s[start] <= pivot{start++}
		s[end] = s[start]
	}
	s[start] = pivot
	return start
}

堆排序

堆排序是一种选择排序
用堆排解决top_k问题

• 创建一个堆 H[0……n-1]；

• 把堆首（最大值）和堆尾互换；

• 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

• 重复步骤 2，直到堆的尺寸为 1。

//
func HeapSort(s []int){
	n := len(s)
	for root:=n/2;root>=0;root--{
		minHeap(root, n, s)
	}
	for end:=n;end>=0;end--{
		if s[0] < s[end]
		s[0],s[end] = s[end],s[0]
		minHeap(0, end-1, s)
	}
}
func minHeap(root int, end int,s []int)  {
	for{
		child := 2*root + 1
		if child > end{break} //判断是否存在child节点
		if child+1 <= end && s[child]>s[child+1]{child++}
		if s[root] > s[child]{
			s[root],s[child]=s[child],s[root]
		}else{break}
	}
}

计数排序

• 花O(n)的时间扫描一下整个序列 A，获取最小值 min 和最大值 max

• 开辟一块新的空间创建新的数组 B，长度为 ( max – min + 1)

• 数组 B 中 index 的元素记录的值是 A 中某元素出现的次数

• 最后输出目标整数序列，具体的逻辑是遍历数组 B，输出相应元素以及对应的个数

func CountSort(l []int)[]int{
	max_num := l[0]
	for i:=1;i<len(l);i++{
		if max_num < l[i]{max_num=l[i]}
	}
	s := make([]int,max_num)
	for j:=0;j<len(l);j++{
		s[l[j]]++
	}
	index := 0
	for value,key := range s{
		for key>0{
			l[index] = value
			index++
		}
	}
	return l
}

桶排序

• 设置固定数量的空桶。

• 把数据放到对应的桶中。

• 对每个不为空的桶中数据进行排序。

• 拼接不为空的桶中数据，得到结果

func BucketSort(l []int,buckeSize int)[]int{
	min := l[0]; max := l[0]
	for i:=0;i<len(l);i++{
		if min > l[i]{min = l[i]}
		if max < l[i]{max = l[i]}
	}

	BucketCount := (max-min)/buckeSize+1
	buckets := make([][]int,BucketCount)
	//将数据分配到各个桶中
	for j:=0;j<len(l);j++{
		index := (l[j]-min)/buckeSize
		buckets[index] = append(buckets[index],l[j])
		//堆每个进入桶的数据进行插入拍寻
		k := len(buckets[index])-2
		for k>=0 && l[j]<buckets[index][k]{
			buckets[index+1] = buckets[index]
			k--
		}
		buckets[index][k+1] = l[j]
	}
	u := 0
	for m,n := range buckets{
		for t:=0;t<len(n);t++{
			l[u] = buckets[m][t]
		}
	}
	return l
}

基数排序

• 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零

• 从最低位开始，依次进行一次排序

• 从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列

import (
	"math"
	"strconv"
)
func RadixSort(l []int){
	max := l[0]
	for i:=0;i<len(l);i++{
		if max < l[i]{max=l[i]}
	}
	//按照基数思路将数据装进桶子中
	for j:=0;j<len(strconv.Itoa(max));j++{
		bucket := make([][]int, 10)
		for k:=0;k<len(l);k++{
			n := l[k]/int(math.Pow(10,float64(j)))%10
			bucket[n] = append(bucket[n],l[k])
		}
		//桶子
		u := 0 
		for p :=0; p<len(bucket);p++{
			for q:=0;q<len(bucket[p]);q++{
				l[u] = bucket[p][q]
				u++
			}
		}
	}
}