kupePoem的专栏

2） 交换片段：将左子数组的 arr[i..mid]与右子数组的 arr[mid+1..j] 交换（使用手摇算法）。// 合并两个有序子数组 arr[left..mid] 和 arr[mid+1..right]- **最坏情况**：每次合并需交换最大片段，时间复杂度 $O(n \log n)$。- **最佳情况**：两个子数组天然有序，时间复杂度 $O(n)$。// 手摇算法交换 arr[a..b] 和 arr[b+1..c]- **空间复杂度**：$O(1)$（原地操作）。

3 数据类型：本示例适用于32位整数，浮点数需改用_mm_max_ps。2 减少指令数：从4次比较减少到2次向量操作。2）第一次移位后：[2, 6, 3, 1]4）第二次移位后：[3,3, 6, 6]5） 比较结果：[6, 6, 6, 6]1）初始向量：[6, 2, 1, 3]3）比较结果：[6, 6, 3, 3]

pragma omp single 是 OpenMP（一种用于共享内存并行编程的 API）中的一种工作共享指令，用于在并行区域内指定一个代码块仅由单个线程执行，其他线程会等待该代码块执行完毕后再继续（除非显式取消同步）。1）单线程执行：在并行区域（#pragma omp parallel）内部，标记的代码块会被任意一个可用线程执行（不固定是主线程）。2）#pragma omp single：由任意一个线程执行，且默认有隐式同步。3）独立性：single 块内的变量默认是共享的（除非显式声明为私有变量）。

4. 最终合并：将 [4,6,7] 和 [5,9] 合并为 [4,5,6,7,9]。2）左子数组继续分解为 [6,4] 和 [7]→ 合并为 [4,6,7]；4） 最终合并 [4,6,7] 和 [5,9]→ [4,5,6,7,9]。2）左子任务 [0,1]（长度2）触发串行处理 → 合并为 [4,6]。-分割为左 [0,2]（6,4,7）和右 [3,4]（$9,5$）。1）长度 3 > 2，继续并行分解为 [0,1] 和 [2,2]。3） 右子任务 [2,2] 直接返回 → 合并为 [4,6,7]。

block_swap_rotate(arr, start, end, d) 处理数组的 [start, end]区间，旋转前 d个元素到末尾。对数组 [1,2,3,4,5,7,8]旋转3位后结果为 [4,5,7,8,1,2,3]。以{1, 2, 3, 4, 5, 6，7, 8}将前3个元素移到末尾为例。1. 将数组分为前`d`个元素（块A）和剩余元素（块B）；// 交换右块和左块前right_len个元素。// 交换左块和右块前left_len个元素。d = d % n;1） 交换A和B的前d个元素；

1 左移k位：修改为reverse(0, k-1) → reverse(k, n-1) → reverse(0, n-1)reverse(arr, k, n-1);2 负数处理：若k<0，转换为等效的正数位移（如左移2位等价于右移3位）。2. 前2个反转 → [4,5,3,2,1]3. 后3个反转 → [4,5,1,2,3]1. 整体反转 → [5,4,3,2,1]2 前k个元素反转：反转前k个元素。

以数组 [1,4,7,9,2,5,6,8]为例，合并左块 [1,4,7,9]和右块 [2,5,6,8]。7 > 5，找到右块中连续比 7 小的元素（5,6）。左块：[1,4,7,9] 右块：[2,5,6,8]数组变为：[1,2,4,7,9,5,6,8]数组变为：[1,2,4,5,6,7,9,8]数组变为：[1,2,4,5,6,7,8,9]数组：[1,4,7,9,2,5,6,8]

代码的关键点在于正确控制子数组的大小和合并的边界条件，确保所有元素最终被合并排序。通过临时数组合并两个有序区间$[left, mid]和[mid+1, right]。1) 合并[5,6,7,8]和[2]$→ $[2,5,6,7,8]$1) 合并[5,6]和[7,8]→ [5,6,7,8]二 算法步骤（以数组[6,5,7,8,2]$为例）1) 合并[6]和[5] → [5,6]2) 合并[7]和[8] → [7,8]3) 数组变为：[5,6,7,8,2]2) 数组变为：[5,6,7,8,2]

每次比较 arr1[i]和 arr2[j]，将较小值放入结果数组。选择更小的 0，结果变为 [0]，指针 j后移。选择 1，结果变为 [0,1]，指针 i 后移。选择 2，结果变为 [0,1,2]，指针 i后移。2 比较 arr1[0]=1和 arr2[1]=4。arr1: [1, 2, 3, 6, 9] 指针i=0。arr2: [0, 4, 5, 7, 8] 指针j=0。1 比较 arr1[0]=1和 arr2[0]=0。3 比较 arr1[1]=2和 arr2[1]=4。

逆向双指针是一种常用于处理两个有序序列的高效算法技巧，其核心思想是从序列的末尾开始遍历，避免覆盖有效数据或多次移动元素。1）合并两个有序数组（如 nums1 和 nums2，其中 nums1 尾部有预留空间）。// 处理nums2剩余元素（无需处理nums1剩余，因为它们已在正确位置）1）比较 nums1[i] 和 nums2[j]，将较大值放入 nums1[k]。3）处理剩余元素：若 nums2 有剩余元素，直接复制到 nums1 头部。i 指向第一个序列有效元素末尾（如 nums1 的最后一个元素）

使用_mm_loadu_si128加载每块中连续的4个整数（128位寄存器），通过_mm_cmpgt_epi32比较对应元素大小，生成掩码。用_mm_blendv_epi8根据掩码混合两个块的数据：将较大值保留在块i+1，较小值留在块i，最后将结果写回内存。若数组按16字节对齐，改用_mm_load_si128和_mm_store_si128提升加载/存储效率。依次遍历每对相邻块（块i与块i+1），若块i+1中某位置元素大于块i的对应位置元素，则交换二者。// 处理剩余不足4个的元素。

给定数组 [6, 5, 7, 8, 2, 9]，子序列间隔为3，可将其平均分为前3个和后3个元素。仅更新有效元素（前3个和后3个），忽略填充值。将前3个和后3个元素加载到两个128位向量（__m128i），填充第四个元素为0。分割数组：前半为 [6, 5, 7]，后半为 [8, 2, 9]。2) 掩码混合：利用 _mm_blendv_epi8 快速选择保留的值。3) 通过SSE优化，将逐元素比较与交换转化为向量操作，提升了计算效率。结果：[6, 2, 7, 8, 5, 9]。// 根据掩码混合向量。

4）最终合并 [5 6 7] 和 [2 8]→ [2 5 6 7 8]。3） 合并右半部分 [8] 和[2]→ 合并为 [2 8]。2）合并：将相邻有序子数组合并为一个有序数组，直到全部合并。2） 合并 [5 6] 和 [7] → [5 6 7]。[6 5 7] 和[8 2]。1）合并 [6]和 [5] → [5 6]。二、分步演示（数组[6 5 7 8 2]）2）第2层分解左半部分 [6 5 7]3）第2层分解右半部分 [8 2]

2） 后续增量可通过最后一个元素乘以2.25生成（如：701*2.25=1577，1577*2.25=3548...）。1）经验证最优的初始序列为：[1, 4, 10, 23, 57, 132, 301, 701]3）时间复杂度约为O(n^{3/2})，优于传统希尔排序的O(n^2)。3）性能优化：Ciura序列在中等规模数据（n ≤ 10^6）表现最佳。1）逆序使用序列：必须从最大间隔开始递减。

omp_set_num_threads(物理核心数/2);// 小数据使用单线程。1）分层并行：不同gap阶段顺序执行，同一gap内的子数组分组并行处理。2）数据独立性：同一gap下不同子数组间无重叠元素，天然支持并行。omp_set_num_threads(物理核心数);1）必要性：不同子数组的排序耗时差异大（元素数量不同）。3）负载均衡：动态调度解决不同子数组计算量不均的问题。// 并行区域：每个线程处理不同子数组。// 生成Ciura序列（含动态扩展）

递推公式：每次k增加1，计算 h_{k+1}=2^{k+1}-1。while ((1 << k) - 1 < n) { // 1<<k等价于2^k。作为希尔排序的步长（间隔序列），用于将数据分为多个子序列进行插入排序。其中k从1开始递增，序列为：1, 3, 7, 15, 31, 63, …1）最坏情况：O(n^{3/2})，优于原始希尔排序的O(n^2)。起始条件：k=1，对应h_1=2^1-1=1。// 找到最大的k使得2^k -1 < n。

最终，希尔排序在大多数实际场景中显著优于插入排序，时间复杂度可降至 O(n log n) 至 O(n^{4/3}) 之间，具体取决于间隔序列的设计。例如，Hibbard间隔保证每次排序后，元素的移动步长呈指数级缩小，有效降低总操作次数。希尔排序通过分阶段的子序列插入排序，逐步减少元素与目标位置的偏差，从而降低整体比较和移动次数。希尔排序通过引入间隔（gap）将数组分成多个子序列，逐步缩小间隔直至为1。例如，若元素需从位置51移动到位置1，在间隔为50时，一步即可到位。最坏 O(n^{3/2})。

Pratt序列是希尔排序的一种理论优化方案，其核心在于3-smooth数的数学性质。Pratt序列主要具有理论意义，证明了希尔排序在特定增量序列下可达到接近O(n log n)的效率。使用Pratt序列的希尔排序理论时间复杂度为O(n log^2 n)，优于原始希尔排序的O(n^2)。Pratt序列的每个元素是满足$2^p * 3^q（p, q >= 0）的整数，并按升序排列。1, 2, 3, 4, 6, 8, 9, 12（当p <= 3, q <= 2）。2）生成的增量数量较多，导致排序趟数增加。

希尔排序是一种基于插入排序的改进算法，其核心思想是将原始数组分成多个子序列（按一定间隔），分别进行插入排序，随后逐步缩小间隔直至为1。使用Sedgewick序列的希尔排序，在最坏情况下的时间复杂度为O(n^{4/3})，优于其他常见间隔序列（如Hibbard序列的$O(n^{3/2})$）。在希尔排序中，先按Sedgewick公式生成足够大的间隔值，然后从最大且小于数组长度的间隔开始，逐步缩小直至间隔为1。Sedgewick提出了两种生成间隔的公式，结合了指数和多项式，生成的间隔序列具有较好的实践经验。

2^k-1（最坏时间复杂度O(n^{3/2})）。2）使用优化序列（如Hibbard、Sedgewick）时，性能显著提升至O(n^{3/2})或更低。, 1（最坏时 间复杂度O(n^2)）。常用增量序列的平均时间复杂度约为O(n^{1.25} ）到O(n^{1.5} ）。数学证明当增量满足h=2^k-1时，比较次数约为O(n^{3/2})。希尔排序 O(n^{1.25} 到O(n^{1.5} ） O(n^2)1）00使用简单递减序列（如N/2）时，最坏情况为O(n^2)。

希尔排序（Shell Sort）是一种基于插入排序的改进算法，通过分组插入排序逐步减少元素移动次数，提升排序效率。平均情况：O(n log n)到 O(n^{1.5})，优于直接插入排序。本例数组[6 5 7 8 2]长度为5，增量序列为：gap = 2 ->1。2 时间复杂度：最坏情况下为 O(n^2)，但优于普通插入排序。排序后数组变为： [2, 5, 6,8,7]最坏情况：O(n^2)（取决于增量序列）。最终有序数组： [2,5, 6, 7, 8]插入排序后 → [2, 6, 7]

插入排序是稳定的原地排序算法，核心思想是逐步构建有序序列。对于未排序部分的每个元素，在已排序序列中从后向前扫描，找到合适位置插入。合并过程可并行化，逐步减少块数直至整体有序。插入排序本身时间复杂度为O(n^2)，并行化后加速比受限于分块数量和归并开销。块过小会导致合并开销过大，建议块大小 ≥ 1000元素。将数组分成多个子块，每个线程使用插入排序处理一块。若数据分布不均，末尾块可能较长，需特殊处理。// 步骤1：并行分块插入排序。// 步骤2：归并所有有序块。// 并行插入排序主函数。

/ 仅复制指针，内存共享。// 直接赋值即可完成深拷贝。1. 优先使用 std::array或 std::vector。1. 浅拷贝（Shallow Copy）：仅复制指针/地址。2. 深拷贝（Deep Copy）：完整复制内存数据。2. 普通数组建议用 std::copy。2. 使用 std::copy（推荐）2）对象数组需注意拷贝构造函数。// 或使用 vector。

std::merge需要输入区间和目标区间的迭代器 ， std::inplace_merge为同一容器的迭代器。std::merge需要额外存储空间（目标区间），std::inplace_merge无需额外空间。2）std::inplace_merge合并同一容器的两个连续有序子区间。// 合并到 dst，结果为 {1,2,3,4,5,6}// 合并整个区间，v 变为 {1,2,3,4,5,6}

AVX 系列：AVX/AVX2（256位寄存器）。SSE 系列：SSE/SSE2/SSE3/SSE4（128位寄存器)。// 存储到[i-2, i-1, i, i+1]位置（右移一位）// 加载[i-3, i-2, i-1, i]位置的元素。使用数组右移一位的SIMD算法来优化插入排序算法。// 从倒数第二个元素开始处理。// SSE处理：每次4个元素，从右往左。// 处理剩余元素（无法组成4个的部分）// simd批量移动元素。// 找到插入位置pos。// 将末尾元素放到首位。// 保存最后一个元素。

存储：向右移动一位，存储到i-2的位置（如i=5时，存储到arr[3], arr[4], arr[5], arr[6]）加载：从i-3开始加载4个元素（如i=5时，加载arr[2], arr[3], arr[4], arr[5]）// 存储到[i-2, i-1, i, i+1]位置（右移一位）// 加载[i-3, i-2, i-1, i]位置的元素。2)SSE批量移动：从右向左每次加载4个元素到寄存器，存储到右侧位置。3)处理剩余元素：对无法组成4个元素的剩余部分，用普通循环处理。

在 VS2015 的 memcpy 实现中，可能调用 SSE/AVX 指令集优化的块复制操作某些情况下会自动选择复制方向（类似 memmove），但非官方保证行为。if(s < d && s + n > d) { // 检测正向复制是否会导致覆盖。// 改为从高地址向低地址复制。// 从低地址向高地址复制。memmove 允许（自动处理重叠） 检测重叠区域，智能选择复制方向。安全性 低（需手动确保安全） 高（自动处理重叠）// 插入排序元素移动（源与目标区域重叠）

传统插入排序通过循环逐位移动元素完成插入，而memcpy/memmove优化利用内存操作函数批量移动连续内存，减少循环开销。插入4（i=1） 1次 1次（等效）2 ）批量移动：将arr[0..0]（元素6）后移1位。2）批量移动：将arr[0..3]（4,6,7,8）后移1位。以数组 [6,4,7,8, 2] 为例来演示优化步骤。结果： [4, 6, 7, 8, 2]目标位置： [4,6,7,8 → 全部后移1位]结果： [2, 4, 6, 7, 8]

对于未排序部分的每个元素，在已排序序列中从后向前扫描，找到合适位置插入。while (arr[j] > temp) { // 无需检查j >=0（因为首元素是哨兵）在寻找插入位置时，使用二分查找代替顺序查找，将比较次数从O(n)降低到O(log n)。比较次数O(n log n)，移动次数仍为O(n^2)→ 整体O(n^2)，但常数更小。i++) // 先找到最小值作为哨兵。1. 小规模数据（n< 1000）：优先使用原始插入排序。最差：O(n^2)（完全逆序）最优：O(n)（已有序）

/ 已排序区的末尾索引。// 插入到正确位置。[6 | 5 7 8 2] // 已排序区:6，未排序区:5 7 8 2。- 最差情况（完全逆序）：总比较次数n(n-1)/2 O(n^2)[5 6 7 8 | 2] // 已排序区:5 6 7 8。[5 6 7 | 8 2] // 已排序区:5 6 7。[5 6 | 7 8 2] // 已排序区:5 6。- 最优情况（已有序）：仅需比较n-1次 O(n)[2 5 6 7 8] // 排序完成。

时间复杂度,O(n 2)。每次从未排序序列中选择最小元素，交换到已排序序列末尾。2）线程数建议设置为物理核心数（通过omp_set_num_threads()调整）。通过shared指定min_val/min_idx为共享变量。在未排序区间[i, n-1]中找最小值索引min_idx。已排序区间为空，未排序区间为[0,n-1]。交换arr[i]与arr[min_idx]。3）编译需添加OpenMP支持。3）重复n-1次直到全部有序。1）适用于大规模数据。一 选择排序算法原理。三 C++串行实现。

/ 建议不超过物理核心数。if (arr[i] < min_val) { // 需二次检查防止竞态。#pragma omp critical // 仍需保护索引更新。本文介绍查找数组最小值索引的C++实现及OpenMP并行优化方法。遍历数组所有元素，维护当前最小值和对应索引每次发现更小值时更新记录。3 使用归约操作（更高效， 需要支持OpenMP3.0,vs2019以上）

将查找数组最小值索引的SIMD优化的函数嵌入选择排序主循环，优化最耗时的最小值查找环节，同时保留选择排序的交换逻辑。复用SIMD优化的 find_min_index_simd函数。每次循环处理 arr[i..n-1] 子数组。保持原址排序特性，交换操作仍使用标量实现。// 查找子数组最小值偏移量。避免 SIMD 指令处理小数据时的额外开销。自动切换标量模式处理尾部数据。当剩余元素 <4 时自动回退到标量模式，三 数组最小值查找的SIMD优化函数。n - i：剩余未处理的元素数量。1)最小值查找模块化。

1）数据对齐：使用 _mm_loadu_si128 处理未对齐数据，若数据对齐可改用 _mm_load_si128 提升性能。2）整数类型：本示例针对 int32，其他类型需调整指令（如 _mm_cmplt_pd 用于 double）。1)向量化加载：_mm_loadu_si128 加载未对齐的 16 字节数据。4)最小值更新：_mm_min_epi32 直接获取每个通道的最小值。3)混合操作：_mm_blendv_epi8 根据掩码选择索引。2)并行比较：_mm_cmplt_epi32 生成比较掩码。

在每一轮遍历中，同时找到未排序部分的最小值和最大值，将最小值交换到未排序部分的起始位置，最大值交换到未排序部分的末尾位置。通过这种方式减少总遍历次数。示例：数组 [4, 3, 2, 1]，首轮交换最小值 1 后，原最大值 4 被移动到索引3，需更新 max_idx 为3。时间复杂度为(O(n^2))，但实际比较次数约为标准选择排序的 (1/2)。交换索引0和2 → [1, 2, 6, 8, 5]交换索引4和3 → [1, 2, 6, 5, 8]交换索引2和3 → [1, 2, 5, 6, 8]

将数组分为已排序区间（前部）和未排序区间（后部）每轮从未排序区间选择最小元素，将其与未排序区间的第一个元素交换,通过n-1轮（数组长度为n）完成排序。不稳定（如对[6,6,2]$排序会破坏两个6的原始顺序）。第1轮：找到最小值 2，与第一个元素 6交换 → [2,4,7,8,6]cout << "第" << i+1 << "轮：";O(n^2)（每轮需遍历剩余元素，共n(n-1)/2次比较）。// 在未排序区间[i, n-1]中找最小值。第3轮：找到 6与 7交换 → [2,4,6,8,7]

本文对十大经典排序算法做简要的总结（按常用分类方式排列），包含核心思想、时间/空间复杂度及特点。1）稳定：归并、冒泡、插入、计数、桶、基数。2）非比较排序（计数/桶/基数）空间换时间。4）稳定需求：归并排序（大数据）或基数排序（整数）时间：O(n \times k)（k为最大位数）时间：O(n\log n)（最坏O(n^2)）8. 计数排序 (COUNTING SORT)时间：O(n^{1.3})（依赖增量序列）2）不稳定：选择、希尔、快速、堆。1）归并排序需要额外O(n)空间。

奇阶段：比较所有奇数索引与后一偶数索引元素对（arr[1] arr[2], arr[3] arr[4], …偶阶段：比较所有偶数索引与后一奇数索引元素对（arr[0] arr[1], arr[2] arr[3],）重复交替执行直到完全有序。冒泡排序的并行化面临天然的顺序依赖性挑战，但通过算法改造可实现有限程度的并行。以下介绍奇偶交换思路的实现方法。核心思路将比较操作分为奇阶段和偶阶段交替执行，同一阶段内的相邻元素比较可并行进行。2）通过向量化比较减少分支预测失误。三 SIMD优化关键点。

让我们使用SIMD指令优化数组相邻元素的比较交换操作。// 结果：[1,2,3,4]simd_swap(simd_data);// 结果：[1,2,3,4]比较结果：0 -1 -1 0 （0表示false，-1表示true）将4个int元素加载到SIMD寄存器，形成向量[1,2,4,3]使用shuffle操作将元素重新排列为[2,1,3,4]最终期望结果：[1 2 3 4]比较结果重排：0 0 -1 -1。// 生成比较结果掩码。原始数据：1 2 4 3。重排数据：2 1 3 4。

双向冒泡排序（Cocktail Shaker Sort）是传统冒泡排序的改进版本，通过双向交替扫描数组，在每轮循环中同时将最大值移动到右侧、最小值移动到左侧，从而减少排序轮次。OpenMP是一个支持共享内存并行编程的API，通过添加编译指令（如#pragma omp parallel）实现多线程并行。偶数阶段：并行处理索引为偶数的元素对（如0-1, 2-3）奇数阶段：并行处理索引为奇数的元素对（如1-2, 3-4）并行处理偶数索引对 → 并行处理奇数索引对。并行处理奇数索引对 → 并行处理偶数索引对。