排序1

排序算法有几个指标，内存消耗，和稳定性。

内存消耗：内存消耗主要通过空间复杂度来衡量，针对空间负责度，我们提出原地排序这个概念。原地排序是指空间复杂度是O(1)的排序算法，也就是没有额外引入内存的算法。

稳定性：这个概念是指如果待排序的序列中存在值相等的元素，经过排序之后，相等的元素之间原有的先后顺序不变。

比如，5，3，4，2，4，6。经过排序后：2，3，4，4，5，6。其中两个4的先后顺序没有发生变化，那么我们就称这种排序叫稳定的排序，如果发生了变化，那么我们就称这种叫不稳定的排序。

冒泡排序（Bubble Sort）

冒泡排序只会操作相邻的两个数据，每次操作只对相邻的额元素比较。代码如下：

// 冒泡排序，a 表示数组，n 表示数组大小
public void bubbleSort(int[] a, int n) {
  if (n <= 1) return;
 
 for (int i = 0; i < n; ++i) {
    // 提前退出冒泡循环的标志位
    boolean flag = false;
    for (int j = 0; j < n - i - 1; ++j) {
      if (a[j] > a[j+1]) { // 交换
        int tmp = a[j];
        a[j] = a[j+1];
        a[j+1] = tmp;
        flag = true;  // 表示有数据交换      
      }
    }
    if (!flag) break;  // 没有数据交换，提前退出
  }
}

冒泡排序是原地排序算法。也是稳定排序算法。

关于冒泡排序的时间复杂度需要使用有序度来阐述。因为如果一个数组是完全有序的，那么排序只需要循环一次O(n)，

如果是完全无序的则需要，如果使用平均复杂度来分析比较复杂。所以通过“有序度”和“逆序度”这两个概念来进行分析。

一组数据的满有序度= = 。满有序度 = 有序度 + 逆序度。

冒泡排序每交换一次，有序度就加1。交换的次数为逆序度，就是n*(n-1)/2 - 初始有序度。对于包含n个数据的数组进行冒泡排序，最坏情况下，初始有序度是0，要进行n*(n-1)次交换。最好的情况初始有序度是n*(n-1)不需要进行交换。我们取中间值n*(n-1)/4，来表示初始有序度的平均情况。

所以平均情况下需要n*(n-1)/4次交换操作，比较操作比交换操作多，复杂度上限是O(n^2)，所以平均时间复杂度就是O(n^2)。

 

插入排序(Insertion Sort)

插入排序维持一部分数组有序，然后将剩下的数与这部分有序的数依次比较，在比较的过程中进行两种操作：

如果不符合插入的条件（比大或者比小）就移动有序数到比较数的位置。

如果符合插入条件，就将比较数插入那个位置。

代码如下：

    /**
     * 插入排序 升序
     * @param a
     */
    public static void insertionSortAscend(int[] a){
        for (int i = 0 ;i < a.length -1 ;i++){
            if (a[i] > a[i + 1]){
                int value = a[i + 1];
                int j = i;

                for ( ;j >= 0 ;j--){
                    if (a[j] > value){
                        //搬移
                        a[j + 1] = a[j];
                    }else {
                        break;
                    }
                }
                //j可以到-1
                a[j+1] = value;
            }
        }
    }

插入排序也是稳定排序，和原地排序。他的平均时间复杂度是

选择排序(Selection Sort)

简单的选择排序：维持一段已经排好的数组，从剩下数组中找到最小的一个，把他放在已经排好序部分的后边。

代码如下：

   /**
     * 简单选择排序
     * @param a
     */
    public static void selectionSort(int[] a){
        for (int i = 0 ; i < a.length ;i++){ ;
            int index=i;
            for (int j = i+1;j < a.length; j++){
                //找到最小者的下标
                if (a[j] < a[index]){
                    index = j;
                }
            }
            //调换位置
            if (index != i){
                int temp = a[i];
                a[i] = a[index];
                a[index]=temp;
            }
        }
    }

选择排序的空间复杂度是O(1)是一种原地排序算法。但是选择排序的最好和最坏的时间复杂度都是O(n^2)。

而且选择排序会交换元素位置，比如4,3,4,6,5,2。第一次找到最小元素2，将4和2调换位置。那么数中的两个4的原来的位置就发生了变化。所以选择排序不是稳定的排序算法。