JAVA 四种排序——选择排序、冒泡排序、插入排序、计数排序

一、选择排序

这个排序较为简单主要核心就是i和j的初始值和最大值

import java.util.*;
public class select{
    public static void main(String [] args){
        selectSort();//选择排序只有当前者大于后者时才交换
    }
    public static void selectSort(){
        int[] arr = {8,5,6,4,3,7,9,1,2};
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    swap(arr,i,j);//比较时调用（进栈），交换完弹栈，这样不占用内存空间
                }
            }
        }
        show(arr);//打印数组
        //System.out.println(Arrays.toString(arr));    Arrays.toString(arr)相当于这个函数show(arr)
    }
    public static void swap(int[] arr,int i,int j){
        //这种交换方式适用于任何类型的数据
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static void show(int[] arr){
        System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
}

二、冒泡排序

i用来表示进行多少轮比较；j表示比较的角标（注意：如果用j和j+1比较时，arr.length还要再减一，为了防止【角标越界】）

角标越界在 JAVA数组篇描述过。

import java.util.*;
public class bubble{
    public static void main(String[] args){
        bubbleSort();
    }
    public static void bubbleSort(){
        int[] arr = {2,6,4,3,5,1,8,9,7};
        for(int i=0;i<arr.length-1;i++){
            for(int j=1;j<arr.length-i;j++){
                if(arr[j-1]>arr[j]){
                    swap(arr,j);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static void swap(int[] arr,int j){
        int temp = arr[j];
        arr[j] = arr[j-1];
        arr[j-1] = temp;
    }
}

三、插入排序

插入排序顾名思义就是用插入的方式进行排序，就相当于麻将一样，（同类型）每张牌与左边的牌相比较若小于它，则与它交换位置。

优化之后可以减少交换的次数。用e变量来保存当前数值，若前者大于e，则将前者向后移一个位置

import java.util.*;
public class insert{
    public static void main(String[] args){
        insertSort();
    }
    public static void insertSort(){
        int[] arr = {1,5,3,4,6,2,9,8,7};
        //优化之后的代码
        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);
            }
        }
        */
        System.out.println(Arrays.toString(arr));
    }
    public static void swap(int[] arr,int j){
        int temp = arr[j];
        arr[j] = arr[j-1];
        arr[j-1] = temp;
    }
}

四、计数排序

上述三个排序都是根据数据之间的大小关系进行比较排序的

        计数排序是根据数据本身的特性比较 与大小无关的排序

        该排序只针对整数，是一个典型的牺牲空间换时间的排序

注意：这个偏移量的计算，利用最小值的（nums数组的角标）比如0=-10+offset=>offset=-10

import java.util.*;
public class count{
    public static void main(String[] args){
        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];
        //找数组中最大值和最小值
        for(int i=0;i<arr.length;i++){//O(n)
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] nums=new int[max-min+1];
        int offset=min;
        for(int i=0;i<arr.length;i++){//O(n)
            nums[arr[i]-offset]++;
        }
        int index=0;//O(m)
        for(int i=0;i<nums.length;i++){//遍历nums数组
            if(nums[i]!=0){
                for(int j=0;j<nums[i];j++){
                    arr[index++]=i+offset;//对原来的数组进行复制，覆盖原先角标上的数值
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}