基础排序（冒泡，选择，插入）

交换方法（不需要额外空间，并且速度更快）

private static void swap(int[] src,int x,int y){
    src[x] = src[x] ^ src[y];
    src[y] = src[x] ^ src[y];
    src[x] = src[x] ^ src[y];
}

冒泡排序（加入exchange变量，如果没发生交换，说明已经排好了，直接return不需要再做循环）

private static void bubble(int[] src){
    boolean exchange;
    for(int i = src.length - 1; i > 0; i--){
        exchange = false;
        for(int j = 0; j < i; j++){
            if(src[j] > src[j + 1]){
                swap(src, j, j + 1)
                exchange = true;
            }
        }
        if(!exchange){
            return;
        }
    }
}

算法分析：冒泡排序最好的情况是初始状态是正序的，一次扫描即可完成排序，所以最好的时间复杂度为 O(N)；最坏的情况是反序的，此时最坏的时间复杂度为 O(N^2)。平均情况，每轮 N/2 次循环，N 轮时间复杂度为 O(N^2)。

算法是稳定的，因为当 a=b 时，由于只有大于才做交换，故 a 和 b 的位置没有机会交换，所以算法稳定。

空间复杂度为 O(1)，不需要额外空间。

选择排序

private static void select(int[] src){
    int min;
    for(int i = 0; i < src.length; i++){
        min = i;
        for(int j = i + 1; j < src.length; j++){
            if(src[j] < src[min]){
                min = j;
            }
        }
        if(min != i){
            swap(src,i,min); 
        }
    }
}

算法分析：选择排序最好和最坏的情况一样运行了 O(N^2) 时间，但是选择排序无疑更快，因为它进行的交换少得多，当 N 值较小时，特别是如果交换时间比比较时间大得多时，选择排序实际上是相当快的。平均复杂度也是 O(N^2)。

算法是不稳定的，假设 a=b，且 a 在 b 前面，而某轮循环中最小值在 b 后面，而次最小值需要跟 a 交换，这时候 b 就在 a 前面了，所以选择排序是不稳定的。

空间复杂度为 O(1)，不需要额外的空间。

插入排序

private static void insert(int[] src){
    for(int i = 1; i < src.length; i++){
        for(int j = i; (j > 0) && (src[j] < src[j-1]); j--){
            swap(src, j, j-1);             
        }
    }
}

算法分析：插入排序最好的情况是序列已经是升序排列了，在这种情况下，需要进行 N-1 次比较即可，时间复杂度为 O(N)，最坏的情况是序列降序排列，这时候时间复杂度为 O(N^2)。因此插入排序不适合对于数据量比较大的排序应用。但是如果需要排序的数据量很小(如小于千)，那么插入排序还是一个不错的选择。插入排序平均时间复杂度为 O(N^2)，但是它要比冒泡排序快一倍，比选择排序还要快一点，经常被用在较复杂的排序算法的最后阶段，例如快速排序。

算法是稳定的，假设 a=b，且 a 在 b 的前面，其排序位置必然比 b 先确定，而后面再插入 b 时，必然在 a 的后面，所以是稳定的。

空间复杂度为 O(1)，不需要额外的空间。