二分法查找元素：
function binarySearch($arr, $target) {
$left = 0;
$right = count($arr) - 1;
while ($left <= $right) {
$mid = floor(($left + $right) / 2);
if ($arr[$mid] == $target) {
return $mid; // 找到目标值，返回索引
}
if ($arr[$mid] < $target) {
$left = $mid + 1; // 目标值在右侧，更新左边界
} else {
$right = $mid - 1; // 目标值在左侧，更新右边界
}
}
return -1; // 目标值不存在，返回-1
}
准备一个有序数组：
$nums = [2, 5, 8, 12, 16, 23, 38, 45, 57, 68];
$target = 16; // 假设目标值是数组里的16
$result = binarySearch($nums, $target);
if ($result == -1) {
echo "目标值 $target 不存在于数组中。";
} else {
echo "目标值 $target 的索引为 $result。";
}首先定义了一个binarySearch函数来执行二分搜索算法。函数接受两个参数：一个有序数组$arr和要搜索的目标值$target。函数使用两个指针$left和$right来表示搜索范围的边界，并在每次迭代中将搜索范围缩小一半。如果找到目标值，则返回目标值的索引；如果目标值不存在，则返回-1。注意，二分搜索算法要求在有序数组上进行操作。
冒泡排序：
function bubbleSort($arr) {
$n = count($arr);
// 外层循环控制比较轮数
for ($i = 0; $i < $n - 1; $i++) {
// 内层循环执行每轮比较
for ($j = 0; $j < $n - $i - 1; $j++) {
// 如果当前元素大于下一个元素，则交换它们
if ($arr[$j] > $arr[$j + 1]) {
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
}
}
}
return $arr;
}
// 示例用法
$unsortedArray = [64, 34, 25, 12, 22, 11, 90];
$sortedArray = bubbleSort($unsortedArray);
echo "排序后的数组：";
print_r($sortedArray);
定义了一个bubbleSort函数，接受一个待排序的数组作为参数，并返回排序后的数组。外层循环用于控制比较轮数，内层循环用于执行每轮比较并交换元素。在每一轮内层循环结束后，最大的元素都会浮到数组的末尾，因此外层循环的轮数逐渐减少，直到排序完成。
以上是冒泡排序算法的PHP实现示例。请注意，冒泡排序不是最有效的排序算法，特别是对于大型数据集，因为它的时间复杂度为O(n^2)。在实际应用中，更常用的排序算法是快速排序、归并排序或使用PHP内置的sort函数。
桶排序：
function bucketSort($arr) {
// 找到数组中的最大值和最小值
$min = min($arr);
$max = max($arr);
// 计算桶的数量，这里可以根据实际情况调整桶的数量
$bucketCount = ($max - $min) + 1;
// 创建桶并初始化为空数组
$buckets = array_fill(0, $bucketCount, []);
// 将元素分配到桶中
foreach ($arr as $num) {
$index = $num - $min; // 计算桶的索引
array_push($buckets[$index], $num);
}
// 对每个桶中的元素进行排序
foreach ($buckets as &$bucket) {
sort($bucket);
}
// 合并桶中的数据以获得最终排序结果
$sortedArray = [];
foreach ($buckets as $bucket) {
$sortedArray = array_merge($sortedArray, $bucket);
}
return $sortedArray;
}
// 示例用法
$unsortedArray = [64, 34, 25, 12, 22, 11, 90];
$sortedArray = bucketSort($unsortedArray);
echo "排序后的数组：";
print_r($sortedArray);
首先找到了输入数组中的最小值和最大值，然后根据这两个值计算了桶的数量。接下来，我们创建了一个桶的数组，每个桶是一个空数组。
然后，我们遍历输入数组中的每个元素，将每个元素放入相应的桶中。为了确定元素应该放入哪个桶，我们使用了元素值与最小值之差作为桶的索引。
接着，我们对每个桶中的元素进行排序，这里使用了PHP的sort函数。
最后，我们将每个桶中的元素按照桶的顺序合并成最终的排序结果。
需要注意的是，桶排序适用于数据分布均匀的情况，如果数据分布不均匀，可能需要进行一些额外的优化。此外，桶排序的性能也取决于桶的数量的选择，需要根据具体情况进行调整。
快速排序：
function quickSort($arr) {
// 如果数组为空或只包含一个元素，直接返回
if (count($arr) <= 1) {
return $arr;
}
// 选择一个基准元素
$pivot = $arr[0];
$left = $right = [];
// 将小于基准的元素放入左子数组，大于基准的元素放入右子数组
for ($i = 1; $i < count($arr); $i++) {
if ($arr[$i] < $pivot) {
$left[] = $arr[$i];
} else {
$right[] = $arr[$i];
}
}
// 递归地对左右子数组进行排序，并合并结果
return array_merge(quickSort($left), [$pivot], quickSort($right));
}
// 示例用法
$unsortedArray = [64, 34, 25, 12, 22, 11, 90];
$sortedArray = quickSort($unsortedArray);
echo "排序后的数组：";
print_r($sortedArray);
算法的基本思想是选择一个基准元素，将数组分成两个子数组，一个包含小于基准元素的元素，另一个包含大于基准元素的元素，然后递归地对这两个子数组进行排序。
quickSort函数首先检查输入数组是否为空或只包含一个元素，如果是，则直接返回数组。然后，选择一个基准元素（通常是第一个元素），将小于基准的元素放入左子数组，大于基准的元素放入右子数组。接下来，递归地对左右子数组进行排序，然后将排序后的左子数组、基准元素和排序后的右子数组合并成最终的排序结果。
快速排序的时间复杂度平均情况下为O(n log n)，它是一种非常高效的排序算法，通常用于大规模数据集的排序。在实际应用中，也可以采用不同的方式选择基准元素，以优化算法的性能。
递归算法：
示例1：计算阶乘
function factorial($n) {
if ($n <= 1) {
return 1;
} else {
return $n * factorial($n - 1);
}
}
// 示例用法
$result = factorial(5);
echo "5的阶乘是：" . $result; // 输出 120
示例2：计算斐波那契数列的第n个数
function fibonacci($n) {
if ($n <= 0) {
return 0;
} elseif ($n == 1) {
return 1;
} else {
return fibonacci($n - 1) + fibonacci($n - 2);
}
}
// 示例用法
$result = fibonacci(6);
echo "斐波那契数列的第6个数是：" . $result; // 输出 8
递归是一种在函数内部调用自身的编程技巧。它通常用于解决问题，这些问题可以分解成更小的子问题，然后通过递归调用来解决这些子问题。
在这个示例中，factorial函数计算一个正整数的阶乘。如果输入值$n小于或等于1，则返回1（递归的终止条件）。否则，函数调用自身，传递$n - 1作为参数，并将结果乘以$n。这样，递归将一直进行，直到$n减小到1，然后递归终止。
递归是一个强大的编程技巧，但需要小心处理递归终止条件，以避免无限递归导致堆栈溢出。
递归实现无限级分类：
function categoryTree($categories, $parentId = 0) {
$newTree = [];
foreach ($categories as $item) {
if ($item['parent_id'] == $parentId) {
$child = categoryTree($categories, $item['id']);
if ($child) {
$item['child'] = $child;
}
$newTree[] = $item;
}
}
return $newTree;
}
$categories = array(
['id' => 1, 'name' => '电子产品', 'parent_id' => 0],
['id' => 2, 'name' => '手机', 'parent_id' => 1],
['id' => 3, 'name' => '电视', 'parent_id' => 1],
['id' => 4, 'name' => '苹果手机', 'parent_id' => 2],
['id' => 5, 'name' => '三星手机', 'parent_id' => 2],
['id' => 6, 'name' => '家具产品', 'parent_id' => 0],
// 更多分类...
);
$tree = categoryTree($categories);无限极分类通常是指一个数据结构，其中每个分类可以包含子分类，子分类也可以包含子分类，以此类推。
上述函数会遍历分类数组，找到所有具有给定父分类ID的分类，并将它们递归地添加到一个子分类数组中。最终，它会返回一个包含所有分类的树状结构。
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
