排序算法

·  阅读 92

各个排序的复杂度

src=http___image.bubuko.com_info_202002_20200211144849675446.png&refer=http___image.bubuko.jpeg

1. 选择排序

执行流程

从序列中找出最小的元素与最前面的交换

实现代码

func main() {
   arr := []int{1,11,3,8,6,22,14,32,16}

   for i := 0; i < len(arr); i++{
      minIndex := i
      for j:=i;j< len(arr);j++{
         if arr[minIndex] > arr[j]{
            minIndex = j
         }
      }
      if minIndex != i{
         arr[i] =arr[i] ^ arr[minIndex]
         arr[minIndex] =arr[i] ^ arr[minIndex]
         arr[i] =arr[i] ^ arr[minIndex]
      }
   }
   fmt.Println(arr)
}
复制代码

2. 插入排序

执行流程

和生活中玩扑克牌的理牌过程类似

实现代码

func main() {
   arr := []int{1,11,3,8,6,22,14,32,16}
   for i := 1; i < len(arr); i++{
      for j:=i;i>=0;j--{
         if arr[j]<arr[j-1]{
            //arr[j],arr[j-1] = arr[j-1],arr[j] go语言编译时会使用临时变量做交换
            arr[j] = arr[j] ^ arr[j-1]
            arr[j-1] = arr[j] ^ arr[j-1]
            arr[j] = arr[j] ^ arr[j-1]
         }else {
            break
         }
      }
   }
   fmt.Println(arr)
}
复制代码

3. 堆排序

执行流程

这里用到了这个数据结构,Go语言里内置包里实现了堆这个数据结构,我们直接可以拿来用,详细的对堆的使用在我的这篇文章中写了详细的使用方式

4. 归并排序

执行流程

归并排序实际上是对分治法的一个利用,将一个大的数组分成小的处理,再合并.难点就在于合并的算法,如果合并的时候需要复制一个数组,复制一半比如说左边的数组这样子是空间复杂度是最优的,但是不太好理解,我最终采取了全复制的策略

实现代码

package main

import "fmt"


func main() {
   arr := []int{3,6,9,11,1,2,4,5}
   fmt.Println(mergeSort(arr))
}
//递归
func mergeSort(arr []int) []int {
   if len(arr) < 2 {
      return arr
   }
   mid := len(arr) >> 1
   left := mergeSort(arr[:mid])
   right := mergeSort(arr[mid:])
   result := merge(left, right)
   return result
}
//合并左右两个有序数组
func merge(left,right []int) []int {
   temp := make([]int, 0)
   i, j := 0, 0
   for i < len(left) && j < len(right) {
      if left[i] <= right[j] {
         temp = append(temp, left[i])
         i++
      } else {
         temp = append(temp, right[j])
         j++
      }
   }
   if i < len(left) {
      temp = append(temp, left[i:]...)
   }
   if j < len(right) {
      temp = append(temp, right[j:]...)
   }
   return temp
}
复制代码

5.休眠排序

执行流程

这种排序就离谱,利用线程的休眠时间进行排序,了解一下就行

6.快速排序

执行流程

快速排序采用了二分递归的思想,通过一趟排序将整个数组划分为两个部分,低位部分的值全部小于高位部分的值,然后对低位和高位部分分别排序

实现代码

func main()  {
   var arr = []int{8,22,13,5,4}
   quickSort(arr,0,len(arr)-1)
   fmt.Println(arr)
}

func quickSort(arr []int, left,right int){
   if left < right{
      index := getIndex(arr,left,right)
      quickSort(arr,left,index-1)
      quickSort(arr,index+1,right)
   }
}

func getIndex(arr []int, left,right int) int {
   pivot := arr[left]

   for left < right{
      for left < right && arr[right] >= pivot {
         right--
      }
      arr[left] = arr[right]

      for left < right && arr[left] < pivot {
         left++
      }
      arr[right] = arr[left]
   }

   arr[left] = pivot
   return left
}
复制代码
分类:
后端
标签:
分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改