选择排序

选择排序

• 算法介绍

  1. 现在有一堆乱序的数，比如：5 9 1 6 8 14 6 49 25 4 6 3
  2. 第一轮迭代，从第一个数开始，左边到右边进行扫描，找到最小的数 1，与数列里的第一个数交换位置。1 5 9 6 8 14 6 49 25 4 6 3
  3. 第二轮迭代，从第二个数开始，左边到右边进行扫描，找到第二小的数 3，与数列里的第二个数交换位置。1 3 9 6 8 14 6 49 25 4 6 5
  4. 第三轮迭代，从第三个数开始，左边到右边进行扫描，找到第三小的数 4，与数列里的第三个数交换位置。1 3 4 6 8 14 6 49 25 9 6 5

• 算法实现

      python版本
      def SelectSort(arr):
          for i in range(len(arr) - 1):
              # 记录最小数的索引
              minIndex = i
              for j in range(i + 1, len(arr)):
                  if arr[j] < arr[minIndex]:
                      minIndex = j
              # i 不是最小数时，将 i 和最小数进行交换
              if i != minIndex:
                  arr[i], arr[minIndex] = arr[minIndex], arr[i]
          return arr
  

  Go版本    
      func SelectSort(nums []int) {
          n := len(nums)
          // 进行 N-1 轮迭代
          for i := 0; i < n-1; i++ {
              // 每次从第 i 位开始，找到最小的元素
              min := nums[i] // 最小数
              minIndex := i  // 最小数的下标
              for j := i + 1; j < n; j++ {
                  if nums[j] < min {
                      // 如果找到的数比上次的还小，那么最小的数变为它
                      min = list[j]
                      minIndex = j
                  }
              }
              // 这一轮找到的最小数的下标不等于最开始的下标，交换元素
              if i != minIndex {
                  nums[i], nums[minIndex] = nums[minIndex], nums[i]
              }
          }
      }
  
      func main() {
          nums := []int{2,7,9,6,4,5,3,1,0}
          SelectSort(list)
      }
  

• 算法改进

  上面的算法需要从某个数开始，一直扫描到尾部，我们可以优化算法，使得复杂度减少一半。我们每一轮，除了找最小数之外，还找最大数，然后分别和前面和后面的元素交换，这样循环次数减少一半

     GO版本
      func SelectGoodSort(list []int) {
          n := len(list)
  
          // 只需循环一半
          for i := 0; i < n/2; i++ {
              minIndex := i // 最小值下标
              maxIndex := i // 最大值下标
  
              // 在这一轮迭代中要找到最大值和最小值的下标
              for j := i + 1; j < n-i; j++ {
                  // 找到最大值下标
                  if list[j] > list[maxIndex] {
                      maxIndex = j // 这一轮这个是大的，直接 continue
                      continue
                  }
                  // 找到最小值下标
                  if list[j] < list[minIndex] {
                      minIndex = j
                  }
              }
  
              if maxIndex == i && minIndex != n-i-1 {
                  // 如果最大值是开头的元素，而最小值不是最尾的元素
                  // 先将最大值和最尾的元素交换ni xi
                  list[n-i-1], list[maxIndex] = list[maxIndex], list[n-i-1]
                  // 然后最小的元素放在最开头
                  list[i], list[minIndex] = list[minIndex], list[i]
              } else if maxIndex == i && minIndex == n-i-1 {
                  // 如果最大值在开头，最小值在结尾，直接交换
                  list[minIndex], list[maxIndex] = list[maxIndex], list[minIndex]
              } else {
                  // 否则先将最小值放在开头，再将最大值放在结尾
                  list[i], list[minIndex] = list[minIndex], list[i]
                  list[n-i-1], list[maxIndex] = list[maxIndex], list[n-i-1]
              }
          }
      }
  
      func main() {
          list := []int{5}
          SelectGoodSort(list)
          fmt.Println(list)
  
          list1 := []int{5, 9}
          SelectGoodSort(list1)
          fmt.Println(list1)
  
          list2 := []int{5, 9, 1}
          SelectGoodSort(list2)
          fmt.Println(list2)
  
          list3 := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
          SelectGoodSort(list3)
          fmt.Println(list3)
  
          list4 := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6}
          SelectGoodSort(list4)
          fmt.Println(list4)
      }