常见一维数组的排序方法

选择排序法

选择排序的核心思想：当前元素和后面的元素进行比较如果比以后的元素小，则两者交换。

class Test02{
    public static void main(String[] args){
        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){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;        
    }
      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);
    }
}

图示为选择排序的过程，牺牲空间和内存比较大。

冒泡排序法

冒泡排序法是从左往右以及进行比较，同样也是如果后者比前者的值大，则互相交换位置。每一次循环都会将该次循环的最大值寻找出来，然后将其顺序排好。

 

class Test02{
    public static void main(String[] args){
          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){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;        
    }
      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);
    }
}

图示为冒泡的过程，牺牲空间和内存比较大，同样的算法复杂度相对比较高。

插入排序法

显示生活中打麻将已经不知不觉中使用到了冒泡排序法。一个数列，从左边先开始，第一个除外，只要第二个大于第一个数则两者就交换位置。这样一次遍历到数列的结尾，也就将一组数据排序好了。

class Test02{
    public static void main(String[] args){
         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;
        }
        /*
        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 swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;        
       }

      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);
    }
}

 

计数排序法

计数 基数 桶 都是根据数据本身的特性比较 与大小无关的排序 这些排序只针对整数 是一个典型的牺牲空间换时间的排序方法。

 

class Test02{
    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;
        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){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;        
       }

      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);
    }
}

 这个计数排序法和上面的几个排序方法最大区别就是，它没有直接用数字的大小属性来判断顺序问题，而是以数据出现次数这个属性间接的得到数字的排列顺序的。

数组扩容

数组扩容是数组的一个比较重要的特性，在原先数组长度基础上，创建一个新数组新数组长度为原来数组长度+n。之后再将原来数组的所有元素遍历一遍交给新数组。之后将新数组地址返回给原先数组名即可。

 

import java.util.*;
/*
数组扩容，其实就是创建一个新的数组，将元素赋值进去之后将新的地址返回即可
*/ 
class test3{
    public static void main(String [] args){
        int[] arr=new int[]{1,2,3};
        arr=copyOf(arr,arr.length+1);
        arr[arr.length-1]=5;
        System.out.println(Arrays.toString(arr));
    }

    public static int[] copyOf(int[] arr,int newlen){
        int[] newarr=new int[newlen];
        for(int i=0;i<arr.length;i++){
            newarr[i]=arr[i];
        }

        return newarr;
    }
}