算法
排序、查找、逆序、变换、计数——对标 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 ===== 算法库测试完成 =====