排序初步认识

一，排序的概念及常见的排序

1.1排序的概念

排序：所谓排序，就是将一段数据以大小或者不同的方式排起来，以递增递减的方式排列起来的操作。

稳定性：就是在排序中有一样的数据，比如两个5，一个在前面，一个在后面，排序完之后，还能保持一个在前面的，一个在后面，这样的就是稳定的。

内部元素：将元素全部放在内部的元素，也是大多数的排序基准。

外部元素：数据元素太多不能同时放在内部，然后排序的要求也不能在内外之间移动数据的排序。

1.2常见的排序算法

二，几种排序算法的基本实现

2.1直接插入排序

名字就是排序方法，也就是将数据直接插入排序到一个已经排好序的序列中，将自己的数据跟序列中的数据一个一个进行比较，找到插入位置插入即可，然后把原来位置的数据按序往后移动。

直接插入排序特点：

1.如果数据接近有序，这种排序的效率就越高

2.时间复杂度：O（N^2）

3.空间复杂度：O（1）

4.稳定性：稳定

代码实现：

​
public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0 ; j--) {
                //加不加等号 能取决于这个排序的稳定性
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }

​

2.2希尔排序

希尔排序是直接插入排序的升级版，它会先进行几次预排序，将序列变的更接近有序，最后进行一次总排序，也就是直接插入排序，可以在数量很大的时候，更加快速的排序出来。

 希尔排序总结：

1.是对直接插入排序的优化

2.当gap>1时，都是预排序

3.希尔排序的时间复杂度很难计算，一般记成o（n^1.25）

4.是不稳定的

代码实现：

 public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap = gap / 2;
            shell(array,gap);
        }
       
    }

    private static void shell(int[] array,int gap) {
        //每组的数据也在变化
        // 1+2+3+4+....+n/gap
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0 ; j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

2.3堆排序

堆排序是利用推积树这种数据结构实现的一种排序，它是根据堆来选择数据，需要注意的是创建升序（由小到大）用大根堆，反之则小根堆

 如上图就是堆排序的过程，先调换最后一个和堆顶元素，然后根据小跟堆特点来调换，最后达到目的。

代码实现：

 public static void heapSort(int[] array){
        //创建大根堆
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }

    private static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            siftDown(array,parent,array.length);
        }
    }

    private static void siftDown(int[] array,int parent,int len) {
        int child = (2*parent)+1;
        while (child < len) {
            if(child + 1 < len && array[child] < array[child+1]) {
                child = child+1;
            }
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

堆排序总结：

1.效率较高，堆是二叉树的形式速度会快很多。

2.时间复杂度：O（N*logN）

3.空间复杂度：O（1）

4.不稳定

2.4冒泡排序

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序容易理解，就不放图了。

冒泡排序代码：

     public static void bubbleSort(int[] array) {
        //i代表趟数 10 -》 9趟
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;//初始化为false，后面交换就变1.
            for(int j = 0;j < array.length-1-i;j++) {
                if(array[j] > array[j+1]) {//如果前一个比后一个大就交换
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            //没有交换证明有序了
            if(flg == false) {
                return;
            }
        }
    }

冒泡排序特点：

1.时间复杂度：O（N^2）

2.空间复杂度：O（1）

3.稳定

2.5快速排序*

快排主要分三步：

1.选基准：在序列中选一个元素作为基准。
2.分割：将序列中小于基准的放在左边，大于基准的放在右边。
3.递归排序：对基准左右两边的子序列重复上述步骤，直到子序列有序。

快速排序递归实现的框架和二叉树前序遍历很像，基本是一样的，代码如下：

void QuickSort(int[] array, int left, int right)
{
    if(right - left <= 1){
        return；
     }

    // 按照基准值对array数组的 [left, right)区间中的元素进行划分
    int div = partion(array, left, right);
    
    // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
    // 递归排[left, div)在进行一次划分
    QuickSort(array, left, div);
    
    // 递归排[div+1, right)同理操作
    QuickSort(array, div+1, right);
}

2.5.1挖坑法

快速排序有三种方法，我在这里说一下我喜欢的挖坑法：就是先将序列的第一个数据放在临时变量key中，然后从两边开始往中间走，在后面的right往前走找到了比基准小的，就放到前面基准挖的坑里面，然后后面就会形成一个坑，前面left找到比基准大的，就放的后面那个坑里，也就是挪开的坑里，一直重复，最后相遇，将基准放到最后相遇的地方。这就是挖坑法。

挖坑法的代码：

private static int partition(int[] array, int left, int right) {
    int i = left;
    int j = right;
    int pivot = array[left];//挖坑，将第一个数拿出来
    while (i < j) {
        while (i < j && array[j] >= pivot) {
            j--;//先走right找到比基准小的往前挪到基准挖的坑，空出自己的坑位
       }
        
        array[i] = array[j];
        
        while (i < j && array[i] <= pivot) {
            i++;//再走left找到比基准大的挪到它挪开的地方
       }
        
        array[j] = array[i];
   }
    array[i] = pivot;//最后把基准放到对应的相遇坑位。
    return i;
}    

快速排序总结：

1.快排性能非常好，使用场景也很多，实力出众。

2.时间复杂度：O（N*logN） 

3.空间复杂度：O（logN）

4.不稳定

2.6归并排序

归并的操作就是将一个乱序数据先拆分成若干两两对比的小份数据，然后在慢慢归并，最后合在一起形成一个有序的序列表。还有要注意的就是对比时要保证两边都有数据才能进行比较，其操作如下：

即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并排序代码：

​//分解操作，跟建立二叉树时一样的
    private static void mergeFunc(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        int mid = left + ((right-left) >> 1);
        mergeFunc(array,left,mid);//分解左树
        mergeFunc(array,mid+1,right);
        merge(array,left,mid,right);//递归合并
    }
//归并过程
    private static void merge(int[] array,int left,int mid,int right) {
        //为了方便写代码，赋值简单的字
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmpArr = new int[right-left+1];//表的长度
        int k = 0;//表头位置
        //1.保证两个表 都有数据
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];//将s1的东西放到k上，然后将他俩一起往后移动一个
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        //2. 看哪个数组 还有数据 拷贝回去
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        //3.拷贝到源数组
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];//加left是因为右边合并时会将前面覆盖，防止这种操作产生而做的
        }
    }

​

 归并排序总结：

1.牺牲空间换取时间

2.时间复杂度：O（N*logN）

3.空间复杂度：O（N）

4.稳定