排序算法（一）（Java实现）

   本文主要介绍七种基本的排序算法：冒泡排序，快速排序，插入排序，希尔排序，选择排序，堆排序和归并排序。其中，快速排序是冒泡排序的增强，希尔排序是插入排序的增强，堆排序是选择排序的增强。

1、冒泡排序
原理：第一轮比较，将序列中的每个元素两两进行比较，小于则交换，直到比较到最后一个位置，相当于将第一轮将序列中最大的数放在了最后一个位置；第二轮，将序列中的每个元素（最后一个除外）两两比较，小于则交换，将这一轮中的最小值放到倒数第二个位置上，依次进行，直到剩下一个元素进行比较。
举例如下：

代码实现如下：

 public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
 public void BubbleSort(int[] arr){
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr.length-1-i;j++){//注意循环边界条件
                if(arr[j] > arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }

算法分析：
(1)算法性能

(2)时间复杂度
若序列是正序的，则只需一次即可得到有序序列，这是最好的情况，时间复杂度为O(N)；
若序列是反序的，需要进行N-1趟排序，比较和移动次数均达到最大值，时间复杂度为O(N^2)；
所以冒泡排序的平均时间复杂度为O(N^2),也就是说，序列越接近正序，冒泡排序的性能越好。
(3)稳定性
冒泡排序是将大元素后移或小元素前移，比较和移动也是两个元素之间，所以，相同元素的前后顺序并未改变，是一种稳定的排序算法。

2、插入排序
原理：将一个序列分为有序序列和无序序列，初始状态将第一个元素作为有序序列，其余元素为无序序列；将无序序列中的元素一次与有序序列中的元素进行排序，插入到合适位置，直到无序序列中的最后一个元素插入到有序序列中为止。
举例如下：

代码实现如下：

 public void insertSort(int[] arr){
        for(int i = 1;i < arr.length;i++) {//若a大于b，将b插入a前面，i要从下标为1处开始遍历
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                int j = i - 1;
                for (; j >= 0; j--) {
                    if (arr[j] > temp) {//将大于temp的往后移动
                        arr[j + 1] = arr[j];
                    }else{
                        break;
                    }
                }
                arr[j + 1] = temp;
            }
        }
    }

算法分析：
(1)算法性能

(2)时间复杂度
序列越接近正序，算法性能越好，时间复杂度为O(N);
序列越接近反序，算法性能越差，时间复杂度为O(N^2);
(3)稳定性
改变后的相同元素的前后顺序未改变，则插入排序为稳定的算法。
3、选择排序
原理：先将第一个元素与其余元素依次比较，若第一个元素大于第二个元素交换，再将第三个元素与第一个位置上元素进行比较，依此类推，第一轮后第一个位置上的元素是最小的，接着进行第二轮比较，等等，直到最后一个位置。

代码实现：

    public void chooseSort(int[] arr){
        for(int i = 0;i < arr.length;i++){
            //第一轮将最小的数放在最前面（每个数与第一个数比较，小则交换）；
            // 第二轮从第二位数开始比较，结果将这一轮中最小的数放在第二位置上，一次进行到最后一位
            for(int j = i+1;j < arr.length;j++){
                if(arr[j] < arr[i]){
                    swap(arr,j,i);
                }
            }
        }
}

算法分析：
(1)性能分析

(2)时间复杂度
选择排序的比较次数与序列的初始顺序无关，为N(N-1)/2；
当序列为基本正序时，移动次数最少，时间复杂度O(N^2)；
当序列为反序时，移动次数最多，3N(N-1)/2，时间复杂度为O(N^2)
(3)空间复杂度
在比较元素时，需要占用一个空间来保存临时值，空间复杂度为O(1)。