Java算法实践之排序(一)

1.冒泡排序

• 时间复杂度（平均）：O(n²)
• 稳定

private static void bubbleSort(int[] arr) {
    int temp;
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-i-1; j++) {
            if (arr[j]>arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

2.选择排序

• 时间复杂度：O(n²)
• 不稳定

private static void selectSort(int[] arr) {
    int temp, minIndex;
    for (int i = 0; i < arr.length-1; i++) {
        minIndex = i;
        for (int j = i+1; j < arr.length; j++) {
            if (arr[minIndex] > arr[j]) {
                minIndex = j;//保存最小值的索引
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

3.插入排序

• 时间复杂度（平均）：O(n²)
• 稳定

private static void insertSort(int[] arr) {
    int preIndex,current;
    for (int i = 1; i < arr.length; i++) {//对第i个数进行插入排序
        preIndex = i - 1;//与第preIndex个数作比较
        current = arr[i];//取出arr[i]的值
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];//比current大的数后移一位
            preIndex--;
        }
        arr[preIndex + 1] = current;//插入
    }
}

4.希尔排序

• 时间复杂度（平均）：O(n^1.3)
• 不稳定

private static void shellSort(int[] arr) {
    int preIndex,current;
    //增量gap，并逐步缩小增量
    for(int gap=arr.length/2;gap>0;gap/=2){
        //从第gap个元素，逐个对其所在组进行直接插入排序操作
        for(int i=gap;i<arr.length;i++){
            preIndex = i - gap;
            current = arr[i];
            while (preIndex >= 0 && arr[preIndex] > current) {
                arr[preIndex + gap] = arr[preIndex];//比current大的数后移一位
                preIndex-=gap;
            }
            arr[preIndex + gap] = current;//插入
        }
    }
}

5.归并排序

• 时间复杂度（平均）：O(n*log₂n)
• 空间复杂度：O(n)
• 稳定

private static void mergeSort(int[] arr) {
    int[] tempArr = new int[arr.length];
    mergeArray(arr, 0, arr.length-1, tempArr);
}

private static void mergeArray(int[] arr, int left, int right, int[] tempArr) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeArray(arr, left, mid, tempArr);//左边归并排序
        mergeArray(arr, mid+1, right, tempArr);//右边归并排序
        merge(arr, left, mid, right, tempArr);//合并有序子数组
    }
}

private static void merge(int[] arr, int left, int mid, int right, int[] tempArr) {
    int i = left;//左序列指针
    int j = mid + 1;//右序列指针
    int temp = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {//左右序列比较，小的先放入数组
            tempArr[temp++] = arr[i++];
        } else {
            tempArr[temp++] = arr[j++];
        }
    }
    //左序列剩余元素填充
    while (i <= mid) {
        tempArr[temp++] = arr[i++];
    }
    //右序列剩余元素填充
    while (j <= right) {
        tempArr[temp++] = arr[j++];
    }
    //数组拷贝
    temp = 0;
    while (left <= right) {
        arr[left++] = tempArr[temp++];
    }
}

6.快速排序

• 时间复杂度（平均）：O(n*log₂n)
• 空间复杂度：O(n*log₂n)
• 不稳定

private static void quickSort(int[] arr, int left, int right) {
    int pivot;
    if (left < right) {
        pivot = partition(arr, left, right);
        quickSort(arr, left, pivot-1);
        quickSort(arr, pivot+1, right);
    }
}

private static int partition(int[] arr, int left, int right) {
    int i = left;
    int j = right;
    int temp;
    while (i < j) {
        //由j开始从后往前找，找到第一个比arr[i]小的数
        while (i < j && arr[i] <= arr[j]) {
            j--;
        }
        //交换
        if (i < j) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
        }
        //由i开始从前往前后找，找到第一个比arr[j]大的数
        while (i < j && arr[i] <= arr[j]) {
            i++;
        }
        //交换
        if (i < j) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            j--;
        }
    }
    //arr[i]前面的数比arr[i]小，后面的数比arr[i]大
    return i;
}

总结

实现代码下载：https://download.csdn.net/download/ca_co3/10559448