Golang基本的四种排序

排序

冒泡排序，选择排序，插入排序，快速排序等…

冒泡排序

冒泡排序(Bubble Sorting）的基本思想是:通过对待排序序列从后向前（从下标较大的元素开始)，依次比较相邻元素的排序码,若发现逆序则交换,使排序码较小的元素逐渐从后部移向前部(从下标较大的单元移向下标较小的单元）,就象水底下的气泡一样逐渐向上冒。

//冒泡排序
func BubbleSort(arr *[5]int) {

   temp := 0 //临时变量
   for j := 0; j < len(*arr)-1; j++ {
      for i := 0; i < len(*arr)-1-j; i++ {
         if (*arr)[i] > (*arr)[i+1] {
            temp = (*arr)[i]
            (*arr)[i] = (*arr)[i+1]
            (*arr)[i+1] = temp
         }
      }
   }
}

选择排序

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，再依原则交换位置后达到排序的目的。

package main

import "fmt"

func SelectSort(arr *[5]int) {
   for i := 0; i < len(arr)-1; i++ {
      max := arr[i]
      maxIndex := i

      for j := i + 1; j < len(arr); j++ {
         if max < arr[j] {
            max = arr[j]
            maxIndex = j
         }
      }
      if maxIndex != i {
         arr[i], arr[maxIndex] = arr[maxIndex], arr[i]
      }
      fmt.Printf("第 %d 次 %v \n", i+1, *arr)
   }

}

func main() {
   arr := [5]int{10, 34, 19, 100, 80}
   SelectSort(&arr)
   fmt.Println(arr)
}

插入排序

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入排序（Insertion Sorting）的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

package main

import "fmt"

func InsertSort(arr *[5]int) {

   for i := 1; i < len(arr); i++ {
      InsertVal := arr[i]
      insertIndex := i - 1

      for insertIndex >= 0 && arr[insertIndex] < InsertVal {
         arr[insertIndex+1] = arr[insertIndex]
         insertIndex--
      }
      if insertIndex+1 != i {
         arr[insertIndex+1] = InsertVal
      }
      fmt.Printf("第 %d 次 插入后  %v \n", i, *arr)
   }

}

func main() {
   arr := [5]int{23, 0, 12, 56, 34}
   InsertSort(&arr)
   fmt.Println(arr)
}

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

package main

import "fmt"

func QuickSort(left int, right int, array *[6]int) {
   l := left
   r := right
   //pivot 是中轴，支点
   pivot := array[(left+right)/2]
   temp := 0

   //for 循环的目标是将比pivot 小的数放到左边
   // 比 pivot 大的数据放到右边
   for l < r {
      for array[l] < pivot {
         l++
      }
      for array[r] > pivot {
         r--
      }
      if l >= r {
         break
      }
      temp = array[l]
      array[l] = array[r]
      array[r] = temp
      if array[l] == pivot {
         r--
      }
      if array[r] == pivot {
         l++
      }
   }
   if l == r {
      l++
      r--
   }
   if left < r {
      QuickSort(left, r, array)
   }
   if right > l {
      QuickSort(l, right, array)
   }
}

func main() {
   arr := [6]int{-9, 78, 100, 65, 87, 11}

   QuickSort(0, len(arr)-1, &arr)
   fmt.Println(arr)
}