CN·语言

算法

排序、查找、逆序、变换、计数——对标 C++ <algorithm> 的常用子集。

导入写法CN

导入 算法::{排序整32, 排序整64, 线性查找, 逆序, 计数, 最大元素};
导入 算法::{二分查找整32, 二分查找整64, 变换整32, 变换整64};

数组算法

全部作用于原生数组/指针(非容器)。排序为冒泡(升序);二分查找前置条件=数组已升序。查找未找到返回 可选 无(命中=某些(下标),以 .有值 分流取 .值)。泛型函数要求元素类型支持 == 或 </> 比较。

数组算法.cnCN

导入 算法::{排序整64, 二分查找整64, 线性查找, 逆序, 计数, 最大元素};

函数 主() -> 整32 {
    整64[6] 数据;
    数据[0] = 5;
    数据[1] = 2;
    数据[2] = 8;
    数据[3] = 2;
    数据[4] = 9;
    数据[5] = 1;
    排序整64(数据, 6);
    整64 i = 0;
    当 (i < 6) { 打印行(数据[i], " "); i++; }
    打印("");                     // 1 2 2 5 8 9
    可选<整64> 位 = 二分查找整64(数据, 6, 8);
    如果 (位.有值) { 打印(位.值); } 否则 如果 (!位.有值) { 打印("无"); }    // 4(升序前提下)
    可选<整64> 找7 = 线性查找<整64>(数据, 6, 7);
    如果 (找7.有值) { 打印(找7.值); } 否则 如果 (!找7.有值) { 打印("无"); }    // 无(未找到)
    打印(计数<整64>(数据, 6, 2));          // 2
    打印(最大元素<整64>(数据, 6));         // 9
    逆序<整64>(数据, 6);
    打印(数据[0]);                    // 9
    返回 0;
}

输出:1 2 2 5 8 9 4 无 2 9 9

排序整32 不安全

不安全 函数 排序整32(整32* 数组, 整64 长度) -> 空类型

对 整32 数组原地冒泡排序(升序)。长度为 0/1 时不动。

参数类型说明
数组整32*数组首地址
长度整64元素个数

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

排序整64 不安全

不安全 函数 排序整64(整64* 数组, 整64 长度) -> 空类型

对 整64 数组原地冒泡排序(升序)。

参数类型说明
数组整64*数组首地址
长度整64元素个数

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

线性查找

泛型 <类型 T> 函数 线性查找(T* 数组, 整64 长度, T 目标) -> 可选<整64>

从头到尾逐元素 == 比较,命中=某些(首个下标);未找到=无。消费以 .有值 分流后取 .值。任意可比较相等类型可用(泛型单态化)。

参数类型说明
数组T*数组首地址
长度整64元素个数
目标T要找的值

返回 可选<整64>:命中=某些(首个命中下标);未找到=无。

主.cnCN

导入 算法::线性查找;

函数 主() -> 整32 {
    整32[4] 值;
    值[0] = 10;
    值[1] = 20;
    值[2] = 30;
    值[3] = 40;
    // #1360 结果化:线性查找 返回 可选<整64>(显式 <整32> 调用形态不变),
    //   消费以 .有值 分流——与 658 隐式推导对照
    可选<整64> 查 = 线性查找<整32>(值, 4, 30);
    如果 (查.有值) {
        打印(查.值);
    } 否则 如果 (!查.有值) {
        打印("意外无值");
    }
    返回 0;
}

输出:2

二分查找整32 不安全

不安全 函数 二分查找整32(整32* 数组, 整64 长度, 整32 目标) -> 可选<整64>

前置条件:数组已升序。折半查找,O(log n)。命中=某些(下标);未找到=无。

参数类型说明
数组整32*已升序数组
长度整64元素个数
目标整32要找的值

返回 可选<整64>:命中=某些(命中下标);未找到=无。

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

二分查找整64 不安全

不安全 函数 二分查找整64(整64* 数组, 整64 长度, 整64 目标) -> 可选<整64>

前置条件:数组已升序。整64 版折半查找。命中=某些(下标);未找到=无。

参数类型说明
数组整64*已升序数组
长度整64元素个数
目标整64要找的值

返回 可选<整64>:命中=某些(命中下标);未找到=无。

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

逆序 不安全

泛型 <类型 T> 不安全 函数 逆序(T* 数组, 整64 长度) -> 空类型

原地反转(首尾双指针交换)。

参数类型说明
数组T*数组首地址
长度整64元素个数

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

变换整32 不安全

不安全 函数 变换整32(整32* 数组, 整64 长度) -> 空类型

原地变换:每个元素翻倍(数组[i] = 数组[i] * 2)。

参数类型说明
数组整32*数组首地址
长度整64元素个数

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

变换整64 不安全

不安全 函数 变换整64(整64* 数组, 整64 长度) -> 空类型

原地变换:整64 版逐元素翻倍。

参数类型说明
数组整64*数组首地址
长度整64元素个数

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

计数

泛型 <类型 T> 函数 计数(T* 数组, 整64 长度, T 目标) -> 整64

统计 目标 在数组中出现的次数。

参数类型说明
数组T*数组首地址
长度整64元素个数
目标T要统计的值

返回 出现次数。

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====

最大元素

泛型 <类型 T> 函数 最大元素(T* 数组, 整64 长度) -> T

返回数组中的最大值。空数组(长度 0)是未定义行为——调用方保证长度 ≥ 1。

参数类型说明
数组T*数组首地址
长度整64元素个数(≥1)

返回 最大元素。

主.cnCN

导入 算法::排序整32;
导入 算法::排序整64;
导入 算法::线性查找;
导入 算法::二分查找整32;
导入 算法::二分查找整64;
导入 算法::逆序;
导入 算法::变换整32;
导入 算法::变换整64;
导入 算法::计数;
导入 算法::最大元素;

函数 主() -> 整32 {
    打印("===== 算法库(Task 6.7)=====");

    // ==================== 1. 排序(整32 冒泡升序) ====================
    整32[6] 数组 = { 5, 2, 8, 1, 9, 3 };
    排序整32(数组, 6);
    打印("排序: ", 数组[0], 数组[1], 数组[2], 数组[3], 数组[4], 数组[5]);

    // ==================== 2. 线性查找(找到索引 / 找不到=无·#1360 结果化) ====================
    // 消费样板:可选<整64> 以 .有值 分流(否则 如果 显式枚举无值区间·else 新规)
    可选<整64> 查 = 线性查找<整32>(数组, 6, 8);
    如果 (查.有值) {
        打印("线性查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找8: 无");
    }
    查 = 线性查找<整32>(数组, 6, 5);
    如果 (查.有值) {
        打印("线性查找5: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找5: 无");
    }
    查 = 线性查找<整32>(数组, 6, 99);
    如果 (查.有值) {
        打印("线性查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("线性查找99: 无");
    }

    // ==================== 3. 二分查找(升序数组查目标) ====================
    查 = 二分查找整32(数组, 6, 8);
    如果 (查.有值) {
        打印("二分查找8: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找8: 无");
    }
    查 = 二分查找整32(数组, 6, 1);
    如果 (查.有值) {
        打印("二分查找1: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找1: 无");
    }
    查 = 二分查找整32(数组, 6, 99);
    如果 (查.有值) {
        打印("二分查找99: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找99: 无");
    }

    // ==================== 4. 逆序({1,2,3} → {3,2,1}) ====================
    整32[3] 三元素 = { 1, 2, 3 };
    逆序<整32>(三元素, 3);
    打印("逆序: ", 三元素[0], 三元素[1], 三元素[2]);

    // ==================== 5. 变换(每个元素 ×2) ====================
    整32[4] 变换数组 = { 1, 2, 3, 4 };
    变换整32(变换数组, 4);
    打印("变换: ", 变换数组[0], 变换数组[1], 变换数组[2], 变换数组[3]);

    // ==================== 6. 计数(统计目标出现次数) ====================
    整32[8] 计数组 = { 1, 2, 2, 3, 2, 4, 2, 5 };
    整64 次数 = 计数<整32>(计数组, 8, 2);
    打印("计数2: ", 次数);
    次数 = 计数<整32>(计数组, 8, 9);
    打印("计数9: ", 次数);

    // ==================== 7. 最大元素 ====================
    整32 最大 = 最大元素<整32>(数组, 6);
    打印("最大元素: ", 最大);

    // ==================== 8. 整64 版本(排序/二分/变换) ====================
    整64[5] 大数组 = { 50, 20, 80, 10, 90 };
    排序整64(大数组, 5);
    打印("排序整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);
    查 = 二分查找整64(大数组, 5, 80);
    如果 (查.有值) {
        打印("二分查找整64 80: ", 查.值);
    } 否则 如果 (!查.有值) {
        打印("二分查找整64 80: 无");
    }
    变换整64(大数组, 5);
    打印("变换整64: ", 大数组[0], 大数组[1], 大数组[2], 大数组[3], 大数组[4]);

    打印("===== 算法库测试完成 =====");
    返回 0;
}

输出:===== 算法库(Task 6.7)===== 排序: 123589 线性查找8: 4 线性查找5: 3 线性查找99: 无 二分查找8: 4 二分查找1: 0 二分查找99: 无 逆序: 321 变换: 2468 计数2: 4 计数9: 0 最大元素: 9 排序整64: 1020508090 二分查找整64 80: 3 变换整64: 2040100160180 ===== 算法库测试完成 =====