常用排序算法的java实现

/**
 * 冒泡排序
 * 时间复杂度： 最小 = O(n), 最大 = O(n^2), 平均 = O(n^2)
 *
 * @param data 待排序序列
 * @return
 */
public static int[] bubbleSort(int[] data) {
    if (data == null || data.length == 0 || data.length == 1) return data;

    boolean flag = false; //是否继续排序
    for (int i = 0; i < data.length - 1; i++) {
        for (int j = 0; j < data.length - 1 - i; j++) {
            if (data[j] > data[j + 1]){
                int temp = data[j + 1];
                data[j + 1] = data[j];
                data[j] = temp;
                flag = true; //继续排序
            }
        }
        if(flag == false){
            break; //排序完成，不再继续
        } else{
            flag = false;
        }
    }
    return data;
}

/**
 * 选择排序
 * 时间复杂度： 最小 = O(n^2), 最大 = O(n^2), 平均 = O(n^2)
 *
 * @param data 待排序序列
 * @return
 */
public static int[] selectionSort(int[] data){
    if(data == null || data.length == 0 || data.length == 1) return data;

    for(int i = 0; i < data.length - 1; i++){
        int min = data[i];
        int minIndex = i;

        for(int j = i + 1; j < data.length; j++){
            if(data[j] < min){
                min = data[j];
                minIndex = j;
            }
        }
        int temp = data[i];
        data[i] = data[minIndex];
        data[minIndex] = temp;
    }
    return data;
}

/**
 * 插入排序——解法1
 * 时间复杂度： 最小 = O(n), 最大 = O(n^2), 平均 = O(n^2)
 *
 * @param data 待排序序列
 * @return
 */
public static int[] insertSort1(int[] data){
    if(data == null || data.length == 0 || data.length == 1) return data;

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

    return data;
}

/**
 * 插入排序——解法2
 * 时间复杂度： 最小 = O(n), 最大 = O(n^2), 平均 = O(n^2)
 *
 * @param data 待排序数组
 * @return
 */
public static int[] insertSort2(int[] data){
    if(data == null || data.length == 0 || data.length == 1) return data;

    int cur = -1; //当前待插入的数
    int preIndex = -1; //待插入位置的上一个数
    for(int i = 1; i < data.length; i++){
        cur = data[i];
        preIndex = i - 1;
        while(preIndex >= 0 && data[preIndex] > cur){
            data[preIndex + 1] = data[preIndex];
            preIndex--;
        }
        data[preIndex + 1] = cur;
    }
    return data;
}

/**
 * 希尔排序
 * 时间复杂度： 最小 = O(nlog2n), 最大 = O(nlog2n), 平均 = O(nlog2n)
 *
 * @param data 待排序数组
 * @return
 */
public static int[] shellSort(int[] data){
    if(data == null || data.length == 0 || data.length == 1) return data;

    int len = data.length;
    int gap = len / 2; //希尔增量
    int cur = -1; //当前待插入的数
    int preIndex = -1; //待插入位置的上一个数
    while(gap > 0){
        for(int i = gap; i < len; i++){
            cur = data[i];
            preIndex = i - gap;
            while(preIndex >= 0 && data[preIndex] > cur){
                data[preIndex + gap] = data[preIndex];
                preIndex -= gap;
            }
            data[preIndex + gap] = cur;
        }
        gap /= 2;
    }
    return data;
}

/**
 * 归并排序
 * 时间复杂度： 最小 = O(nlog2n), 最大 = O(nlog2n), 平均 = O(nlog2n)
 *
 * @param data
 */
public static void mergeSort(int[] data){
    mergeSortMain(data, 0, data.length - 1);
}

public static void mergeSortMain(int[] data, int low, int high){
    if(low < high){
        int mid = low + (high - low) / 2;
        System.out.println("low=" + low + "; mid=" + mid + "; high=" + high);
        mergeSortMain(data, low, mid); //左数组
        mergeSortMain(data, mid + 1, high); //右数组
        merge(data, low, mid, high); //左右对比合并
    }
}

public static void merge(int[] data, int low, int mid, int high){
    int[] temp = new int[high - low + 1]; //用于存放左右数组合并结果
    int i = low; //左数组的遍历下标
    int j = mid + 1; //右数组的遍历下标
    int k = 0; //temp的遍历下标

    //对比左右数组，将对比结果存入temp中（并移动对应遍历下标i或者j）
    while(i <= mid && j <= high){
        if(data[j] <= data[i]){
            temp[k++] = data[j++];
        } else{
            temp[k++] = data[i++];
        }
    }

    //将左数组剩余的数据存入temp中
    while(i <= mid){
        temp[k++] = data[i++];
    }

    //将右数组剩余的数据存入temp中
    while(j <= high){
        temp[k++] = data[j++];
    }

    //将左右数组合并结果写回待排序数组中
    for(int k2 = 0; k2 < temp.length; k2++){
        data[low++] = temp[k2];
    }
}

/**
 * 快速排序——初始调用
 * 时间复杂度： 最小 = O(nlogn), 最大 = O(n^2), 平均 = O(nlogn)
 *
 * @param arr
 */
public static void quickSort(int[] arr) {
    qSort(arr, 0, arr.length - 1);
}

/**
 * 快速排序——递归调用
 * @param arr
 * @param low
 * @param high
 */
public static void qSort(int[] arr, int low, int high) {
    if(low >= high) return;

    int pivotIndex = divideCurArrAndGetPivotIndex(arr, low, high); //左右划分当前数组并返回枢轴位置
    System.out.println("qSort(...) low=" + low + "; high=" + high + "; pivotIndex=" + pivotIndex);
    qSort(arr, low, pivotIndex - 1); //对左数组继续划分
    qSort(arr, pivotIndex + 1, high); //对右数组继续划分
}

/**
 * 快速排序——递归体
 * @param arr
 * @param low
 * @param high
 * @return
 */
public static int divideCurArrAndGetPivotIndex(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;
}





public static void main(String[] args){
    int[] data = {3, 44, 38, 5, 47, 15, 2, 1, 11};

    // 冒泡排序
    //bubbleSort(data);

    // 选择排序
    //selectionSort(data);

    // 插入排序
    //insertSort1(data);
    //insertSort2(data);

    // 希尔排序
    //shellSort(data);

    // 归并排序
    //mergeSort(data);

    // 快速排序
    quickSort(data);
    System.out.println("排序结果：" + Arrays.toString(data));
}