排序（选择、冒泡，插入、计数）

选择排序

选择排序就是从第一个元素开始，按照顺序和后边所有的元素比较大小，如果比后面数字大，则进行交换。直到排完所有等待排序的数据元素为止。

图示：

代码如下：

class paixu{
    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);//即用-即释放
                }
            }
        }
        show(arr);
    }
    public static void swap(int[] arr,int i,int j){
        //1.借助三方变量进行交换 
        //适用于所有的数据类型 比较通用
        /*
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
        */
        //2.借助加减法运算进行交换
        //只适用于数字相关的数据类型
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

        //3.借助位运算进行交换
        //只适用于整数相关的数据类型
       
    }
    public static void show(int[] arr){
        //[1,2,3,4,5,6,7,8,9]
        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);
    }
}

冒泡排序

冒泡排序，就是从第一个数据元素开始，从左到右两个相邻元素依次向后进行比较，如果前者比后者大，则进行交换。

每比较完成一轮，有一个最大的数字“下沉”到最后。

图示：

 

代码实现：

class paixu{
    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-1-i;j++){//-1避免重复比较和角标越界
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        show(arr);
    }
   
    }
    public static void swap(int[] arr,int i,int j){
     
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

    }
    public static void show(int[] arr){
        //[1,2,3,4,5,6,7,8,9]
        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);
    }
}

 

插入排序

插入排序，如果当前的数字左边有数字，且左边的数字大于当前的数字，则交换位置。

基本思想：

每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。

代码实现如下：

class paixu{
    public static void main(String[] args){
       
        //3.插入排序O(n^2) 
        insertSort();
       

    }
    
    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;
        }
    
        show(arr);
    }
   
    public static void swap(int[] arr,int i,int j){
       
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

   
    }
    public static void show(int[] arr){
        //[1,2,3,4,5,6,7,8,9]
        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);
    }
}

计数排序

计数排序不是基于元素比较，而是利用数组下标来确定元素的正确位置。

具体的说就是，如果有一串数列如：2，1，1，5，4，6，9，8，7，4，1；已知整数的取值范围是从0到9，那么这些整数的值肯定是在0到9这10个数里面。于是我们可以建立一个长度为10的数组，数组下标从0到9，元素初始值全为0。

遍历这个无序的随机数组，每一个整数按照其值对号入座，对应数组下标的元素进行加1操作。

遍历前：

遍历完成后：

代码实现如下：

class paixu{
    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];
        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;
        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 swap(int[] arr,int i,int j){
     
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

   
    }
    public static void show(int[] arr){
        //[1,2,3,4,5,6,7,8,9]
        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);
    }
}