常见排序算法Java实现及复杂度总结

1、冒泡排序

public class SortAlgorithm {
    //1、冒泡排序bubbleSort
    public static void bubbleSort(int[] num){
        int len = num.length;
        for(int i =len-1; i>0;i--){
            for(int j=0; j<=i-1;j++){
                if(num[j]>num[j+1]){
                    swap(num,j,j+1);
                }
            }
        }

    }
    public static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }

3、插入排序

public static void insertSort(int[] arr){
        /*
        * 思路：从第二个数开始，把当前数字插入前面已经排序好的数组中，从拍好序的数组的尾部开始，如果数组中元素大于当前
        * 数，那么把数组中的数向后挪一位，知道找到当前数字合适的位置
        * */
        int temp;
        int len = arr.length;
        for(int i = 1; i<len;i++){
            int j=i-1;
            temp = arr[i];

            while(j>=0){
                if(arr[j]>temp){
                    arr[j+1] = arr[j];
                    j--;
                }
                else{
                    break;
                }
            }
            j++;
            arr[j] = temp;
        }
    }

4、堆排序

public static void heapSort(int[] arr){
        /*
        * 思路：首先要对用数组创建一个最大堆，然后把第一个数和最后一个数交换，然后对第一个数
        * 到倒数第二个数调整顺序，创建新的最大堆，然后把新的第一个数和倒数第二个数交换，以此类推
        * */
        int len = arr.length;
        for(int parent = (len-1)/2; parent>=0;parent--){
            adjustHeap(arr,parent,len);
        }
        int lastLeaf = len-1;

        while(lastLeaf>=1){
           // System.out.println("lastLeaf:" + lastLeaf);
            swap(arr,0,lastLeaf);
            /*
            for(int parent = (lastLeaf-1)/2; parent>=0;parent--){
                adjustHeap(arr,parent,lastLeaf);
            }*/
            adjustHeap(arr,0,lastLeaf);
            lastLeaf--;
        }


    }
    public static void adjustHeap(int[] arr, int parent,int len){
        /*
        * 思路：从最后一个父节点开始，如果有子节点大于父节点，那么把子节点和父节点交换，
        * 直到交换到叶子结点，然后对前一个父节点执行上述动作，直到对根节点执行完此操作
        * */
       // int len = arr.length;
        while((parent*2+1)<len){
            int left = parent*2+1;
            if(parent*2+2<len){
                int right = parent*2+2;
                if(arr[left]<arr[right]){
                    swap(arr,left,right);
                }
            }
            //System.out.println(left);
            if(arr[parent]<arr[left]){
                swap(arr,left,parent);
            }
            parent = parent*2+1;
        }
    }
 public static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }

5、归并排序

public static void mergeSort(int[] arr){
        /*
        * 思路：先递归的调用sort函数把数组平均分为两组，然后用merge函数把分开的每个组排序并合并起来
        * */
        sort(arr,0,arr.length-1);
    }
    public static void sort(int[] arr, int begin, int end){
        if(begin>=end){
            return;
        }
        int meddle = (begin+end)/2;
        sort(arr,begin,meddle);
        sort(arr,meddle+1,end);
        merge(arr,begin,meddle,end);
    }
    public static void merge(int[] arr, int begin, int meddle, int end){
        int[] newArr = new int[end-begin+1];
        //从begin到meddle，和meddle+1到end中，把小的数放进newArr中
        int newIndex=0;
        int i=begin;
        int j = meddle+1;
        while(i<=meddle && j<=end){
            if(arr[i]>arr[j]){
                newArr[newIndex++] = arr[j++];
            }
            else{
                newArr[newIndex++] = arr[i++];
            }
        }
        while(i<=meddle){
            newArr[newIndex++] = arr[i++];
        }
        while(j<=end){
            newArr[newIndex++] = arr[j++];
        }
        //更新把排序好的newArr更新到arr对应的位置中
        for(int k = begin;k<=end;k++){
            arr[k] = newArr[k-begin];
        }
    }

6、快速排序

public static void qsort(int[] arr){
        if(arr == null || arr.length <=1 ){
            return;
        }
        partition(arr,0,arr.length-1);
    }
    public static void partition(int[] arr, int begin, int end){
        if(arr == null || begin>=end){
            return;
        }

        int small = begin-1;
        for(int index = begin; index<end;index++){
            if(arr[index]<arr[end]){
                small++;
                //System.out.println(small);
                if(index != small){
                    swap(arr,index,small);
                }
            }
        }
        small++;
        swap(arr,small,end);
        partition(arr,begin,small-1);
        partition(arr,small+1,end);
    }
    public static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }

2、选择排序

public static void selectSort(int[] arr){
        /*
        * 思路：找到数组中最小的数，把他与第一个数交换，然后忽视第一个数，继续选出除了第一个数的最小的数，将这个最小的数与
        * 第二个数交换，以此类推
        * */
        int len = arr.length;
        for(int i =0; i<len-1;i++){
            int minIndex = i;
            for(int j = i;j<len;j++){
                if(arr[j]<arr[minIndex]){
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);
        }

    }
public static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }

各个算法的时间复杂度和空间复杂度以及稳定性：