4.选择排序、冒泡排序、插入排序、计数排序

前言：常见的排序操作有选择排序、冒泡排序、插入排序、归并排序、堆排序、快速排序（二路快排、三路快排）、计数排序、基数排序、桶排序。本文主要介绍的是选择排序、冒泡排序、插入排序、计数排序。注：以下均为从小到大排序。

一、选择排序

{8,5,9,2,7,4,6,1,3}

对上面数组进行从小到大排序（8和5比较然后交换，变为5 8 9 2 7 4 6 1 3，5和9比较不交换，5和2比较然后交换，变为2 8 9 5 7 4 6 1 3........）

第一轮排完：1 8 9 5 7 4 6 2 3（也就是说选择排序经过第一次扫描之后就能找到最小数）

第二轮排完：1 2 9 8 7 5 6 4 3

 

......

则共需要八轮排完

具体过程见图：

代码实现：

public class Test4 {
    public static void main(String[] args) {
        //1.选择排序O(n^2)
        selectSort();
    }
    //选择排序
    public static void selectSort(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        for (int i=0;i<arr.length-1;i++){//-1是因为没有必要进行最后一个数字的比较
            for (int j=i+1;j<arr.length;j++){
                if (arr[i]>arr[j]){
                    swap(arr,i,j);
                }
            }
            System.out.println(arr[i]);
        }
        show(arr);
    }
  
    //打印数组
    public static void show(int[] arr){
        String s="[";
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                s+=arr[i]+"]";
            }else {
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
    //做备份
    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

二、冒泡排序

以{55，23，87，62，16}为例对数组进行从小到大排序

 

第一次扫描结果：23 55 62 16 87

  第一次扫描先拿第一个元素55和第二个元素23进行比较，如果第二个元素小于第一个元素，则进行交换。紧接着拿55和87进行比较，就这样一直比较并交换，到第4次比较完即可确定最大值在数组的最后面。具体过程如下图：

第二次扫描结果：23 55 16 62 87

  第二次扫描也是从头开始比较，但因为最后一个元素在第一次扫描就已确定是数组中的最大值，故只需比较3次即可把剩余数组元素的最大值排到剩余数组的最后面。具体过程如下图：

第三次扫描结果：23 16 55 62 87

第四次扫描结果：16 23 55 62 87

代码实现：

//排序操作
public class Test4 {
    public static void main(String[] args) {
        //2.冒泡排序O(n^2)
        bubbleSort();
    }
    //冒泡排序
    //优化待补充
    public static void bubbleSort(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        for (int i=0;i<arr.length-1;i++){//-1是少一轮比较
            for (int j=0;j<arr.length-i-1;j++){//-1避免重复比较和角标越界
                if (arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        show(arr);
    }
   
    //打印数组
    public static void show(int[] arr){
        String s="[";
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                s+=arr[i]+"]";
            }else {
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
    //做备份
    public static void swap(int[] arr,int i,int j){ 
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

  该排序有个缺点，不管数据是否已排序完成都固定会执行你n(n-1)/2次，所以需进行优化，使用所谓的岗哨的概念，可以提前中断程序，又可得到正确的排序结果，以此来提高程序执行的效率。

优化后的代码实现：

public class Test4 {
    public static void main(String[] args) {
       
        bubbleSortYou();
    }
   
    public static void bubbleSortYou(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        int i,j,tmp,flag;
        for (i =arr.length-1;i>=0;i--){
            flag=0;
            for (j=0;j<i;j++){
                if (arr[j+1]<arr[j]){
                    tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                    flag++;
                }
            }
            if (flag==0){
                break;
            }
        }
        show(arr);
    }
    
    //打印数组
    public static void show(int[] arr){
        String s="[";
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                s+=arr[i]+"]";
            }else {
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
    
}

三、插入排序

  插入排序法是将数组中的元素，逐一与已排序好的数据进行比较，前两个数字先排好，再将第三个元素插入适当的位置，重复此步骤（类似打牌时边接牌后边排牌）

8,5,9,2,7,4,6,1,3对该数组进行从小到大排序具体过程如图所示：

public class Test4 {
    public static void main(String[] args) {
        //3.插入排序O(n^2)
        insertSort();
    }
   
    //3.插入排序
    public static void insertSort(){
        int[] arr={8,5,9,2,7,4,6,1,3};
        int e;
        int j;
        for(int i=1;i<arr.length;i++){
            e=arr[i];
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        /*
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0&&arr[j-1]>arr[j];j--){
                swap(arr,j,j-1);
            }
        }
        */
        show(arr);
    }
   
    //打印数组
    public static void show(int[] arr){
        String s="[";
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                s+=arr[i]+"]";
            }else {
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
    //做备份
    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;

    }
}

四、计数排序

代码实现：

public class Test4 {
    public static void main(String[] args) {
        //4.计数排序O(n+m)
        /*
        上述三个排序都是根据数据之间的大小关系进行比较排序的
        计数 基数 桶 都是根据数据本身的特性比较 与大小无关的排序
        这些排序只针对整数
        是一个典型的牺牲空间换时间的排序
        */
        countSort();
    }

    public static void countSort(){
        int[] arr={8,5,9,2,7,4,6,1,3,10,-3,-2,-10};
        int min=arr[0];
        int max=arr[0];
        //1.找最大最小值
        for(int i=0;i<arr.length;i++){//O(n)
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        //2.计算存储大小
        int[] nums=new int[max-min+1];
        //3.计算偏移量
        int offset=min;
        //4.统计次数
        for(int i=0;i<arr.length;i++){//O(n)
            nums[arr[i]-offset]++;
        }
        //5.遍历数组nums
        int index=0;
        for(int i=0;i<nums.length;i++){//O(m)
            if(nums[i]!=0){
                for(int j=0;j<nums[i];j++){
                    arr[index++]=i+offset;
                }
            }
        }
        show(arr);
    }
    //打印数组
    public static void show(int[] arr){
        String s="[";
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                s+=arr[i]+"]";
            }else {
                s+=arr[i]+",";
            }
        }
        System.out.println(s);
    }
   
}