Java数据结构——排序

码仔~

已于 2024-10-09 18:37:56 修改

阅读量623

点赞数 13

文章标签：数据结构 java

于 2024-09-04 22:03:24 首次发布

本文链接：https://blog.csdn.net/2302_76435884/article/details/141828315

版权

前言：

掌握七大基于比较的排序算法基本原理及实现
掌握排序算法的性能分析
掌握Java中的常用排序方法

1.概念

1.1 排序

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

平时的上下文中，如果提到排序，通常指的是排升序（非降序）。

通常意义上的排序，都是指的是原地排序。

1.2稳定性（重要）

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

2.七大基于比较的排序-总览

3.插入排序

3.1直接插入排序-原理

整个区间被分为：

有序区间
无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入：

如下图（画下划线的为有序区间）：

3.2 实现

public static void insertSort(int[] array) {
    for (int i = 1; i < array.length; i++) { //无序区间
        // 有序区间: [0, i)
        // 无序区间: [i, array.length)
        int v = array[i]; // 无序区间的第一个数，保存下来（哨兵法）
        int j = i - 1;
        // 不写 array[j] == v 是保证排序的稳定性
           //在有序区间中排序
        for (; j >= 0 && array[j] > v; j--) {
            array[j + 1] = array[j];//数往前移
       }
        //发现移不动时，把v放到对应位置
        array[j + 1] = v;
   }
}

3.3性能分析

稳定性：稳定

插入排序，初始数据越接近有序，时间效率越高。

4. 希尔排序

4.1原理

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为相同记录的分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

希尔排序实际上就是插入排序的升级版

4.2 代码实现

public static void shellSort(int[] array) {
    int gap = array.length;
    while (gap > 1) {
        insertSortGap(array, gap);
        gap = (gap / 3) + 1; // 或 gap = gap / 2;
   }
    insertSortGap(array, 1);
}
//插入排序
private static void insertSortGap(int[] array, int gap) {
    for (int i = 1; i < array.length; i++) {
        int v = array[i];
        int j = i - gap;
        for (; j >= 0 && array[j] > v; j -= gap) {
            array[j + gap] = array[j];
       }
        array[j + gap] = v;
   }
}

4.3性能分析

稳定性：不稳定

5.选择排序

5.1直接选择排序原理

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完。

5.2 实现

//把大的值都往后面放
public static void selectSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        // 无序区间: [0, array.length - i)
        // 有序区间: [array.length - i, array.length)
        int max = 0;
        //先找出最大的值
        for (int j = 1; j < array.length - i; j++) {
            if (array[j] > array[max]) {
                max = j;
           }
       }
        //把最大的值放到后面
        int t = array[max];
        array[max] = array[array.length - i - 1];
        array[array.length - i - 1] = t;
   }
}

5.3 性能分析

稳定：不稳定

int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别，保证 5a 还在 5b 前边

6.堆排序

6.1原理

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。

注意：排升序要建大堆；排降序要建小堆。

如图：

6.2 实现

public static void heapSort(int[] array) {
    createHeap(array);
    for (int i = 0; i < array.length - 1; i++) {
        // 交换前
        // 无序区间: [0, array.length - i)
        // 有序区间: [array.length - i, array.length)
        swap(array, 0, array.length - i - 1);
        // 交换后
        // 无序区间: [0, array.length - i - 1)
        // 有序区间: [array.length - i - 1, array.length)
        // 无序区间长度: array.length - i - 1
        shiftDown(array, array.length - i - 1, 0);
   }
}
private void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t;
}
private void createHeap(int[] array) {
    for (int i = (array.length - 1) / 2; i >= 0; i--) {
        shiftDown(array, array.length, i);
   }
}
public static void shiftDown(int[] array, int size, int index) {
    int left = 2 * index + 1;
    while (left < size) {
        int max = left;
   int right = 2 * index + 2;
        if (right < size) {
            if (array[right] > array[left]) {
                max = right;
           }
       }
        
        if (array[index] >= array[max]) {
            break;
       }
        
        int t = array[index];
        array[index] = array[max];
        array[max] = t;
        
        index = max;
        left = 2 * index + 1;
   }
}

6.3性能分析

7.冒泡排序

7.1原理

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

7.2实现

public static void bubbleSort(int[] array) { 
     for (int i = 0; i < array.length - 1; i++) { 
         boolean isSorted = true; 
         for (int j = 0; j < array.length - i - 1; j++) { 
         // 相等不交换，保证稳定性
             if (array[j] > array[j + 1]) { 
                 swap(array, j, j + 1); 
                 isSorted = false; 
             } 
         } 
         if (isSorted) { 
             break; 
         } 
     } 
}

7.3性能分析

稳定性：稳定

8.快速排序（重要）

8.1原理-总览

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

动画理解：

9月4日

（只介绍）挖坑法：

代码实现：

public static void quickSort(int[] array) { 
     quickSortInternal(array, 0, array.length - 1); 
} 
// [left, right] 为待排序区间
private static void quickSortInternal(int[] array, int left, int right) { 
     if (left == right) { 
         return; 
     } 
     if (left > right) { 
         return; 
     } 
 // 最简单的选择基准值的方式，选择 array[left] 作为基准值
 // pivotIndex 代表基准值最终停留的下标
     int pivotIndex = partition(array, left, right); 
 // [left, pivotIndex - 1] 都是小于等于基准值的
 // [pivotIndex + 1, right] 都是大于等于基准值的
     quickSortInternal(array, left, pivotIndex - 1); 
     quickSortInternal(array, pivotIndex + 1, right); 
} 
private static int partition(int[] array, int left, int right) { 
     int i = left; 
     int j = right; 
     int pivot = array[left]; 
     while (i < j) { 
         while (i < j && array[j] >= pivot) { 
             j--; 
         } 
     array[i] = array[j]; 
     while (i < j && array[i] <= pivot) { 
             i++; 
     } 
     array[j] = array[i]; 
     } 
     array[i] = pivot; 
     return i; 
}