排序算法总结（java实现）

排序算法

介绍：排序分为内部排序和外部排序，内部排序指在内存中进行的排序过程；外部排序指在外存中进行排序的过程，但是此过程建立在多次访问内存的基础上（分成一段段利用内部排序进行排序）。

以下排序均属于内部排序：

一、插入排序

1、直接插入排序

　　思想：每一步将一个待排序元素，插入到前面已经排好序的序列中去进行比较排序，直到所有元素插完

　　图解：

　　

　　代码实现：

　　

 /**
      * 插入排序
      *
      * @param arr
      */
     public static void insertionSort(int[] arr) {
         for (int i = 1; i < arr.length; i++) {
             int j = i;
             //当前元素开始与前面排好序元素进行比较
             while (j > 0 && arr[j] < arr[j - 1]) {
                 swap(arr,j,j-1);
                 j--;
             }
         }
     }

2、希尔排序

　　思想：把排序序列按照设定的增量进行分组，然后对每一组使用直接插入排序

　　说明：

1. 增量的设定：这个值通常自定义，但是比较常用的增量是gap=length/2（并不是最优）
2. 增量的修改：每次经过一次排序后，增量通常需要gap=gap/2，直到增量为1时，停止修改
3. 增量的使用：若增量为n，则当前序列需要分为n组，即一组有length/n个元素
4. 分组：距离保持一致

　　图解：

　　

　　代码实现：

　　

     private static int[] sort(int nums[]){
         int length = nums.length;
         int gap = length/2;//初始化增量
         while(gap>=1){
             for (int i=0;i<gap;i++){
                 //得到了本组所有元素，以下对本组元素进行直接插入排序
                 for (int j=i+gap;j<nums.length;j=j+gap){//默认第一个元素在已排序序列中，故从第二个元素开始插入比较
                        while(j>i && nums[j-gap]>nums[j]){
                            int temp = nums[j-gap];
                            nums[j-gap] = nums[j];
                            nums[j] = temp;
                            j=j-gap;
                        }
                 }
             }
             gap = gap/2;
         }
         return nums;
     }

二、选择排序

1、直接选择排序

　　思想：每次遍历比较出最小值，再拿最小值与当前未排序列的第一个位置元素互换位置。n表示元素个数，则第m次比较（n-m）次

　　图解：

　　

　　代码实现：

　　

 private static int[] selectSort(int arr[]){
         int flag = 0;//记录待比较序列中最小值位置
         for(int i=0;i<arr.length-1;i++){
             //第i+1轮比较排序
             flag = i;
             for(int j=i+1;j<arr.length;j++){
                 if(arr[flag]>arr[j]){
                     flag=j;  //保存最小值位置
                 }
             }
             if(flag!=i) {
                 //判断最小值是否在目标位置，不是则需要进行交换
                 int temp = arr[flag];
                 arr[flag] = arr[i];
                 arr[i] = temp;
             }
         }
         return arr;
     }

2、堆排序

　　思想：

　　图解：

　　代码实现：

三、交换排序

1、冒泡排序

　　思想：进行n-1轮排序（n为元素个数）每轮排序中按照“小在前，大在后”的比较规则进行位置调整，每一轮都会冒出一个最大值在尾部（当前比较序列尾部）

　　图解：

　　       依次进行n-1轮排序

　　代码实现：

　　

 private int[] bubbleSort(int arr[]){
     for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
 　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
 　　　　　　　　if(arr[j]>arr[j+1]){
 　　　　　　　　　　int temp=arr[j];
 　　　　　　　　　　arr[j]=arr[j+1];
 　　　　　　　　　　arr[j+1]=temp;
 　　　　　　　　}
 　　　　　　}
 　　　　}
     return arr;
 }

2、快速排序

　　思想：在冒泡排序的基础上进行了优化，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两

　　部分数据分别进行快速排序，整个排序过程可  以 递归进行，以此达到整个数据变成有序序列。

　　过程说明：

　　①选取适当的基准数，通常我们选取第一个数为基准数，每一趟依次选取一个基准数，直到结束。

　　②与基准数比较中，小的换到前面，大的换到后面

　　③每趟都是先从右边开始比较，发生一次比较赋值（比较位置元素不变，游标不动；把它的值再复制到目标位置，目标位置移动一个单位）后则从另一方向开始

　　④快速排序停止条件：

　　图解：

　　图片来源于 https://www.cnblogs.com/skywang12345/p/3596746.html

　　

　　代码实现：

　　

     /**
      * 一次快速排序
      * @param array 数组
      * @param lo 数组的前下标
      * @param hi 数组的后下标
      * @return key的下标index，也就是分片的间隔点
      */
     public static int partition(int []array,int lo,int hi){
         /** 固定的切分方式 */
         int key=array[lo];//选取了基准点
         while(lo<hi){
             //从后半部分向前扫描
             while(array[hi]>=key&&hi>lo){
                 hi--;
             }
             array[lo]=array[hi];
             //从前半部分向后扫描
             while(array[lo]<=key&&hi>lo){
                 lo++;
             }
             array[hi]=array[lo];
         }
         array[hi]=key;//最后把基准存入
         return hi;
     }

     /**
      * 快速排序
      * @param array
      * @param lo
      * @param hi
      */
     public static void quickSort(int[] array,int lo ,int hi){
         if(lo>=hi){
             return ;
         }
         //进行第一轮排序获取分割点
         int index=partition(array,lo,hi);
         //排序前半部分
         quickSort(array, lo, index - 1);
         //排序后半部分
         quickSort(array,index+1,hi);
     }

四、归并排序

　　思想：归并排序采用“分治法”思想，将待排序列拆分位子序列，将个子序列内部排序，再合并各子序列，在子序列之间进行排序。

　　图解：

　　

　　在治（合并阶段）图解如下：

　　拿上图中最后一步来举例说明吧

　　

　　代码实现：

五、基数排序

　　思想：

　　图解：

　　代码实现：

性能比较