Java算法排序算法总结

1.选择排序

思想：首先是遍历一遍数组找最小值，并记录当前最小值得索引，将该最小值与第一个索引位置（index）的值交换位置，这样第一步后整体数组最小值就来到了数组第一个位置，并固定。index位置又移，即下一次遍历数组后将次小值与数组第二个位置的值交换位置，以此方式一只遍历n-1次。

时间复杂度：O(n^2)，空间复杂度：O(1)，稳定性：不稳定。

代码如下：

 public static  void selectSort(int[] arr){
        if(arr.length< 2 || arr==null ){
            return;
        }
        for(int i= 0 ; i < arr.length;i++){
            int minIndex=i;
            for(int j=i+1;j < arr.length;j++){
                minIndex=arr[j]<arr[minIndex] ? j:minIndex;
            }
            swp(arr,i,minIndex);
        }
    }
    public static void swp(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

2.冒泡排序

思想：相邻两个数比较大小，如果左边数比右边数大，则交换两个数，否则不交换，依次比较，一轮过后，最大的数到了最后索引的位置，并固定。连续多轮此番操作。

时间复杂度：O(n^2)，空间复杂度：O(1)，稳定性：稳定。

代码如下：

    public  static void swp(int[] arr, int a, int b){
        arr[a]=arr[a]^arr[b];
        arr[b]=arr[a]^arr[b];
        arr[a]=arr[a]^arr[b];

    }

    public  static  void rubberSort(int[] arr){
        if(arr==null || arr.length<2)return;

        for (int e = arr.length-1; e >0 ; e--) {
            for(int i=0;i<e;i++){
                if(arr[i]>arr[i+1]){
                    swp(arr,i,i+1);
                }
            }
        }
    }

3.插入排序：

思想：第一步是先保证数组在0-0索引位置的值有序，在保证0-1上有序，以此依次遍历数组，在此过程中，如果后一个数比前一个数要小，那么就让这两个数交换位置。

时间度：O(n^2)，空间复杂度：O(1)，稳定性：稳定。

代码如下：

    public  static void swp(int[] arr,int a,int b){
        arr[a]=arr[a]^arr[b];
        arr[b]=arr[a]^arr[b];
        arr[a]=arr[a]^arr[b];

    }
    public  static void insertSort(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
                swp(arr,j,j+1);
            }
        }
    }

4.归并排序

思想：首先将数组元素分成左右两半，利用递归分别将左右两边数组排好序，然后进行左右有序数组的归并操作，使得最后整个数组有序。

时间复杂度：O(nlogn），空间复杂度：O(n)，稳定性：稳定。

代码如下：

    public static void mergeSort(int[] arr){
        if(arr==null || arr.length<2)return;
        process(arr,0,arr.length-1);
    }
    public static void process(int[] arr,int L,int R){
        if(L==R){
            return;
        }
        int mid=L+((R-L)>>1);
        //将数组左半边排好序
        process(arr,L,mid);
        //将数组右半边排好序
        process(arr,mid+1,R);
        //merge方法是可以将两个排好序的局部序列，进行合并排好顺序。
        merge(arr,L,mid,R);
    }
    public  static void merge(int[] arr,int L,int M,int R){
        int[] help=new int[R-L+1];
        int i=0;
        int p1=L;
        int p2=M+1;
        while(p1<=M && p2<=R){
            help[i++]=arr[p1]<=arr[p2] ? arr[p1++]:arr[p2++];
        }
        while(p1<=M){
            help[i++]=arr[p1++];
        }
        while(p2<=R){
            help[i++]=arr[p2++];
        }
        for (int j = 0; j < help.length-1; j++) {
            arr[L+j]=help[j];
        }
    }

5.快速排序（3.0版本）

思想：快速排序3.0使用的是分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

时间复杂度：O(nlogn)，空间复杂度：O(logn)，稳定性：不稳定。

代码如下：

public static void swp(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    public static void quickSort(int[] arr){
        if(arr==null || arr.length<2)return;
        quickSort(arr,0,arr.length-1);
    }
    public static void quickSort(int[] arr,int L,int R){
        if(L<R){
            swp(arr,L+(int)(Math.random()*(R-L+1)),R);
            int[] p=partition(arr,L,R);
            quickSort(arr,L,p[0]-1);
            quickSort(arr,p[1]+1,R);
        }

    }
    public static int[] partition(int[] arr,int L,int R){
        int less=L-1;
        int more=R;
        while(L<more){
            if(arr[L]<arr[R]){
                swp(arr,++less,L++);
            }else if(arr[L]>arr[R]){
                swp(arr,--more,L);
            }else{
                L++;
            }
        }
        swp(arr,more,R);
        return new int[] {less+1,more};
    }

6.堆排序

思想：先让数组变成大根堆，再把大根堆的0索引元素和大根堆的最后一位元素交换位置，并固定最大值，再次进行局部堆化得到有序数组。

时间复杂度:O(nlogn)，空间复杂度：O(1)，稳定性：不稳定。

代码如下：

public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) return;
        //1.让数组变成大根堆
        heapInsert(arr);
        int heapSize = arr.length;
        while (heapSize > 1) {
            //2.把大根堆得0索引元素和大根堆的最后一位元素交换，并固定最大值
            swap(arr, 0, heapSize - 1);
            heapSize--;
            //3.再次局部堆化
            heapify(arr, 0, heapSize);

        }
    }

    //让给定得一个数组,让这个数组变成一个大根堆
    public static void heapInsert(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int currentIndex=i;
            int fatherIndex=(currentIndex-1)/2;
            while (arr[currentIndex]>arr[fatherIndex]){
                swap(arr,currentIndex,fatherIndex);
                currentIndex=fatherIndex;
                fatherIndex=(currentIndex-1)/2;
            }
        }
    }

    public static void heapify(int[] arr, int index, int heapSize) {
        int left = index * 2 + 1;
        while (left< heapSize) {
            int largest = (left + 1 < heapSize) && (arr[left + 1] > arr[left]) ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (index == largest) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    //数组值交换
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }