常用的排序算法各种语言相同，这里大致介绍下go的常用排序，废话不多说，直入正题：

冒泡排序

package main

import (
   "fmt"
)

func bubbleSort(slice []int) []int {
   for n := 0; n <= len(slice); n++ {
      for i := 1; i < len(slice)-n; i++ {
         if slice[i] < slice[i-1] {
            slice[i], slice[i-1] = slice[i-1], slice[i]
         }
      }
   }
   return slice
}

func main() {
   var arr = [...]int{99, 51, 41, 2, 31}
   var rarr = bubbleSort(arr[:])
   fmt.Println(rarr) // 从小到大[2 31 41 51 99]
}

比较排序

package main

import (
   "fmt"
)

func selectionSort(slice []int) []int {
   for n := 0; n <= len(slice); n++ {
      for i := n + 1; i < len(slice); i++ {
         if slice[n] > slice[i] {
            slice[n], slice[i] = slice[i], slice[n]
         }
      }
   }
   return slice
}

func main() {
   var arr = [...]int{99, 51, 41, 2, 31}
   var rarr = selectionSort(arr[:])
   fmt.Println(rarr)
}

插入排序

    思路：将数组拆分为一个有序的，一个无序的。初始时下标0永远为有序数组。

    建立循环，从下标1开始到数组的长度，每个都与前一个进行对比，如果比前一个值小，就互相换位，当当前值比上一个值大时，说明当前值之前都是已经排序好的数组。就退出。

    例子：如该数组[...]int{10, 56, 4, 654, 8, 997}，

    第一次循环时，n=1 i=1 56 > 10跳出。

    第二次循环时，{10, 56, 4, 654, 8, 997} n=2 i=n=2， 4<56互换，值为{10, 4, 56, 654, 8, 997}，内部循环继续进行，i=1 4<10互换为[4 10 56 654 8 997]。内部循环结束，条件为i<0 

package main

import (
   "fmt"
)

func insertSort(arr []int) {
   for n := 1; n < len(arr); n++ {
      for i := n; i > 0; i-- {
         if arr[i] > arr[i-1] {
            break
         }
         arr[i], arr[i-1] = arr[i-1], arr[i]
      }
   }
}

func main() {
   var array = [...]int{10, 56, 4, 654, 8, 997}
   insertSort(array[:])

   fmt.Println(array)
}

快速排序

思路：以一个基准数将数组拆分为两个，一边大于这个数，一边小于这个数。从数组第0个开始，首先先记录此基准数的下标和值  {312, 84, 543, 5, 100, 23} ，k=0 v=312。需要传入一个从哪里开始到哪里的位置。这里基准数为第一个，顾循环位置就从0+1开始 循环完之后为 84 84 543 5 100 23 。

package main

import (
   "fmt"
)

func qsort(arr []int, start int, end int) {
   if start >= end {
      return
   }

   key := start
   value := arr[start] //记录当前基准值位置
   for n := start + 1; n <= end; n++ {
      // a[n] < arr[start]
      if arr[n] < value {
         arr[key] = arr[n]   //就将a[n]挪至arr[key]所在位置
         arr[n] = arr[key+1] //a[n]空缺了，将arr[key]向后移动一位
         // 理论上现在值为这个 {84, 84, 543, 5, 100, 23}
         key++ //key的位置改变了1位，key++
         //最后在将进位后的arr[key] = 之前保存的value即为
         // value=321 {84, 312, 543, 5, 100, 23}
         //这样完成了替换
      }
   }

   arr[key] = value
   //一轮循环后该数组为[84 5 100 23 312 543]
   //将基准数两边的数进行进行排序 此时 key=3 start=0 左边为 start-key-1
   qsort(arr, start, key-1)
   qsort(arr, key+1, end) //右边为key+1-end
}

func main() {
   var array = [...]int{312, 84, 543, 5, 100, 23}
   qsort(array[:], 0, len(array)-1)
   fmt.Println(array)
}
//输出[5 23 84 100 312 543]

排序思路算法几乎一样。十大经典排序算法暂时就介绍这几种了。