golang 常用的排序

• 冒泡排序

  func BubblingSort(slice []int,method bool) [] int{
      for i:=0;i<len(slice)-1;i++{
  
          for j:=0;j<len(slice) -i-1;j++ {
  
              if method {
                  if slice[j] < slice[j+1]{
                      slice[j],slice[j+1] = slice[j+1],slice[j]
                  }
              }else{
                  if slice[j] > slice[j +1]{
                      slice[j],slice[j+1] = slice[j+1],slice[j]
                  }
              }
          }
  
      }
  
      return slice
  }

• 选择排序

  func ChoiceSort(slice []int,method bool) []int {
      for i:=0;i<len(slice) -1;i++{
  
          var template = [...]int{i,slice[i]}
  
          for j:=i+1;j<len(slice);j++{
  
              if method {
                  if slice[j] < template[1] {
                      template[0] = j
                      template[1] = slice[j]
                  }
              }else {
                  if slice[j] > template[1] {
                      template[0] = j
                      template[1] = slice[j]
                  }
              }
          }
  
          slice[i],slice[template[0]] = slice[template[0]],slice[i]
      }
  
      return slice
  }

•  插入排序

  func InsertSort(slice []int,method bool) []int {
      for i :=0;i<len(slice) -1;i++ {
          for j:=0;j<i+1;j++{
              if method{
                  if slice[i+1-j] <slice[i-j]{
                      slice[i+1-j],slice[i-j] = slice[i-j],slice[i-j+1]
                  }
              }else {
                  if slice[i+1-j] >slice[i-j]{
                      slice[i+1-j],slice[i-j] = slice[i-j],slice[i-j+1]
                  }
              }
          }
      }
  
      return slice
  }　　
  
  //二分查找

  func BinaryFind(slice []int,val int,leftIndex int,rightIndex int)  bool {
     if leftIndex > rightIndex {
        return false
     }
  
     middleIndex := (leftIndex + rightIndex) / 2
  
     if slice[middleIndex] == val{
        return true
     }else if slice[middleIndex] < val {
        return BinaryFind(slice,val,middleIndex+1,rightIndex)
     }else {
        return BinaryFind(slice,val,leftIndex,middleIndex-1)
     }
  }