【直接选择排序的特性总结】 1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用 。 2. 时间复杂度：O(N^2) 。 3. 空间复杂度：O(1) 。 4. 稳定性：不稳定。

二、堆排序

代码实现：

  public static void heapSort(int[] array) {//堆排序createBigHeap(array);//O(n)int end = array.length-1;while (end > 0) {swap(array,0,end);shiftDown(array,0,end);end--;}}private static void createBigHeap(int[] array) {//创建大根堆for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {shiftDown(array,parent,array.length);}}private static void shiftDown(int[] array,int parent,int len) {//向下调整int child = (2 * parent) + 1;while (child < len) {if (child + 1 < len && array[child] < array[child + 1]) {child++;}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. 稳定性：不稳定 。

四、交换排序

1、冒泡排序

冒泡排序基本思想就是相邻元素挨个比较，遇到比自己小的就交换，直到最后元素有序。

代码实现：

    public static void bubbleSort(int[] array) {//最外层控制的是趟数for (int i = 0; i < array.length-1; i++) {boolean flg = false;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) {break;}}}

【冒泡排序的特性总结】 1. 冒泡排序是一种非常容易理解的排序 2. 时间复杂度：O(N^2) 3. 空间复杂度：O(1) 4. 稳定性：稳定

2、快速排序

1、Hoare法

Hoare法的基本思想就是假设我们选array[0]，作为我们的临时节点tmp，定义两个指针变量left和right，先让right从右往左走，找到第一个小于tmp的元素下标，然后left从前往后遍历，找到第一个大于tmp元素的下标，然后交换这两个下标元素的值，当循环结束后，把我们的tmp和left下标交换，那么得到的结果就是tmp左边元素都比tmp小，tmp右边的元素都比tmp大。

代码实现：

 private static int partitionHoare(int[] array,int left,int right) {//hoare法int i = left;int pivot = array[left];while (left < right) {//left < right &&  这个条件不能少 预防后面都比基准大while (left < right && array[right] >= pivot) {right--;}//代码走到这里表示right下标的值 小于pivotwhile (left < right && array[left] <= pivot) {left++;}//left下标的值 大于pivotswap(array,left,right);}//交换 和 原来的leftswap(array,left,i);return left;}

2、挖坑法

挖坑法的基本思想就是把第一个元素取出来，形成一个坑位，然后定义两个指针left和right，先让right从右往左走，找到第一个比tmp小的元素，如果找到，那么把这个元素放到tmp的位置，同理，left从前往后遍历，找到比tmp大的元素的下标，然后用这个元素覆盖array[right],循环结束以后，将tmp放在array[left]的位置，最后返回left便是我们的基准！

代码实现：

  private static int partition2(int[] array,int left,int right) {//挖坑法,优先使用int pivot = array[left];while (left < right) {//left < right &&  这个条件不能少 预防后面都比基准大while (left < right && array[right] >= pivot) {right--;}array[left] = array[right];//right下标的值 小于pivotwhile (left < right && array[left] <= pivot) {left++;}array[right] = array[left];}//交换 和 原来的leftarray[left] = pivot;return left;}

3、前后指针法

前后指针法的思路有点难理解，基本思想就是结合代码来看，我们定义一个临时节点cur，然后令cur= left+1，然后循环条件是cur<=right,能够交换的条件就是当array[cur] < array[left] && array[++prev] != array[cur]，然后cur++，继续往后找。

1、找到符合条件的元素

 2、交换cur和prev。

 3、交换之后，cur++

代码实现：

    private static int partition(int[] array, int left, int right) {//前后指针法int prev = left ;int cur = left+1;while (cur <= right) {if(array[cur] < array[left] && array[++prev] != array[cur]) {swap(array,cur,prev);}cur++;}swap(array,prev,left);return prev;}

快速排序总结：

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序 。 2. 时间复杂度：O(N*logN)。

最坏情况下能达到O(N^2)。

3. 空间复杂度：O(logN) 。 4. 稳定性：不稳定 。

快速排序测试

那么快速排序既然敢叫快速排序，那么它的速度应该是非常快的，我们定义一个逆序的数组来测试一下。

 那么问题就是当数组中的元素趋于有序的时候，即形成了单分支。这个时候我们的快速排序效率是非常低下的且空间复杂，时间复杂度会达到最大，而空间复杂度度会随之改变。

当元素数量达到100000左右的时候，程序就会崩溃，因为idea默认在栈上开辟的内存空间是有限的，我们来测试一下。

 快速排序优化

1、三数取中法

基本思想就是我们取3个数的中间数(index)作为我们的基准，然后交换start和index。

代码：找中间数

 private static int findMidValOfIndex(int[] array,int start,int end) {//找中间值int midIndex = (start+end) / 2;//    3                 9if(array[start] < array[end]) {if(array[midIndex] < array[start]) {return start;}else if(array[midIndex] > array[end]) {return end;}else {return midIndex;}}else {if(array[midIndex] > array[start]) {return start;}else if(array[midIndex] < array[end]) {return end;}else {return midIndex;}}}

2、子区间插入排序

大概意思就是我们递归的主体主要分布在二叉树的靠下面的节点，那么可以考虑当我们的元素较少且趋于有序的时候采用插入排序来完成!

代码实现：

    private static void insertSort(int[] array,int left,int right) {for (int i = left+1; i <= right; i++) {int tmp = array[i];int j = i-1;for (; j >= left;j--) {if(array[j] > tmp) {array[j+1] = array[j];}else {//array[j+1] = tmp;break;}}array[j+1] = tmp;}}

六、归并排序

1、基本思想

 1、递归实现归并排序

    public static void MergeSort(int[] array) {mergeSortChild(array,0,array.length-1);}private static void mergeSortChild(int[] array,int left,int right) {if(left == right) {return;}int mid = (left+right) / 2;mergeSortChild(array,left,mid);mergeSortChild(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;//表示tmpArr 的下标while (s1 <= e1  && s2 <= e2) {if(array[s1] <= array[s2]) {tmpArr[k++] = array[s1++];}else{tmpArr[k++] = array[s2++];}}while (s1 <= e1) {tmpArr[k++] = array[s1++];}while (s2 <= e2) {tmpArr[k++] = array[s2++];}//tmpArr当中 的数据 是right  left 之间有序的数据for (int i = 0; i < k; i++) {array[i+left] = tmpArr[i];}}

效率测试

归并排序总结 1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。 2. 时间复杂度：O(N*logN)。 3. 空间复杂度：O(N)。 4. 稳定性：稳定。

 2、非递归实现归并排序 

非递归的思想就是假如我们有8个待排序的元素，那么非递归的做法就是22 44 88，即两两比较完了之后4个一起比较，再然后8个一起比较，直到所有元素都比较完。

 代码演示：

  public static void MergeSort1(int[] array) {int gap = 1;while (gap < array.length) {for (int i = 0; i < array.length; i += gap*2) {int left = i;int mid = left + gap -1;int right = mid+gap;if(mid >= array.length) {mid = array.length-1;}if(right >= array.length) {right = array.length-1;}merge(array,left,mid,right);}gap *= 2;}}

结果测试

 🥞🥞好了，那么以上就是java实现七大排序算法的全部内容了，本篇博客博主也是耗费了2天的精力才整理完毕的，实属不易，那么当然了，还有一些其他的排序算法本篇博客没有提及到，博主所写内容基本都是针对面试的重要知识点，也是非常常见的题型，后续有精力的话博主会补充一些额外的排序知识点供大家学习，那么如果能掌握以上的全部内容，那么我相信，你一定也是个排序小高手了，嘿嘿！💝💝感谢阅读，期待一键三连！🤟🤟