✨哈喽，进来的小伙伴们，你们好耶！✨
🛰️🛰️系列专栏:【数据结构与算法】
✈️✈️本篇内容: Java实现七大排序算法汇总！
🚀🚀由于本篇博客涉及代码较多，博主把代码都提交到了码云仓库gitee：Java数据结构代码存放！
⛵⛵作者简介：一名双非本科大三在读的科班Java编程小白，道阻且长，你我同行！
🍱🍱给大家推荐一个超级好用的刷题网站—牛客网！
点击链接注册，开启刷题之路！
目录
一、排序的概念
二、插入排序
1、直接插入排序
2、希尔排序
三、选择排序
1、直接选择排序
二、堆排序
四、交换排序
1、冒泡排序
2、快速排序
1、Hoare法
2、挖坑法
3、前后指针法
快速排序测试
快速排序优化
1、三数取中法
2、子区间插入排序
六、归并排序
1、递归实现归并排序
2、非递归实现归并排序
一、排序的概念
二、插入排序
🍏基本思想：
1、直接插入排序
🍯🍯直接插入排序的基本思想就是在一组给定的元素中，我们先定义一个i作为下标，我们将i下标的元素放在一个临时变量tmp中，即array[i] = tmp;然后在定义一个变量j，j=i-1;j下标往前走，每遇到一个元素就和tmp比较，如果array[j] > tmp,那么array[j+1] = tmp;这样就把前面大的元素给放到了后面，j往前遍历的前提是j>=0;如果array[j] <= tmp;那么循环结束，这里要注意的是最后循环条件不满足时，还要执行一次array[j+1] = tmp;因为最后一次没有交换，这样我们的代码就完整了！
🍸🍸代码实现：
public static void insertSort(int []arr){
for (int i = 0; i < arr.length; i++) {
int j = i-1;
int tmp = arr[i];
for (; j >=0 ; j--) {
if(arr[j] > tmp){
arr[j+1] = arr[j];
}else{
break;
}
}
arr[j+1] = tmp;
}
}🍗🍗直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高 。2. 时间复杂度：O(N^2) 。3. 空间复杂度：O(1)，它是一种稳定的排序算法 。4. 稳定性：稳定 。
2、希尔排序
🧀🧀希尔排序可以看成是直接插入排序的一种优化，因为在希尔排序当中，我们会确定一个步长gap，这个gap的值可以是大于1的，那么就假设我上面的动态图解中，有6个元素待排序，以间隔为4分组，那么距离第一个元素1步长为4的元素就是8，第二个元素5距离为步长4的元素就是4，那么1和8比较，1比8小，不交换，5和4比较，5比4大，交换；交换完成后在以2为步长分组，同理最后步长为1的时候，那么我们的比较就完成了，实现原理就是直接插入排序，但是希尔排序的好处就是一次排序会把大的元素尽量往后排，把小的元素往前排，这样就减少了我们直接插入排序的挨个元素比较，减少了时间复杂度。
🍬🍬代码实现：
public static void shell(int[] array,int 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;
}
}
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
gap /= 2;
shell(array,gap);
}
}🍫🍫1.希尔排序是对直接插入排序的优化。
2.当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了
这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，如果没有特殊说明，我们通常就取时间复杂度为O(n^1.3)。时间复杂度：O(n^1.3)
空间复杂度：O(1)
4. 稳定性：不稳定
三、选择排序
1、直接选择排序
基本思想：
代码实现：
public static void selectSort(int[] array){
int i = 0;
int minindex = i;
for (i = 0; i < array.length; i++) {
for (int j = i+1; j <array.length ; j++) {
if(array[j] < array[minindex]){
//更新minindex的值
minindex = j;
}
}
//处理两个下标值一样的情况
if (i != minindex){
swap(array,minindex,i);
}
}
}
public static void swap(int[] array,int i,int j){
int tmp = array[i];
array[i] = array[j];
array[j] =tmp;
}【 直接选择排序的特性总结】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下标的值 小于pivot
while (left < right && array[left] <= pivot) {
left++;
}
//left下标的值 大于pivot
swap(array,left,right);
}
//交换 和 原来的left
swap(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下标的值 小于pivot
while (left < right && array[left] <= pivot) {
left++;
}
array[right] = array[left];
}
//交换 和 原来的left
array[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 9
if(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天的精力才整理完毕的，实属不易，那么当然了，还有一些其他的排序算法本篇博客没有提及到，博主所写内容基本都是针对面试的重要知识点，也是非常常见的题型，后续有精力的话博主会补充一些额外的排序知识点供大家学习，那么如果能掌握以上的全部内容，那么我相信，你一定也是个排序小高手了，嘿嘿！💝💝感谢阅读，期待一键三连！🤟🤟
