排序算法

`
package com.six.prac;

public class Sort {

/**
 * 冒泡排序 时间复杂度 T = O(n²)
 * @param arrs
 * @return
 */
public static int[] maopao(int[] arrs){

    for(int i=0; i < arrs.length ; i++){
        for (int j=0; j < arrs.length - 1 - i; j++){
            if(arrs[j] > arrs[j+1]){
                int temp;
                temp = arrs[j + 1];
                arrs[j + 1] = arrs[j];
                arrs[j] = temp;
            }
        }
    }
    return arrs;
}

/**
 * 选择排序 时间复杂度 T = O(n²)
 * @param arrs
 * @return
 */
public static  int[] xuanze(int[] arrs){
    for(int i=0 ; i < arrs.length ; i++){
        for (int j=i ; j < arrs.length ; j++){
            if(arrs[j] < arrs[i]){
                int temp;
                temp = arrs[j];
                arrs[j] = arrs[i];
                arrs[i] = temp;
            }
        }
    }
    return arrs;
}

/**
 * 插入排序 时间复杂度 T = O(n²)
 * @param arrs
 * @return
 */
public static int[] charu(int[] arrs){

    for(int i=0 ; i < arrs.length ; i++){
        int key = arrs[i];
        int j = i-1;
        while ((j>=0) && (arrs[j]>key) ){
            arrs[j+1] = arrs[j];
            j--;
        }
        arrs[j+1] = key;
    }

    return arrs;
}

/**
 * 希尔排序 时间复杂度 T = O(nlog2n)
 * @param arrs
 * @return
 */
public static int[] xier(int[] arrs){
    int len = arrs.length;

    while (true){
        len /= 2;
        for(int i = 0 ; i < len ; i++){
            for(int j = i + len ; j < arrs.length;  j += len ){
                int k = j - len;
                while ( k >= 0 && arrs[k] > arrs[k+len]){
                    int temp = arrs[k];
                    arrs[k] = arrs[k+len];
                    arrs[k+len] = temp;
                    k -= len;
                }
            }
        }
        if(len == 1){
            break;
        }
    }

    return arrs;
}


/**
 *  归并排序 时间复杂度 T = O(nlogn)
 * @param nums
 * @param start
 * @param end
 * @return
 */
public static int[] guibing(int[] nums, int start, int end) {
    if(start == end){
        return new int[]{nums[start]};
    }

    int mid = start + (end - start) / 2;

    int[] leftNums = guibing(nums,start,mid);
    int[] rightNums = guibing(nums,mid+1,end);
    int[] newNums = new int[leftNums.length+rightNums.length];

    int m=0,i=0,j=0;

    while (i<leftNums.length && j < rightNums.length){
        newNums[m++] = leftNums[i] <= rightNums[j] ? leftNums[i++] : rightNums[j++];
    }

    while (i<leftNums.length){
        newNums[m++] = leftNums[i++];
    }
    while (j<rightNums.length){
        newNums[m++] = rightNums[j++];
    }

    return newNums;
}


/**
 * 快速排序 时间复杂度 T = O(nlogn)
 * @param arrs
 * @param start
 * @param end
 */
public static void kuaishu(int[] arrs,int start,int end){
    if(start >= end){
        return ;
    }
    int i = start;
    int j = end;

    int key = arrs[start];

    while (i < j){
        while (i<j && arrs[j] >= key){
            j--;
        }
        if(i < j){
            arrs[i] = arrs[j];
            i++;
        }
        while (i<j && arrs[i] < key){
            i++;
        }
        if(i<j){
            arrs[j] = arrs[i];
            j--;
        }
    }
    arrs[i] = key;
    kuaishu(arrs,start,i-1);
    kuaishu(arrs,i+1,end);


}

}

`