排序算法及优化

---

前言

内排序 ：将数据存储在内存上，在内存上进行的排序
外排序：将数据存储在外存上（例如磁盘，硬盘）排序的
七种排序是基于比较的排序，另外还有三种基于非比较的排序。

一、冒泡排序

1.冒泡排序是一种稳定的排序，思想就是遍历数组是将相邻的两个元素进行比较，值大的就往后面放，一趟冒泡排序的结果就是将数组中最大的值放到了最后面，之后遍历长度就能够减少。
2.时间复杂度是O（n^2）,最好情况下数组有序时间复杂度为O（N）,空间复杂度为O（1）。
3.优化就是插入一个变量查看看遍历一遍是否进行了交换，没有交换就说明已经有序了。

 public void bubbleSort(int []array){
   
        //冒泡排序就是每次排序的时候都将最大值挪到最后的位置
        for(int i=0;i<array.length;i++){
   
            boolean flg=true;
            for(int j=0;j<array.length-i-1;j++){
   
                if(array[j]>array[j+1]){
   
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flg=false;
                }
            }
              if(flg){
   
                  break;
            }
        }
    }

二、插入排序

1.插入排序就像玩扑克牌时一样，将手中的牌插入到合适的位置，排序时先认为第一个元素已经有序，之后遍历将其他元素放到合适的位置即可，
2.插入排序时间复杂度是O（N^2）,时间复杂度为O（1）
代码实现就是先将代排序的拿出来，之后后面每个元素与其比较将它放到合适的位置，默认前1个元素有序

public static void insertSort(int []array){
   
        for(int i=1;i<array.length;i++){
   
            int temp=array[i];
            int j=i-1;
            for(;j>=0;j--){
   
                if(array[j]>temp){
   
                    array[j+1]=array[j];
                }else {
   
     //因为前面的元素都是有序的 如果该元素都大于i-1位置元素，那它的位置就是合适的位置，无需排序
                    break;
                }
            }
            array[j+1]=temp;
        }
    }

1.优化插入排序

针对插入排序的优化就是对待排序元素位置的查找，用二分查找快速找到插入位置，

	 public static void insertSort(int []array) {
   
        for (int i = 1; i < array.length; i++) {
   
            int temp = array[i];
            int left = 0;
            int right = i;
            while (left < right) {
   
                int mid = (left + right) >> 1;
                if (array[mid] < temp) {
   
                    left = mid + 1;
                } else {
   
                    right = mid;
                }
            }
    //前面的元素都是有序的，之后将待排序的元素和中间位置元素进行比较，快速找到代排序的位置
            for (int j = i; j > left; j--) {
   
                array[j] = array[j - 1];
            }
            array[left] = temp;
        }
    }

三、希尔排序

其实希尔排序就是对插入插入排序的优化，利用分组的思想
例如：你要将一万个无序数据进行排序，插入排序的时间复杂度就是 O（10000^2）
但是你进行分组，将一万个数据分成100组，在组内进行排序 O（100^2）*100组 是O（1000000）一百万比一亿小的多，这才是10000个数据的差值。
一般情况的时间复杂度是O（N^1.3~1.5）最坏情况是O（N ^2） 空间复杂度为O（1）
最主要的就是对增量的定义一般取质数 ,

public static void shellSort(int []array,int gap){
   
        for(int i=gap;i<array.length;i++){
   
            int temp=array[i];
            int j=i-gap;
            for(;j>=0;j-=gap){
   
                if(array[j]>temp){
   
                    array[j+gap