【八大排序（四）】归并排序 冒泡排序 计数排序

❣博主主页: 33的博客❣
▶️文章专栏分类:八大排序◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多排序知识

1.前言

这学习数组的时候，我们已经学会将两个有序数组合并成一个有序数组，在归并排序中就需要用到这一思想，接下来我们就一起学习归并排序吧。

2.归并排序

2.1概念

归并排序建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用，将已有的子序列合并，得到完全有序的序列，即先使每个子序列有序，再使子序列段间有序。

2.2画图理解

归并排序

2.3代码实现

 public int[] mergeOrder(int[] arr){
        mergeFun(0,arr.length-1,arr);
        return arr;
    }
    public void mergeFun(int l,int r,int[] arr){
        if (l>=r){
            return;
        }
        int mid=(l+r)/2;
        //分解
        mergeFun(l,mid,arr);
        mergeFun(mid+1,r,arr);
        //归并
        merge(l,r,mid,arr);
    }
    private void merge(int l, int r,int mid ,int[] arr) {
        int s1=l;
        int e1=mid;
        int s2=mid+1;
        int e2=r;
        int[] tmp=new int[r-l+1];
        int i=0;
        while (s1<=e1&&s2<=e2){
            if(arr[s1]<=arr[s2]){
                tmp[i]=arr[s1];
                i++;
                s1++;
            }else {
                tmp[i]=arr[s2];
                i++;
                s2++;
            }
        }
        while (s1<=e1){
            tmp[i]=arr[s1];
            i++;
            s1++;
        }
        while (s2<=e2){
            tmp[i]=arr[s2];
            i++;
            s2++;
        }
        for (int j=0;j<tmp.length;j++){
            arr[j+l]=tmp[j];
        }
    }

1. 时间复杂度：O(NlogN)
2. 空间复杂度：O(N)
3. 稳定性：稳定*

3.冒泡排序

3.1概念

相对来说，冒泡排序是大家最熟悉的一种排序算法吧，冒泡排序是一种交换排序：：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

3.2画图理解

冒泡排序

3.3代码实现

private void swap(int i, int j,int[] arr) {
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }
public int[] Buble(int[] arr){
        boolean flag=true;
        for(int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1]){
                    swap(j,j+1,arr);
                    flag=false;
                }
            }
            if (flag){
                return arr;
            }
        }
        return arr;
    }

1. 时间复杂度：O(N^2)
2. 空间复杂度：O(1)
3. 稳定性：稳定

在之前所学习到的排序算法都是基于比较的，那有没有什么算法是不通过比较也能进行排序呢？当然是有的，那就是计数排序。

4.计数排序

4.1基本概念

计数统计就是就是先统计相同元素出现的次数，出现次数每多一次，对应的数组下标就++，根据统计的结果将序列收回到原来的序列中。

4.2画图理解

计数排序

4.3代码实现

public int[] countOrder(int[] arr){
        int max=arr[0];
        int min=arr[0];
        for (int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        for (int i=0;i<arr.length;i++){
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] tmp=new int[max-min+1];
        for (int i=0;i<arr.length;i++){
            tmp[arr[i]-min]++;
        }
//写回arr
        int index=0;
        for (int i=0;i<tmp.length;i++){
            while (tmp[i]>0){
                arr[index]=i+min;
                index++;
                tmp[i]--;
            }
        }
        return arr;
    }

1.时间复杂度：O(MAX(N,范围))
2. 空间复杂度：O(范围)
3. 稳定性：稳定

5.总结

我们已经详细学习了八大排序的所有排序算法，我们需要掌握各个排序时间复杂度，空间复杂度和稳定性。

排序方法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
插入排序	O(n^2)	O(1)	稳定
归并排序	O(n * log(n))	O(n)	稳定
选择排序	O(n^2)	O(1)	不稳定
希尔排序	O(n^1.3-1.5)	O(1)	不稳定
堆排序	O(n*log(n))	O(1)	不稳定
快速排序	O(n*log(n))	O(log(n))	不稳定

下期预告：Map和Set