php 函数算法优化源码迭代器

最新推荐文章于 2024-08-14 11:22:43 发布

置顶 qq_40250529

最新推荐文章于 2024-08-14 11:22:43 发布

阅读量208

点赞数 1

分类专栏： PHP 文章标签： PHP 算法优化迭代器源码

PHP 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

<？php
// --------------------
//基本数据结构算法
// ----------------- ---
//二分查找（
数组里查找某个元素）递归实现 // $ array数组$ low开始位置$ hight长度减一（求索引位置）$ k查询元素
函数bin_sch（$ array，$ low，$高，$ k）{

if（$ low <= $ high）{
$ mid = intval（（$ low + $ high）/ 2）;
＃找到元素.if
（$ array [$ mid] == $ k）return $ mid;
＃中元素比目标大，查找左部.if
（$ k <$ array [$ mid]）返回bin_sch（$ array，$ low，$ mid-1，$ k）;
＃重元素比目标小，查找右部.if
（$ k> $ array [$ mid]）返回bin_sch（$ array，$ mid + 1，$ high，$ k）;

}
return -1;
}
// $ arr = array（1,3,5,7,9,11）;
// $ inx = bin_sch（$ arr，0，count（$ arr）-1,7）;
// echo $ inx。“<hr />”; //索引位置
.function binarySearch（Array $ arr，$ target）{
$ low = 0;
$ high = count（$ arr） - 1;

while（$ low <= $ high）{
$ mid = floor（（$ low + $ high）/ 2）;
＃找到元素.if
（$ arr [$ mid] == $ target）返回$ mid;
＃中元素比目标大，查找左部.if
（$ arr [$ mid]> $ target）$ high = $ mid - 1;
＃重元素比目标小，查找右部.if
（$ arr [$ mid] <$ target）$ low = $ mid + 1;
}

＃查找失败
return false;
}

// $ arr = array（1,3,5,7,9,11）;
// $ inx = binarySearch（$ arr，7）;
// echo $ inx。“<hr />”; //索引位置
//顺序查找（
数组里查找某个元素） function seq_sch（$ array，$ n，$ k）{
$ array [$ n] = $ k;
for（$ i = 0; $ i <$ n; $ i ++）{
if（$ array [$ i] == $ k）{
break;
}
}
如果（$ I <$ N）{
$返回I;
} else {
return -1;
}
}
// $ ARR =阵列（1，3，5，7，9，11）;
// $ inx = seq_sch（$ arr，count（$ arr）-1,7）;
// echo $ inx。“<hr />”; //索引位置
。//线性表的删除（
数组中实现）$ i删除元素下标函数delete_array_element（$ array，$ i）
{
$ len = count（$ array）;
for（$ j = $ i; $ j <$ len; $ j ++）{
$ array [$ j] = $ array [$ j + 1];
}
array_pop（$ array）;
return $ array;
}
// $ arr = array（1,4,3,6,2,5）;
// $ inx = delete_array_element（$ arr，2）;
//的print_r（INX $） “<HR />”; //索引位置
。//冒泡排序（
数组排序） function maopao（$ array）{
 //计算数组中长度
 $ length = count（$ array）;
 //下标大于零讲下标给$ p利用而语句特性条件不成立至少运行一次
 while（$ length> 0）{
 //保持循环条件通过将$ lenght值传给$ pp就是保持循环lenght用做判断> 0循环
 $ p = $ length;
 // length赋值用于判断每次将零赋值给$ lenght用于查看而有没有发生值得交换
 $ length = 0;
 //循环
 for（$ j = 1; $ j <$ p; $ j ++）{
 //从小到大排序
 if（$ array [$ j - 1]> $ array [$ j]）{
 // z小于r交换
 $ temp = $ array [$ j - 1];
 $ array [$ j - 1] = $ array [$ j];
 $ array [$ j] = $ temp;
 //将r的下标赋值给$ length用于判断
 $ length = $ j;
 }
 }
 }
 返回$阵列;
}
$ array = array（1,4,3,6,2,5）;
//的print_r（maopao（$阵列））;

//快速排序（
数组排序）函数quick_sort（$ array）{
 //先判断是否需要继续进行
if（count（$ array）<= 1）return $ array;
//如果没有返回，说明数组内的元素个数多个1个，需要排序
//选择一个标尺
//选择第一个元素
$ key = $ array [0];
$ left_arr = array（）; //小于标尺
$ right_arr = array（）; //大于标尺
for（$ i = 1; $ i <count（$ array）; $ i ++）{
if（$ array [$ i] <= $ key）
 //放入左边
数组$ left_arr [] = $ array [$ i]于;
else
 //放入右边
数组$ right_arr [] = $ array [$ i];
}
//再分别对左边和右边的数组进行相同的排序处理方式
//递归调用这个函数，并记录结果
$ left_arr = quick_sort（$ left_arr）;
$ right_arr = quick_sort（$ right_arr）;
//合并左边标尺右边
返回array_merge（$ left_arr，array（$ key），$ right_arr）;
}
$ array = array（1,4,3,6,2,5）;
//的print_r（quick_sort（$阵列））;
//选择排序
//通过传递传索引交换
数组r z r代表左边的数z代表右边的数函数swap（array＆$ arr，$ a，$ b）{
 //左边的数大于右边的数交换因为$ a ，$ b是下标传索引
$ temp = $ arr [$ a];
$ arr [$ a] = $ arr [$ b];
$ arr [$ b] = $ temp;
}

function selectSort（array＆$ arr）{
 //统计长度
$ count = count（$ arr）;
//循环
（$ i = 0; $ i <$ count; $ i ++）{
 //用$ main记录$ i的位置
$ min = $ i;
//将$ j作为右边的数
为（$ j = $ i + 1; $ j <$ count; $ j ++）{
 //判断左边大于右边
if（$ arr [$ min]> $ arr [$ j] ）{
 //将右边数的下标给$ main
$ min = $ j;
}
}
//判断
如果（$分钟= $我！）{
交换（$ ARR，$分钟，$ⅰ）;
}
}
返回$ ARR;
}

// echo“选择排序”;
echo“ ”;
$ arr = array（9,1,5,8,3,7,4,6,2）;
//的print_r（selectSort（$ ARR））;
//
迭代器function yiledone（）{

for（$ i = 0; $ i <3; $ i ++）{
$ a [$ i] ='';
$ a [$ i]。= $ i;
收益$ a [$ i];
echo $ a [$ i]。'| |” ;
}
}
// $ GET = yiledone（）;
// foreach（$ get as $ value）{

// print_r（$ get）;
//}

function printer（）{
$ i = 1;
while（true）{
echo'这是收益'。（收益$ i）。“\ n”个;
$ I ++;
}
}

$ printer = printer（）;
// echo“ ”;
// var_dump（$ printer-> current（））;
// echo“ ”;
// var_dump（$ printer-> send（'first'））;
// echo“ ”;
// var_dump（$ printer-> send（'second'））;
// echo“ ”;
// echo“迭代器”;
//插入排序
函数InsertSort（$ arr）{
//区分哪部分是已经排序好的
//哪部分是没有排序的
//找到其中一个需要排序的元素
//这个元素就是从第二个元素开始，到最后一个元素都是这个需要排序的元素
//利用循环就可以标志出来
//我循环控制每次需要插入的元素，一旦需要插入的元素控制好了，
//间接已经将数组分成了2部分，下标小于当前的（左边的），是排序好的序列
（$ i = 1，$ len = count（$ arr）; $ I <$ LEN;
$ i ++）{ //获得当前需要比较的元素值。
$ tmp = $ arr [$ i];
//内层循环控制比较并插入
（$ j = $ i-1; $ j> = 0; $ j--）{
// $ arr [$ i]; //需要插入的元素; $ arr [$ j]; //需要比较的元素
if（$ tmp <$ arr [$ j]）{
//发现插入的元素要小，交换位置
//将后边的元素与前面的元素互换
$ arr [$ j + 1] = $ arr [$ j];
//将前面的数设置为当前需要交换的数
$ $ arr [$ j] = $ tmp;
}其他{
//如果碰到不需要移动的元素
//由于是已经排序好是数组，则前面的就不需要再次比较了。
打破;
}
}
}
//将这个元素插入到已经排序好的序列内.//
返回
return $ arr;
}
// var_dump（InsertSort（$ arr））;
// echo'插入排序：';
// echo implode（''，InsertSort（$ arr））。“ ”;
/ **基数排序** /

/ *
*获取第几位上的数字
*
*百位数= 2345％1000/100
* /
函数getN（$ num，$ N）{
$ value = 10;
for（$ i = 1; $ i <$ N; $ i ++）{
$ value = $ value * 10;
}

$ M =（int）（（$ num％$ value /（$ value / 10）））;
返回$ M;
}
/ *
* /
function paixu（$ arr）
{
$ flag = 1; //该次位数上是否全为0标志位，全为0 flag = 0
for（$ M = 1; $ flag！= 0; $ M ++）
{
$ flag = 0;

if（$ M> 1）{
$ m = 0;
for（$ j = 0; $ j <10; $ j ++）{
for（$ k = 0; $ k <count（$ b [$ j]）; $ k ++）{
if（$ b [$ j] [$ k]！= 0）
$ arr [$ m ++] = $ b [$ j] [$ k]; //将容器中的数按序取出，进行下一次排序
}

}
$ b = array（）; //再给b附新值前要清空数组中原有的数据
}

for（$ i = 0; $ i <count（$ arr）; $ i ++）
{
$ thisNum = getN（$ arr [$ i]，$ M）;
if（$ thisNum！= 0）$ flag = 1;
$ b [$ thisNum] [] = $ arr [$ i]; //将数组中的数放入容器中

}

}
// print_r（$ arr）;
返回$ arr;
//的var_dump（$ b）的

}
// print_r（paixu（array（65,3,45,6,7,8,31,100,1000,1234）））;
// echo'基数排序：';
// echo implode（''，paixu（$ arr））。“ ”;
/ **基数排序**结束** /
//堆排序（对简单选择排序的改进）

function swapa（array＆$ arr，$ a，$ b）{
$ temp = $ arr [$ a];
$ arr [$ a] = $ arr [$ b];
$ arr [$ b] = $ temp;
}
//调整$ arr [$ start]的关键字，使$ arr [$ start]，$ arr [$ start + 1] ,,, $ arr [$ end]成为一个大根堆（根节点最大的完全二叉树）
//注意这里节点s的左右孩子是2 * s + 1和2 * s + 2
（数组开始下标为0时）函数HeapAdjust（array＆$ arr，$ start，$ end）{
$ temp = $ ARR [$开始];
//沿关键字较大的孩子节点向下筛选
//左右孩子计算（我这里数组开始下标识0）
//左孩子2 * $ start + 1，右孩子2 * $ start + 2
for（$ j = 2 * $ start + 1; $ j <= $ end; $ j = 2 * $ j + 1）{
if（$ j！= $ end && $ arr [$ j] <$ arr [$ j + 1] ）{
$ j ++; //转化为右孩子
}
if（$ temp> = $ arr [$ j]）{
break; //已经满足大根堆
}
//将根节点设置为子节点的较大值
$ arr [$ start] = $ arr [$ j];
//继续往下
$ start = $ j;
}
$ arr [$ start] = $ temp;
}

function HeapSort（array＆$ arr）{
$ count = count（$ arr）;
//先生数组构造成大根堆（由于是完全二叉树，所以这里用floor（$ count / 2）-1，下标小于或等于这数的节点都是有孩子的节点）
for（$ i = floor （$ count / 2） - 1; $ i> = 0; $ i - ）{
HeapAdjust（$ arr，$ i，$ count）;
}
for（$ i = $ count - 1; $ i> = 0; $ i - ）{
//将堆顶元素与最后一个元素交换，获取到最大元素（交换后的最后一个元素），将最大元素放到数组末尾
SWAPA（$ ARR，0，$ⅰ）;
//经过交换，将最后一个元素（最大元素）脱离大根堆，并将未经排序的新树（$ ARR [0 ... $ I-1]）重新调整为大根堆
HeapAdjust（$ ARR，0 ，$ i - 1）;
}
}

$ arr = array（4,1,5,9,8,5,4,6,33,5,2,6）;
// HeapSort（$ arr）;
// echo“ ”;
// var_dump（$ arr）;

// ------------------------
// PHP内置字符串函数实现
// -------------- ----------
//字符串长度
函数strlen1（$ str）
{
if（$ str ==''）返回0;
$ count = 0;
while（1）{
if（$ str [$ count]！= NULL）{
$ count ++;
继续;
} else {
break;
}

}
返回$计数;

}
//截取子串
函数substr1（$ str，$ start，$ length = NULL）
{
if（$ str ==''|| $ start> strlen（$ str））return;
if（（$ length！= NULL）&&（$ start> 0）&&（$ length> strlen（$ str） - $ start））return;
if（（$ length！= NULL）&&（$ start <0）&&（$ length> strlen（$ str）+ $ start））return;
if（$ length == NULL）$ length =（strlen（$ str） - $ start）;
if（$ start <0）{
for（$ i =（strlen（$ str）+ $ start）; $ i <（strlen（$ str）+ $ start + $ length）; $ i ++）{
$ substr。= $ str [$ i]于;
}
}
如果（$长度> 0）{
对于（$ I = $启动; $ I < （$ start + $ length）; $ i ++）{
$ substr。= $ str [$ i];
}
}
如果（$长度<0）{
对于（$ I = $启动; $ I <（strlen的（$ STR）+ $长度）; $ I ++）{
。$ SUBSTR = $ STR [$ i]于;
}
}
返回$ SUBSTR;
}

//字符串翻转
函数strrev1（$ str）
{
if（$ str ==''）返回0;
for（$ i =（strlen（$ str） - 1）; $ i> = 0; $ i - ）{
$ rev_str。= $ str [$ i];
}
return $ rev_str;
}

//字符串比较
函数strcmp1（$ s1，$ s2）
{
if（strlen（$ s1）<strlen（$ s2））return -1;
if（strlen（$ s1）> strlen（$ s2））返回1;
for（$ i = 0; $ i <strlen（$ s1）; $ i ++）{
if（$ s1 [$ i] == $ s2 [$ i]）{
continue;
} else {
return false;
}
}
返回0;
}

//查找字符串
函数strstr1（$ str，$ substr）
{
$ m = strlen（$ str）;
$ n = strlen（$ substr）;
if（$ m <$ n）返回false;
for（$ i = 0; $ i <=（$ m- $ n + 1）; $ i ++）{
$ sub = substr（$ str，$ i，$ n）;
if（strcmp（$ sub，$ substr）== 0）返回$ i;
}
return false;
}
//字符串替换
函数str_replace1（$ substr，$ newsubstr，$ str）
{
$ m = strlen（$ str）;
$ n = strlen（$ substr）;
$ x = strlen（$ newsubstr）;
if（strchr（$ str，$ substr）== false）返回false;
for（$ i = 0; $ i <=（$ m- $ n + 1）; $ i ++）{
$ i = strchr（$ str，$ substr）;
$ str = str_delete（$ str，$ i，$ n）;
$ str = str_insert（$ str，$ i，$ newstr）;
}
return $ str;
}

// --------------------
//自实现字符串处理函数
// ----------------- ---
//插入
一段字符串函数str_insert（$ str，$ i，$ substr）
{
for（$ j = 0; $ j <$ i; $ j ++）{
$ startstr。= $ str [$ j ]。
}
为（$ J = $ I; $Ĵ<strlen的（$ STR）; $ J ++）{
$ laststr = $ STR [$ J]。
}
$ str =（$ startstr。$ substr。$ laststr）;
return $ str;
}
//删除
一段字符串函数str_delete（$ str，$ i，$ j）
{
for（$ c = 0; $ c <$ i; $ c ++）{
$ startstr。= $ str [$ c];
}
为（$ C =（$ 1 + $ j）的$ C <的strlen（$ STR）$ C ++）{
。$ laststr = $ STR [$ C];
}
$ str =（$ startstr。$ laststr）;
return $ str;
}
//复制字符串
函数strcpy（$ s1，$ s2）
{
if（strlen（$ s1）== NULL ||！isset（$ s2））return;
for（$ i = 0; $ i <strlen（$ s1）; $ i ++）{
$ s2 [] = $ s1 [$ i];
}
return $ s2;
}
//连接字符串
函数strcat（$ s1，$ s2）
{
if（！isset（$ s1）||！isset（$ s2））return;
$ newstr = $ s1;
for（$ i = 0; $ i <count（$ s）; $ i ++）{
$ newstr。= $ st [$ i];
}
return $ newsstr;
}
//简单编码函数（与php_decode函数对应）
函数php_encode（$ str）
{
if（$ str ==''&& strlen（$ str）> 128）return false;
for（$ i = 0; $ i <strlen（$ str）; $ i ++）{
$ c = ord（$ str [$ i]）;
if（$ c> 31 && $ c <107）$ c + = 20;
if（$ c> 106 && $ c <127）$ c - = 75;
$ word = chr（$ c）;
$ s。= $ word;
}
return $ s;
}
//简单解码函数（与php_encode函数对应）
函数php_decode（$ str）
{
if（$ str ==''&& strlen（$ str）> 128）return false;
for（$ i = 0; $ i <strlen（$ str）; $ i ++）{
$ c = ord（$ word）;
if（$ c> 106 && $ c <127）$ c = $ c-20;
if（$ c> 31 && $ c <107）$ c = $ c + 75;
$ word = chr（$ c）;
$ s。= $ word;
}
return $ s;
}
//简单加密函数（与php_decrypt函数对应）
函数php_encrypt（$ str）
{
$ encrypt_key ='abcdefghijklmnopqrstuvwxyz1234567890';
$ decrypt_key ='ngzqtcobmuhelkpdawxfyivrsj2468021359';
if（strlen（$ str）== 0）return false;
for（$ i = 0; $ i <strlen（$ str）; $ i ++）{
for（$ j = 0; $ j <strlen（$ encrypt_key）; $ j ++）{
if（$ str [$ i] == $ encrypt_key [$ j]）{
$ enstr。= $ decrypt_key [$ j];
打破;
}
}
}
返回$ enstr;
}
//简单解密函数（与php_encrypt函数对应）
函数php_decrypt（$ str）
{
$ encrypt_key ='abcdefghijklmnopqrstuvwxyz1234567890';
$ decrypt_key ='ngzqtcobmuhelkpdawxfyivrsj2468021359';
if（strlen（$ str）== 0）return false;
for（$ i = 0; $ i <strlen（$ str）; $ i ++）{
for（$ j = 0; $ j <strlen（$ decrypt_key）; $ j ++）{
if（$ str [$ i] == $ decrypt_key [$ j]）{
$ enstr。= $ encrypt_key [$ j];
打破;
}
}
}
返回$ enstr;
}
？>

qq_40250529

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
php 函数算法优化源码迭代器

&lt;？php// -------------------- //基本数据结构算法 // ----------------- --- //二分查找（数组里查找某个元素）递归实现 // $ array数组$ low开始位置$ hight长度减一（求索引位置）$ k查询元素函数bin_sch（$ array，$ low，$高，$ k）{ if（$ low &l...
复制链接

扫一扫