【Java系列】七大排序篇

卑微贝贝

已于 2022-08-28 17:04:18 修改

阅读量542

点赞数

文章标签：排序算法算法 java

于 2022-07-21 20:30:01 首次发布

本文链接：https://blog.csdn.net/qq_54558971/article/details/125917460

版权

七大排序

插入排序
- 直接插入排序 —— O(n^2)
- 希尔排序 —— O(n^1.3~1.5）
选择排序
- 选择排序 —— O(n^2)
- 堆排序 —— O(nlogn)
交换排序
- 冒泡排序 —— O(n^2)
- 快速排序 —— O(nlogn)
归并排序
- 归并排序 —— O(nlogn)

其中直接插入排序、冒泡排序、归并排序具有稳定性。

一、选择排序

1、选择排序

每次从无序区间中选择一个最大或者最小的值，存放在无序区间的最前或最后的位置（此位置元素有序），直到所有数据完成排序。

public static void selectSort(int[] arr){
    for(int i = 0; i < arr.length - 1; i++){
        int min = i;
        for(int j = i + 1; j < arr.length; j++){
            if(arr[j] < arr[i]{
                min = j;
            }
        }
        swap(arr,min,i);
    }
}

2、双向选择排序

二、直接插入排序

1、直接插入排序

将集合分为，已经排序的区间[0...i）和待排序区间[i...n]。每次从待排序区间中第一个元素插入已排序区间的合适位置。

public static void insertionSort(int[] arr){
    for(int i = 1; i < arr.length; i++){
        for(int j = i; j > 0; j--){
            //保证数据的稳定性
            if(arr[j] >= arr[j - 1]){
                break;
            }else {
                swap(arr,j,j-1);
            }
        }
    }
}

2、折半插入排序

三、希尔排序

先选定一个整数（gap，gap一般都选取数组长度的½或⅓）将待排序的数组先按照gap分组，不同组之间内部使用插入排序，排序后再将gap/2或者gap/3，重复上述过程直到gap=1。此时整个数组近乎有序，此时再整体使用插入排序。

public static void shellSort(int[] arr){
    int gap = arr.length >> 1;
    while(gap > 1){
        insertionSortByGap(arr,gap);
        gap >> 1;
    }
    insertionSort(arr);
}

private static void insertionSortByGap(int[] arr, int gap){
    for(int i = gap; i < arr.length; i++){
        for(int j = i; j - gap >= 0 && arr[j] < arr[j - gap]; j -= gap){
            swap(arr, j, j-gap);
        }
    }
}

四、归并排序

将原数组不断拆分，一直拆到每个子数组只有一个元素时，第一阶段结束；将相邻的两个数组合并为一个有序的数组，直到整个数据有序。

public static void mergeSort(int[] arr){
    mergeSortInternal(arr, 0, arr.length - 1);
}

private static viod mergeSortInternal(int[] arr, int l, int r){
    if(l >= r){
        return;
    }
    int mid = l + ((r - l) >> 1);
    mergeSortInternal(arr, l, mid);
    mergeSortInternal(arr, mid + 1, r);
    if(arr[mid] > arr[mid + 1]){
        merge(arr, l, mid, r);
    }
}

private static void merge(int[] arr, int l, int mid, int r){
    int[] aux = new int[r - l + 1];
    for(int i = 0; i < aux.length; i++){
        aux[i] = arr[i + l];
    }
    int i = l;
    int j = mid + 1;
    for(int k = l; k <= r; k++){
        if(i > mid){
            //左区间处理完毕
            arr[k] = aux[j - l];
            j++;
        }else if(j > r){
            //右区间处理完毕
            arr[k] = aux[i - l];
            i++;
        }else if(aux[i - l] <= aux[j - l]){
            //左侧元素更小
            arr[k] = aux[i - l];
            i++;
        }else {
            arr[k] = aux[j - l];
            j++;
        }
    }
}

五、快速排序

1、快速排序

如图，v是基准值，将小于v的放入区间（l,j]，大于v的放入区间（j,i），索引 i 指向待排序元素。区分完成后在大于v，小于v区间重复上述流程，直到整个集合有序。

小于v

大于v

l j i

若arr[i] > v 则 i++；

若arr[i] < v 则 swap(arr, i, j+1)；

public static void quickSort(int[] arr){
    quickSortInternal(arr,0,arr.length - 1);
}

private static void quickSortInternal(int[] arr,int l, int r){
    if(l >= r){
        return;
    }
    int p = partition(arr, l, r);
    quickSortInternal(arr, l, p-1);
    quickSortInternal(arr, p+1,r);
}

private static int partition(int[] arr, int l,int r){
    int v = arr[l];
    int j = l;
    for(int i = l + 1; i <= r; i++){
        if(arr[i] < v){
            swap(arr, i, j+1);
            j++;
        }
    }
    swap(arr, l, j);
    return j;
}

2、二路快排

3、挖坑法

4、三路快排

六、堆排序

public static void heapSort(int[] arr){
    //找到最后一个非叶子节点，进行下沉操作
    for(int i = (arr.length - 1 - 1) >> 1; i >=0; i--){
        siftDown(arr, i, arr.length);
    }
    //把最大的交换到最后一个，再进行下沉交换的过程，逐渐将最大的都换到后面去
    for(int i = arr.length - 1; i > 0; i--){
        swap(arr, 0, i);
        siftDown(arr, 0, i);
    }
}    

private static void siftDown(int[] arr,int i, int length){
    while(2 * i + 1 < length){
        int j = (i << 1) + 1;
        if(j + 1 < length && arr[j + 1] > arr[j]){
            j = j + 1;
        }
        if(arr[i] > arr[j]){
            break;
        }else {
            swap(arr, i, j);
            i = j;
        }
    }
}

七、冒泡排序

public static void bubbleSort(int[] arr){
    for(int i = 0; i < arr.length; i++){
        boolean isSwaped = false;
        for(int j = 0; j< arr.length - i - 1; j++){
            if(arr[j] > arr[j + 1]){
                swap(arr, j, j+1);
                isSwaped = true;
            }
        }
        if(!isSwaped){
            break;
        }
    }
}