十大经典排序算法之选择排序及其优化

一、简单选择排序

1.基本思想：

在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换；
第二次遍历n-2个数，找到最小的数值与第二个元素交换；
。。。
第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。

2.过程

3.代码

public static void selectSort(int[] arr) {
        int minNum = 0;
        int temp = 0;
        int a = 0;
        for (int i = 0; i < arr.length; i++) {
            boolean flag = false;
            minNum = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (minNum > arr[j]) {
                    minNum = arr[j];
                    a = j;
                    flag = true;
                }
            }
            if (flag) {
                temp = arr[i];
                arr[i] = minNum;
                arr[a] = temp;
            }
        }
    }

4.复杂度分析

选择排序的交换次数介于0~（n-1)之间；
比较次数为n(n-1)/2之间
交换次数远远小于冒泡排序；由于cpu计算时，交换时间大于比较时间，所以当n较小时，选择排序优于冒泡排序。
平均时间复杂度：O(n^2)

5.稳定性分析

当两个相同的数据相邻时，如果一个更小的数据比这两个数据要小，那么就会与这两个数据的第一个进行交换；那么这就破坏了原先数据的有序性，所以不稳定。

二、优化

1.思路

使用两个变量，分别指向数组的头尾；每次遍历数组过程中，找到无序表中的最大值与最小值进行交换

2.代码

public static void selectSort2(int arr[]) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
          int max = right;
          int min = left;
          for (int j = left; j <= right; j++) {
              if (arr[max] < arr[j]) {
                  max = j;
              }
              if (arr[min] > arr[j]) {
                  min = j;
              }
          }
            if (min != left) {
                swap(arr, min, left);
            }

            if (max == left) {
                max = min;
            }
            if (max != right) {
                swap(arr, max, right);
            }
          left++;
          right--;
        }
    }

3.优化后的复杂度分析

减少了交换次数，交换次数为n/2
平均时间复杂度为O(n^2)
依旧不稳定