目录

排序算法

1.插入排序

2.希尔排序

3.选择排序

4.冒泡排序

5.堆排序

6.快速排序

7.归并排序

排序算法

排序算法是一类用于将数据按照特定顺序（如升序或降序）排列的算法，常用于优化数据检索和处理。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序和归并排序等。不同的排序算法在时间复杂度和空间复杂度上各有优劣，适用于不同规模和类型的数据集。选择合适的排序算法需要根据数据特点和实际应用需求进行权衡。

1.插入排序

基本思想：和前面的比，找到对应位置插入

插入排序的基本思想是通过构建一个有序序列，将未排序部分的元素逐个插入到已排序部分的合适位置。

• 初始状态：第一个元素默认视为已排序。
• 逐一插入：从第二个元素开始，依次与已排序部分的元素进行比较，将其插入到合适的位置。
• 元素移动：如果当前元素比已排序部分的某个元素小，则将已排序的元素向右移动，腾出插入位置。
• 重复过程：重复此过程，直到所有元素都被插入到正确的位置，整个数组变得有序。

// 插入排序函数
void insertionSort(int arr[], int n) {         
    int i, j, key;                              
    for (i = 1; i < n; ++i) {                  
        key = arr[i];  // 记录当前要插入的值      
        j = i - 1;                              
        // 向左移动比 key 大的元素                 
        while (j >= 0 && arr[j] > key) {       
            arr[j + 1] = arr[j];  // 元素右移   
            j--;                                
        }
        arr[j + 1] = key;  // 在找到的位置插入 key 
    }
}

2.希尔排序

基本思想：对每一个子表进行直接插入排序

希尔排序（Shell Sort）的基本思想是通过将整个数组分割成若干个子序列分别进行插入排序，从而加速排序进程。它是对插入排序的优化版本，通过逐步缩小间隔（增量）对元素进行比较和交换，使得数据在整体上趋于有序，最终再进行一次标准的插入排序来完成排序。

• 分组：希尔排序会根据一个初始增量（通常是数组长度的一半）将数据分组。组内的元素相隔该增量距离。
• 组内插入排序：对每一组内的元素执行插入排序，利用增量减少的数据交换，使得数据逐步接近有序状态。
• 缩小增量：每次排序后，将增量逐步缩小，一般缩小为原来的一半，直到增量为1。增量为1时，相当于对整个数组执行了一次标准的插入排序。
• 最终排序：由于前几轮已经将数据初步排序，最后一轮插入排序的效率会大大提高。

// 希尔排序函数
void shellSort(int arr[], int n) {
    // 初始步长为数组长度的一半，然后逐步减小步长
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 对每个步长子序列进行插入排序
        for (int i = gap; i < n; ++i) {
            int temp = arr[i];  // 保存当前元素
            int j;

            // 对步长为 gap 的子表进行直接插入排序
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];  // 将较大的元素向后移动
            }

            arr[j] = temp;  // 将当前元素插入到合适位置
        }
    }
}

3.选择排序

基本思想：先扫 再找 放入最后

选择排序（Selection Sort）的基本思想是通过反复选择未排序部分中的最小（或最大）元素，将其放到已排序部分的末尾，直到所有元素都被排序为止。其主要步骤如下：

• 初始状态：将整个数组视为未排序部分。
• 选择最小元素：在未排序部分中找到最小的元素（或最大的元素），并记录其索引。
• 交换位置：将找到的最小元素与未排序部分的第一个元素进行交换，这样该元素就被放到了已排序部分的末尾。
• 缩小范围：将已排序部分和未排序部分的边界向右移动一位，重复步骤2和3，直到所有元素都被排序。

// 选择排序函数
void selectionSort(int arr[], int n) {
    int i, j, minIndex, temp;

    // 外层循环控制已排序部分的范围
    for (i = 0; i < n - 1; i++) {
        minIndex = i;  // 假设当前元素为最小值的索引

        // 内层循环找到未排序部分的最小值
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;  // 更新最小值索引
            }
        }

        // 交换当前元素和找到的最小值
        if (minIndex != i) {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

4.冒泡排序

基本思想：从后两两对比，更小的往前放

冒泡排序（Bubble Sort）的基本思想是通过重复地比较相邻的元素并交换它们的顺序，使得较大的元素逐渐“冒泡”到数组的顶端（末尾）。这个过程不断重复，直到没有需要交换的元素为止，整个数组就变得有序。

1. 相邻比较：从数组的第一个元素开始，依次比较相邻的两个元素。
2. 元素交换：如果前一个元素大于后一个元素，就交换它们的位置。这样，每一轮后，最大的元素会“冒泡”到数组的末尾。
3. 重复过程：对整个数组进行多轮比较和交换，每一轮都将未排序部分中的最大元素移动到正确位置。
4. 优化：如果在某一轮中没有进行任何交换，说明数组已经有序，可以提前结束排序。

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    int i, j, temp;                             
    // 外层循环控制排序轮次                       
    for (i = 0; i < n - 1; ++i) {               
        // 内层循环从后往前两两比较，将较小的数往前放
        for (j = n - 1; j > i; --j) {
            if (arr[j] < arr[j - 1]) {
                // 交换两个元素
                temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

5.堆排序

基本思想：先建堆 再找数 找一次 建一次 找到数 就输出 输出完 排序完

堆排序（Heap Sort）的基本思想是利用堆这种数据结构的特性来实现排序。堆是一种完全二叉树，具有堆性质，即每个节点的值都大于或等于（最大堆）或小于或等于（最小堆）其子节点的值。堆排序的核心步骤如下：

• 构建最大堆：将待排序的数组构建成一个最大堆。最大堆的根节点是数组中最大的元素，确保父节点的值总是大于其子节点的值。

• 交换元素：将堆的根节点（即最大元素）与堆的最后一个元素交换。此时，最大元素已经放到了正确的位置。

• 调整堆：减少堆的大小，并对根节点进行调整，以恢复最大堆的性质。通过调整，新的根节点将成为新的最大元素。

• 重复操作：重复步骤2和3，直到所有元素都被排序。每次提取最大元素并调整堆时，堆的有效大小都会减小，直到堆为空。

// 交换两个元素的函数
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 调整堆，使其满足最大堆的性质
void heapify(int arr[], int n, int i) {
    int largest = i; // 初始化最大值为根节点
    int left = 2 * i + 1; // 左子节点索引
    int right = 2 * i + 2; // 右子节点索引

    // 如果左子节点比根节点大
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }

    // 如果右子节点比当前最大值大
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }

    // 如果最大值不是根节点，交换并递归调整
    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest); // 递归调整
    }
}

// 堆排序函数
void heapSort(int arr[], int n) {
    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }

    // 一个个提取元素
    for (int i = n - 1; i >= 0; i--) {
        swap(&arr[0], &arr[i]); // 将当前最大元素移到数组末尾
        heapify(arr, i, 0); // 调整堆
    }
}

6.快速排序

基本思想：小放枢轴左 大放枢轴右高低所指换 换针向枢轴高低所遇处 枢轴所落入递归再排至 左右仅一头

快速排序（Quick Sort）的基本思想是通过分治法（Divide and Conquer）来对数组进行排序。它的核心步骤如下：

• 选择枢轴：从数组中选择一个元素作为枢轴（pivot）。常见的选择方式包括选择第一个元素、最后一个元素或中间元素。

• 分区：重新排列数组，使得所有小于枢轴的元素都放在枢轴的左侧，所有大于枢轴的元素都放在右侧。经过这一步骤，枢轴的最终位置就是它在排序后数组中的正确位置。

• 递归排序：

  • 对于枢轴左侧的子数组，重复步骤1和步骤2。
  • 对于枢轴右侧的子数组，同样重复步骤1和步骤2。

• 结束条件：当子数组的大小为1或0时，递归结束，整个数组就变得有序。

// 交换两个元素的函数
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 分区函数，返回枢轴的最终位置
int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为枢轴
    int i = low - 1; // 小于枢轴的元素的索引

    // 遍历数组，将小于枢轴的元素放到左边
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++; // 增加小于枢轴的元素索引
            swap(&arr[i], &arr[j]); // 交换元素
        }
    }
    // 将枢轴放到正确的位置
    swap(&arr[i + 1], &arr[high]);
    return i + 1; // 返回枢轴的索引
}

// 快速排序函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high); // 获取分区后枢轴的位置
        quickSort(arr, low, pivotIndex - 1); // 对左半部分递归排序
        quickSort(arr, pivotIndex + 1, high); // 对右半部分递归排序
    }
}

7.归并排序

基本思想：两有序并为一有序 另建表 分别从两表头依次对比

归并排序（Merge Sort）的基本思想是利用分治法将一个待排序的数组分成多个子数组，然后通过合并操作将这些子数组合并为一个有序的数组。其主要步骤如下：

• 分割：将待排序的数组递归地分割成两个子数组，直到每个子数组的长度为1。此时每个子数组都是有序的。
• 合并：将两个已排序的子数组合并为一个有序的数组。合并时，从每个子数组的开头依次比较元素，将较小的元素放入新的数组中，直到所有元素都被合并。
• 重复操作：不断重复以上两个步骤，直到所有子数组都被合并成一个完整的有序数组。

// 合并两个有序数组
void merge(int arr[], int left, int mid, int right) {
    int i, j, k;
    int n1 = mid - left + 1; // 左子数组的大小
    int n2 = right - mid;    // 右子数组的大小

    // 创建临时数组
    int L[n1], R[n2];

    // 将数据复制到临时数组 L[] 和 R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // 合并临时数组
    i = 0; // 初始索引 L[]
    j = 0; // 初始索引 R[]
    k = left; // 初始索引 arr[]

    // 逐个比较并合并
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 复制剩余元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// 归并排序函数
void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2; // 计算中间索引

        // 递归排序左半部分
        mergeSort(arr, left, mid);
        // 递归排序右半部分
        mergeSort(arr, mid + 1, right);

        // 合并已排序的部分
        merge(arr, left, mid, right);
    }
}

最后，在选择合适的排序算法时，应该考虑以下几个因素：

1. 数据规模：不同算法在处理不同规模的数据时表现不同。例如，插入排序和冒泡排序在小规模数据上表现良好，而快速排序和归并排序则更适合处理大规模数据。

2. 时间复杂度：

   • 插入排序：O(n²)（适用于小规模数据）
   • 希尔排序：O(n log n)（依赖于增量序列）
   • 选择排序：O(n²)（简单，但效率低下）
   • 冒泡排序：O(n²)（效率较低）
   • 堆排序：O(n log n)（适合处理大规模数据）
   • 快速排序：O(n log n)（平均情况好，但最坏情况为 O(n²)）
   • 归并排序：O(n log n)（稳定，适合大规模数据）

3. 稳定性：如果需要保持相同元素的相对顺序，应该选择稳定排序算法。稳定的排序算法包括插入排序、归并排序和冒泡排序，而快速排序和堆排序则不稳定。

4. 空间复杂度：考虑内存使用情况。归并排序和插入排序的空间复杂度较低，而归并排序需要 O(n) 的额外空间。

选择建议：

• 小规模数据：可以选择插入排序或冒泡排序，简单易实现。
• 大规模数据：推荐使用快速排序或归并排序，它们在平均情况下性能优越。
• 需要稳定性：选择归并排序或插入排序。
• 内存受限：选择原地排序的堆排序或快速排序。