排序算法

排序算法

冒泡排序

平均时间复杂度:o(n^2)
最差时间复杂度：o(n^2) 倒序
最好时间复杂度：o(n) 顺序
稳定性：稳定
思路：每次找到最大的，置于末位，

        int[] arr = {3,54,32,5,7,68,2,5};
        int n=arr.length;
        for(int i = 0;i<n;i++){
            for(int j = 0;j<n-i-1;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
    public static void swap(int[] arr,int m ,int n ){
        int temp=arr[m];
        arr[m]=arr[n];
        arr[n]=temp;
    } 

选择排序

平均时间复杂度：o(n^2)
最好时间复杂度：o(n^2)
最坏时间复杂度： o(n^2）
不稳定
每次选择最小值放在第一位

int[] arr = {3,54,32,5,7,68,2,5};
        int n=arr.length;
        for(int i = 0;i<n;i++){
            int a=arr[i];
            for(int j = i+1;j<n-1;j++){
                if(a>arr[j]){
                    a=arr[j];
                    arr[j]=arr[i];
                }
            }

插入排序

时间复杂度： o(n^2）
最好时间复杂度：o(n)
最坏时间复杂度： o(n^2）
稳定
每次添加一位成为有序子序列

 int[] arr = {3,54,32,5,7,68,2,5};
        int n=arr.length;
        for(int i = 1;i<n;i++){
            int p=arr[i];
            int j=i-1;
            while(j>=0 && p<arr[j]){
                arr[j]=arr[j-1];
                j--;
            }
            arr[j+1]=p;
        }

归并排序

时间复杂度 o(nlgn）
稳定
将序列分为两半，再进行合并

 public void sort(int[] arr){
        if(arr.length!=0){
            mergesort(arr,0,arr.length-1);
        }
    }
    public void mergesort(int[] arr,int left,int right){
        if(left==right){
            return;
        }
        int mid=(left+right)/2;
        mergesort(arr,left,mid);
        mergesort(arr,mid+1,right);
        merge(arr,right,left,mid);
    }
    public void merge(int[]arr, int right,int left,int mid){
        //两个已经排序的数组 left mid   mid+1，right
        int len=right-left+1;
        int[] temp=new int[len];
        int index=0;
        int i=left;
        int j=mid+1;
        while(i<=mid &&j<=right){
            if(arr[i]<=arr[j]){
                temp[index]=arr[i];
                index++;
                i++;
            }else {
                temp[index]=arr[j];
                index++;
                j++;
            }
        }
        while (i<=mid){
            temp[index++]=arr[i++];
        }
        while (j<=right){
            temp[index++]=arr[j++];
        }
        for(int x=0;x<len;x++){
            arr[left++]=temp[x++];
        }
    }

快速排序

时间复杂度o(nlogn)
最差时间复杂度 n^2
不稳定
将序列分为大于标志位和小于标志位的两半

 public void quickSortHelp(int[] arr,int low,int high){
        if(low<high){
            int pivot= partition(arr,low,high);
            quickSortHelp(arr,low,pivot-1);
            quickSortHelp(arr,pivot+1,high);
        }
    }
    public int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high && arr[high]>pivot){
                high--;
            }
            arr[low]=arr[high];
            while(low<high && arr[low]<pivot){
                low++;
            }
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }