排序算法学习笔记（一）计数排序

1.前言：

今天又开始学习排序算法啦，为了给大家一起分享学到的知识和自己做笔记给自己以后看，所以写了这篇排序算法学习笔记。

2.排序算法分类

十种常见排序算法可以分为两大类∶
比较类排序∶通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序∶不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

3.相关概念

● 稳定∶如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
● 不稳定:如果a原本在b的前面，而a=b，排序之后a 可能会出现在 b的后面。
● 时间复杂度:对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
● 空间复杂度︰是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

4.非比较排序

4.1 计数排序

定义：计数排序是一种非比较排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

算法稳定性：稳定

时间复杂度：O（n+j），n是数组长度，j是数据范围

例子：
假设这里有一个序列为6,7,6,1,3,10
1.我们首先应该申请一个最大值加一的数组，在这例子中我们可以看到最大值为10，所以我们应该申请一个大小为11的数组int a[11]，初始状态下，我们将a[0]~a[11]都初始化为0

0	0
1	0
2	0
3	0
4	0
5	0
6	0
7	0
8	0
9	0
10	0

2.第一个数是6，我们将a[6]原来的数值加1（就是a[6]从0变成了1），表示6出现了一次

0	0
1	0
2	0
3	0
4	0
5	0
6	1
7	0
8	0
9	0
10	0

2.第二个数出现的是7，同样把a[7]在原来基础上加1

0	0
1	0
2	0
3	0
4	0
5	0
6	1
7	1
8	0
9	0
10	0

3.第三个数出现的还是6，我们要在a[6]原来的基础上加1

0	0
1	0
2	0
3	0
4	0
5	0
6	2
7	1
8	0
9	0
10	0

4.后面就不一一演示了，最终数组内容为：

0	0
1	1
2	0
3	1
4	0
5	0
6	2
7	1
8	0
9	0
10	1
我们其实把数值放到对应的下标里面去了

现在我们可以遍历上面这个数组
下标为1的位置，值为1，我们就输出1个1
下标为3的位置，值为1，我们就输出1个3
下标为6的位置，值为2，我们就输出2个6
下标为7的位置，值为1，我们就输出1个7
下标为10的位置，值为1，我们就输出1个10
（由此可以看出，我们的计数排序其实是用空间换时间的）

代码实现：

import java.util.Arrays;

public class CountSort {
    public static void main(String[] args) {
        int[] arr = {6, 7, 6, 1, 3, 10};
        countSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void countSort(int[] arr){
        //找到数组中的最大值max
        int max = arr[0];
        for (int i = 1; i < arr.length; i++){
            if (arr[i] > max){
                max = arr[i];
            }
        }
        //创建计数数组,记住数组容量要比最大值大一个
        int[] count = new int[max + 1];
        //遍历arr,就是为了得到刚刚例子中最后的那个数组
        for (int i = 0; i < arr.length; i++){
            count[arr[i]]++;
        }
        //遍历计数数组
        int j = 0;
        for (int i = 0; i < count.length;i++){
            while(count[i]>0){
                arr[j++] = i;
                count[i]--;
            }
        }
    }
}

5 计数排序代码优化

不知道大家有没有发现一个问题，如果按照这样子来创建，数组中最大值如果不大还好，如果是几百的话，岂不是要增加几百个数组？因此我们可以算上他的偏移量，我们可以用max-min+1来作为一个偏移量，虽然我们在计数的时候，下表要减去这个偏移量，但是输出数组的时候我们加上这个偏移量

优化后的代码：

import java.util.Arrays;

public class CountSort {
    public static void main(String[] args) {
        int[] arr = {130,150,161,124,166};
        countSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void countSort(int[] arr){
        //找到数组中的最大值max
        int max = arr[0];
        for (int i = 1; i < arr.length; i++){
            if (arr[i] > max){
                max = arr[i];
            }
        }
        //找到数组中的最小值min
        int min = arr[0];
        for (int i = 1; i < arr.length; i++){
            if (arr[i] < min){
                min = arr[i];
            }
        }
        //创建计数数组,记住数组容量要比最大值大一个
        int[] count = new int[max - min + 1];

        //遍历arr,就是为了得到刚刚例子中最后的那个数组
        for (int i = 0; i < arr.length; i++){
            count[arr[i] - min]++;
        }
        //遍历计数数组
        int j = 0;
        for (int i = 0; i < count.length;i++){
            while(count[i]>0){
                arr[j++] = i + min;
                count[i]--;
            }
        }
    }
}