注：为方便描述，下面的排序全为正序（从小到大排序）
假设有一个数组[a,b,c,d]
冒泡排序依次比较相邻的两个元素，如果前面的元素大于后面的元素，则两元素交换位置；否则，位置不变。具体步骤：
1，比较a,b这两个元素，如果a>b,则交换位置，数组变为：[b,a,c,d]
2，比较a,c这两个元素，如果a<c,则位置不变，数组变为：[b,a,c,d]
3，比较c,d这两个元素，如果c>d,则交换位置，数组变为：[b,a,d,c]
完成第一轮比较后，可以发现最大的数c已经排（冒）在最后面了，接着再进行第二轮比较，但第二轮比较不必比较最后一个元素了，因为最后一个元素已经是最大的了。
第二轮比较结束后，第二大的数也会冒到倒数第二的位置。
依次类推，再进行第三轮，，，
就这样最大的数一直往后排（冒），最后完成排序。所以我们称这种排序算法为冒泡排序。
选择排序是一种直观的算法，每一轮会选出列中最小的值，把最小值排到前面。具体步骤如下:
插入排序步骤大致如下：
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。
步骤：
从数列中挑出一个元素，称为 “基准”（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
2. 常见的php排序算法
常见的php排序算法
本文汇总了常见的php排序算法，在进行算法设计的时候有不错的借鉴价值。现分享给大家供参考之用。具体如下：
一、插入排序
用文字简单的描述，比如说$arr = array(4,2,4,6,3,6,1,7,9); 这样的一组数字进行顺序排序：
那么，首先，拿数组的第二个元素和第一元素比较，假如第一个元素大于第二元素，那么就让两者位置互换，接下来，拿数组的第三个元素，分别和第二个，第一个元素比较，假如第三个元素小，那么就互换。依次类推。这就是插入排序,它的时间频度是：1+2+...+(n-1)=(n^2)/2。则它的时间复杂度为O(n^2).
php实现代码如下：
<?phpfunction Sort($arr){ $count = count($arr); if($count<2){ return $arr; } for($i=1;$i<$count;$i++){ tmp="$arr[$i];" j="">=0&&$arr[$j]<$arr[$i]){ return="">
二、选择排序
选择排序用语言描述的话，可以这样,如：$arr = array(4,3,5,2,1);
首先,拿第一个和后面所有的比，找出最小的那个数字，然后和第一个数组互换（当然，如果是第一个最小，那么就不用互换了），接着循环，即：拿第二个和后面的比较，找出最小的数字，然后和第二个数字互换，依次类推，也就是说每次都是找出剩余最小的值。 可得到：第一次，时间频度 是n, （第一个和后面的n－1个比较，找到最小的，再看是不是第一个，不是第一个的话进行互换） 在往后，依次是 减一 。 它的时间复杂度，也是O(n^2);
php实现代码如下：
<?phpfunction selectSort($arr){ $count = count($arr); if($count<2){ return $arr; } for($i=0;$i<$count;$i++){ $min=$i; for(j=$i+1;$j<$count;$j++){>$arr[$j]){ $min = $j; //找到最小的那个元素的下标 } } if($min!=$i){//如果下标不是$i 则互换。 $tmp= $arr[$i]; $arr[$i] = $arr[$min]; $arr[$min] = $tmp; } } return $arr; }?>
三、冒泡排序
冒泡排序其实上是和选择排序相比，并无明显差别。都是找到最小的，放到最左端。依次循环解决问题。差别在于冒泡排序的交换位置的次数较多，而选择排序则是找到最小的元素的下标，然后直接和最左端的交换位置。
php实现代码如下：
<?phpfunction selectSort($arr){ $count = count($arr); if($count<2){ return $arr; } for($i=0;$i<$count;$i++){ for(j=$i+1;$j<$count;$j++){>$arr[$j]){ $tmp= $arr[$i]; $arr[$i] = $arr[$i]; $arr[$i] = $tmp; } } } return $arr; }?>
四、快速排序
快速排序，用语言来形容的话，从数组中选择一个值$a，然后和其余元素进行比较，比$a大的放到数组right中，反之，放到数组left中。然后将left right 分别进行递归调用，即：再细分left right ，最后进行数组的合并。
php实现快速排序：
<?phpfunction mySort($arr){ $count = count($arr); if($count<2){ return $arr; } $key = $arr[0];//选择第一个元素作为比较元素，可选其他 $left = array(); $right = array(); for($i=1;$i<$count;$i++){ key="">=$arr[$i]){ $left[] = $arr[$i]; }else{ $right[] = $arr[$i]; } } $left = mySort($left); $right = mySort($right); $result = array_merge($left,$right); return $result; }?>
五、归并排序
其实归并排序是一种拆分，合并的思想。和快速排序思想有共通之处，左边一堆，右边一堆，然后进行合并。通过递归实现排序。 区别之处呢？ 他们的区别也是思想上本质的区别，快速排序的拆分，是选择了特定的值进行大小比较，从而分为left 和 right 。也就是小的一堆放入left，大的一堆放入right。而后，小的left 再细分为left1 right1。。。。通过进行类似的递归完成排序。也就是说，一直细分下去，递归最末尾的left1就是最小值。
而归并排序，是从几何上的左右切分，一直递归切分成2或者1的'最小粒度的数组，然后才开始进行比较大小，然后合并。此处的比较大小是：儿子left的元素 和儿子的right元素 进行比较，而后进行排序合并成为父亲left或者right。在此，直到拿到各自排序合并完成最后两个数组：最起初的left 和right，也仅仅直到他们各自的顺序，并不能确认整个数组的顺序，还是需要通过最终的left right 比较后合并才能完成真正意义上的排序。
<?phpfunction gbSort($arr){ if(count($arr)<=1){return min="floor(count($arr)/2);//取中间数字进行拆分" left="gbSort($left);" right="gbSort($right);" return="" function="">$right[0] ? array_shift($right) : array_shift($left); //进行比较，小的移除，并且放入到数组$m中。 } return arr_merge($m,$left,$right);//进行合并（由于不知道left right 哪个会为空，所以进行统一合并）}?>
六、堆排序
本例中fixDown函数实现对某一个节点的向下调整，这里默认的是起始节点为1，方便计算父子节点关系
注:
起始节点为1的父子关系: 父节点k, 子节点为2K、2k+1 子节点j, 父节点为 floor(j/2) floor为向下取整
起始节点为0的父子关系: 父节点k, 子节点为2K+1, 2k+2 子节点j, 父节点为 floor((j-1)/2)
参数$k为调整点位置, $lenth为数组长度，也就是从1起始到最后一个节点的坐标.
<?phpfunction fixDown(&$arr, $k, $lenth){while(2*$k<=$lenth) { //只要当前节点有子节点， 就需要继续该循环 $j = $k*2; if ($j<$lenth && $arr[$j]<$arr[$j+1]) $j++; // 只要子节点有右节点，且右节点比左节点大，那么切换到右节点操作。 if ($arr[$j] < $arr[$k]) break; // 如果子节点都没有父节点大， 那么调整结束。 exch($arr[$j], $arr[$k]); $k = $j; }}function exch(&$a, &$b) { $tmp = $a; $a = $b; $b = $tmp;}function headSort(&$arr){ $len = count($arr); array_unshift($arr, NULL); for($i=$len/2;$i>=1;$i--) { fixDown($arr, $i, $len); } while($len>1) { exch($arr[1], $arr[$len]); fixDown($arr, 1, --$len); } array_shift($arr);}$arr = array(4,6,4,9,2,3);headSort($arr);?>
希望本文所述排序算法实例对大家的php程序设计有所帮助。
;3. php现在有哪些常用的算法
<?
//--------------------
// 基本数据结构算法
//--------------------
//二分查找（数组里查找某个元素）
function bin_sch($array, $low, $high, $k){
if ( $low <= $high){
$mid = intval(($low+$high)/2 );
if ($array[$mid] == $k){
return $mid;
}elseif ( $k < $array[$mid]){
return bin_sch($array, $low, $mid-1, $k);
}else{
return bin_sch($array, $mid+ 1, $high, $k);
}
}
return -1;
}
//顺序查找（数组里查找某个元素）
function seq_sch($array, $n, $k){
$array[$n] = $k;
for($i=0; $i<$n; $i++){
if( $array[$i]==$k){
break;
}
}
if ($i<$n){
return $i;
}else{
return -1;
}
}
//线性表的删除（数组中实现）
function delete_array_element($array , $i)
{
$len = count($array);
for ($j= $i; $j<$len; $j ++){
$array[$j] = $array [$j+1];
}
array_pop ($array);
return $array ;
}
//冒泡排序（数组排序）
function bubble_sort( $array)
{
$count = count( $array);
if ($count <= 0 ) return false;
for($i=0 ; $i<$count; $i ++){
for($j=$count-1 ; $j>$i; $j--){
if ($array[$j] < $array [$j-1]){
$tmp = $array[$j];
$array[$j] = $array[ $j-1];
$array [$j-1] = $tmp;
}
}
}
return $array;
}
//快速排序（数组排序）
function quick_sort($array ) {
if (count($array) <= 1) return $array;
$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);
return array_merge($left_arr , array($key), $right_arr);
}
//------------------------
// PHP内置字符串函数实现
//------------------------
//字符串长度
function strlen ($str)
{
if ($str == '' ) return 0;
$count = 0;
while (1){
if ( $str[$count] != NULL){
$count++;
continue;
}else{
break;
}
}
return $count;
}
//截取子串
function substr($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];
}
}
if ($length > 0){
for ($i= $start; $i<($start+$length ); $i++) {
$substr .= $str[$i];
}
}
if ( $length < 0){
for ($i =$start; $i<(strlen( $str)+$length); $i++) {
$substr .= $str[$i ];
}
}
return $substr;
}
//字符串翻转
function strrev($str)
{
if ($str == '') return 0 ;
for ($i=(strlen($str)- 1); $i>=0; $i --){
$rev_str .= $str[$i ];
}
return $rev_str;
}
//字符串比较
function strcmp($s1, $s2)
{
if (strlen($s1) < strlen($s2)) return -1 ;
if (strlen($s1) > strlen( $s2)) return 1;
for ($i =0; $i<strlen($s1 ); $i++){
if ($s1[ $i] == $s2[$i]){
continue;
}else{
return false;
}
}
return 0;
}
//查找字符串
function strstr($str, $substr)
{
$m = strlen($str);
$n = strlen($substr );
if ($m < $n) return false ;
for ($i=0; $i <=($m-$n+1); $i ++){
$sub = substr( $str, $i, $n);
if ( strcmp($sub, $substr) == 0) return $i;
}
return false ;
}
//字符串替换
function str_replace($substr , $newsubstr, $str)
{
$m = strlen($str);
$n = strlen($substr );
$x = strlen($newsubstr );
if (strchr($str, $substr ) == false) return 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 ;
}
//--------------------
// 自实现字符串处理函数
//--------------------
//插入一段字符串
function str_insert($str, $i , $substr)
{
for($j=0 ; $j<$i; $j ++){
$startstr .= $str[$j ];
}
for ($j=$i; $j <strlen($str); $j ++){
$laststr .= $str[$j ];
}
$str = ($startstr . $substr . $laststr);
return $str ;
}
//删除一段字符串
function str_delete($str , $i, $j)
{
for ( $c=0; $c<$i; $c++){
$startstr .= $str [$c];
}
for ($c=( $i+$j); $c<strlen ($str); $c++){
$laststr .= $str[$c];
}
$str = ($startstr . $laststr );
return $str;
}
//复制字符串
function strcpy($s1, $s2 )
{
if (strlen($s1)==NULL || !isset( $s2)) return;
for ($i=0 ; $i<strlen($s1); $i++){
$s2[] = $s1 [$i];
}
return $s2;
}
//连接字符串
function 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函数对应）
function 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函数对应）
function 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函数对应）
function php_encrypt($str)
{
$encrypt_key = '';
$decrypt_key = '';
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];
break;
}
}
}
return $enstr;
}
//简单解密函数（与php_encrypt函数对应）
function php_decrypt($str)
{
$encrypt_key = '';
$decrypt_key = '';
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];
break;
}
}
}
return $enstr;
}
?>
4. php 简单算法
$int = 100;// $int 要计算的数字
$n = 3; //$n 是归属的最大值
/* 下面的代码生成归属描述数组 */
$array = array();
for ($i = 0; $i < n; $i ++) {
$array[$i+1] = pow(3, $i);
}
//现在$array为array(1 => 1, 2 => 3, 3 => 9)
$limit = 0; //当前范围
$is = 0; //归属
foreach ($array as $key => $value) {
$limit += $value;
if ($limit>= $int) {
break;
}
}
echo $is;//这个就是结果了
5. PHP对称加密-AES
对称加解密算法中，当前最为安全的是 AES 加密算法（以前应该是是 DES 加密算法），PHP 提供了两个可以用于 AES 加密算法的函数簇： Mcrypt 和 OpenSSL 。
其中 Mcrypt 在 PHP 7.1.0 中被弃用（The Function Mycrypt is Deprecated)，在 PHP 7.2.0 中被移除，所以即可起你应该使用 OpenSSL 来实现 AES 的数据加解密。
在一些场景下，我们不能保证两套通信系统都使用了相函数簇去实现加密算法，可能 siteA 使用了最新的 OpenSSL 来实现了 AES 加密，但作为第三方服务的 siteB 可能仍在使用 Mcrypt 算法，这就要求我们必须清楚 Mcrypt 同 OpenSSL 之间的差异，以便保证数据加解密的一致性。
下文中我们将分别使用 Mcrypt 和 OpenSSL 来实现 AES-128/192/256-CBC 加解密，二者同步加解密的要点为：
协同好以上两点，就可以让 Mcrypt 和 OpenSSL 之间一致性的对数据进行加解密。
AES 是当前最为常用的安全对称加密算法，关于对称加密这里就不在阐述了。
AES 有三种算法，主要是对数据块的大小存在区别：
AES-128：需要提供 16 位的密钥 key
AES-192：需要提供 24 位的密钥 key
AES-256：需要提供 32 位的密钥 key
AES 是按数据块大小（128/192/256）对待加密内容进行分块处理的，会经常出现最后一段数据长度不足的场景，这时就需要填充数据长度到加密算法对应的数据块大小。
主要的填充算法有填充 NUL("0") 和 PKCS7，Mcrypt 默认使用的 NUL("0") 填充算法，当前已不被推荐，OpenSSL 则默认模式使用 PKCS7 对数据进行填充并对加密后的数据进行了 base64encode 编码，所以建议开发中使用 PKCS7 对待加密数据进行填充，已保证通用性（alipay sdk 中虽然使用了 Mcrypt 加密簇，但使用 PKCS7 算法对数据进行了填充，这样在一定程度上亲和了 OpenSSL 加密算法）。
Mcrypt 的默认填充算法。NUL 即为 Ascii 表的编号为 0 的元素，即空元素，转移字符是 " "，PHP 的 pack 打包函数在 'a' 模式下就是以 NUL 字符对内容进行填充的，当然，使用 " " 手动拼接也是可以的。
OpenSSL的默认填充算法。下面我们给出 PKCS7 填充算法 PHP 的实现：
默认使用 NUL(" ") 自动对待加密数据进行填充以对齐加密算法数据块长度。
获取 mcrypt 支持的算法，这里我们只关注 AES 算法。
注意：mcrypt 虽然支持 AES 三种算法，但除 MCRYPT_RIJNDAEL_128 外， MCRYPT_RIJNDAEL_192/256 并未遵循 AES-192/256 标准进行加解密的算法，即如果你同其他系统通信（java/.net），使用 MCRYPT_RIJNDAEL_192/256 可能无法被其他严格按照 AES-192/256 标准的系统正确的数据解密。官方文档页面中也有人在 User Contributed Notes 中提及。这里给出如何使用 mcrpyt 做标注的 AES-128/192/256 加解密
即算法统一使用 MCRYPT_RIJNDAEL_128 ，并通过 key 的位数 来选定是以何种 AES 标准做的加密，iv 是建议添加且建议固定为16位（OpenSSL的 AES加密 iv 始终为 16 位，便于统一对齐），mode 选用的 CBC 模式。
mcrypt 在对数据进行加密处理时，如果发现数据长度与使用的加密算法的数据块长度未对齐，则会自动使用 " " 对待加密数据进行填充，但 " " 填充模式已不再被推荐，为了与其他系统有更好的兼容性，建议大家手动对数据进行 PKCS7 填充。
openssl 簇加密方法更为简单明确，mcrypt 还要将加密算法分为 cipher + mode 去指定，openssl 则只需要直接指定 method 为 AES-128-CBC，AES-192-CBC，AES-256-CBC 即可。且提供了三种数据处理模式，即 默认模式 0 / OPENSSL_RAW_DATA / OPENSSL_ZERO_PADDING 。
openssl 默认的数据填充方式是 PKCS7，为兼容 mcrpty 也提供处理 "0" 填充的数据的模式，具体为下：
options 参数即为重要，它是兼容 mcrpty 算法的关键：
options = 0 : 默认模式，自动对明文进行 pkcs7 padding，且数据做 base64 编码处理。
options = 1 : OPENSSL_RAW_DATA，自动对明文进行 pkcs7 padding， 且数据未经 base64 编码处理。
options = 2 : OPENSSL_ZERO_PADDING，要求待加密的数据长度已按 "0" 填充与加密算法数据块长度对齐，即同 mcrpty 默认填充的方式一致，且对数据做 base64 编码处理。注意，此模式下 openssl 要求待加密数据已按 "0" 填充好，其并不会自动帮你填充数据，如果未填充对齐，则会报错。
故可以得出 mcrpty簇 与 openssl簇 的兼容条件如下：
建议将源码复制到本地运行，根据运行结果更好理解。
1.二者使用的何种填充算法。
2.二者对数据是否有 base64 编码要求。
3.mcrypt 需固定使用 MCRYPT_RIJNDAEL_128，并通过调整 key 的长度 16, 24，32 来实现 ase-128/192/256 加密算法。
6. php几种排序算法实例详解
四种排序算法的PHP实现：
1)插入排序(InsertionSort)的基本思想是：
每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
2)选择排序(SelectionSort)的基本思想是：
每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
3)冒泡排序的基本思想是：
两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
4)快速排序实质上和冒泡排序一样，都是属于交换排序的一种应用。所以基本思想和上面的冒泡排序是一样的。
1.sort.php文件如下：
<?php
classSort{
private$arr=array();
private$sort='insert';
private$marker='_sort';
private$debug=TRUE;
/**
*构造函数
*
*@paramarray例如：
$config=array(
'arr'=>array(22,3,41,18),//需要排序的数组值
'sort'=>'insert',//可能值:insert,select,bubble,quick
'debug'=>TRUE//可能值:TRUE,FALSE
)
*/
publicfunctionconstruct($config=array()){
if(count($config)>0){
$this->_init($config);
}
}
/**
*获取排序结果
*/
publicfunctiondisplay(){
return$this->arr;
}
/**
*初始化
*
*@paramarray
*@returnbool
*/
privatefunction_init($config=array()){
//参数判断
if(!is_array($config)ORcount($config)==0){
if($this->debug===TRUE){
$this->_log("sort_init_param_invaild");
}
returnFALSE;
}
//初始化成员变量
foreach($configas$key=>$val){
if(isset($this->$key)){
$this->$key=$val;
}
}
//调用相应的成员方法完成排序
$method=$this->sort.$this->marker;
if(!method_exists($this,$method)){
if($this->debug===TRUE){
$this->_log("sort_method_invaild");
}
returnFALSE;
}
if(FALSE===($this->arr=$this->$method($this->arr)))
returnFALSE;
returnTRUE;
}
/**
*插入排序
*
*@paramarray
*@returnbool
*/
privatefunctioninsert_sort($arr){
//参数判断
if(!is_array($arr)ORcount($arr)==0){
if($this->debug===TRUE){
$this->_log("sort_array(insert)_invaild");
}
returnFALSE;
}
//具体实现
$count=count($arr);
for($i=1;$i<$count;$i++){
$tmp=$arr[$i];
for($j=$i-1;$j>=0;$j--){
if($arr[$j]>$tmp){
$arr[$j+1]=$arr[$j];
$arr[$j]=$tmp;
}
}
}
return$arr;
}
/**
*选择排序
*
*@paramarray
*@returnbool
*/
privatefunctionselect_sort($arr){
//参数判断
if(!is_array($arr)ORcount($arr)==0){
if($this->debug===TRUE){
$this->_log("sort_array(select)_invaild");
}
returnFALSE;
}
//具体实现
$count=count($arr);
for($i=0;$i<$count-1;$i++){
$min=$i;
for($j=$i+1;$j<$count;$j++){
if($arr[$min]>$arr[$j])$min=$j;
}
if($min!=$i){
$tmp=$arr[$min];
$arr[$min]=$arr[$i];
$arr[$i]=$tmp;
}
}
return$arr;
}
/**
*冒泡排序
*
*@paramarray
*@returnbool
*/
privatefunctionbubble_sort($arr){
//参数判断
if(!is_array($arr)ORcount($arr)==0){
if($this->debug===TRUE){
$this->_log("sort_array(bubble)_invaild");
}
returnFALSE;
}
//具体实现
$count=count($arr);
for($i=0;$i<$count;$i++){
for($j=$count-1;$j>$i;$j--){
if($arr[$j]<$arr[$j-1]){
$tmp=$arr[$j];
$arr[$j]=$arr[$j-1];
$arr[$j-1]=$tmp;
}
}
}
return$arr;
}
/**
*快速排序
*@bywww.5wx.org
*@paramarray
*@returnbool
*/
privatefunctionquick_sort($arr){
//具体实现
if(count($arr)<=1)return$arr;
$key=$arr[0];
$left_arr=array();
$right_arr=array();
for($i=1;$i<count($arr);$i++){
if($arr[$i]<=$key)
$left_arr[]=$arr[$i];
else
$right_arr[]=$arr[$i];
}
$left_arr=$this->quick_sort($left_arr);
$right_arr=$this->quick_sort($right_arr);
returnarray_merge($left_arr,array($key),$right_arr);
}
/**
*日志记录
*/
privatefunction_log($msg){
$msg='date['.date('Y-m-dH:i:s').']'.$msg.' ';
return@file_put_contents('sort_err.log',$msg,FILE_APPEND);
}
}
/*Endoffilesort.php*/
/*Locationhtdocs/sort.php*/
2.sort_demo.php文件如下：
<?php
require_once('sort.php');
$config=array(
'arr'=>array(23,22,41,18,20,12,200303,2200,1192),
//需要排序的数组值
'sort'=>'select',
//可能值:insert,select,bubble,quick
'debug'=>TRUE
//可能值:TRUE,FALSE
);
$sort=newSort($config);
//var_mp($config['arr']);
var_mp($sort->display());
/*Endofphp*/
7. 如何实现PHP的TEA算法
算法简单,而且效率高,每次可以操作8个字节的数据,加密解密的KEY为16字节,即包含4个int数据的int型数组,加密轮数应为8的倍数,一般比较常用的轮数为64,32,16,QQ原来就是用TEA16来还原密码的.
TEA算法
核心为：
#include<stdint.h>
voidencrypt(uint32_t*v,uint32_t*k){
uint32_tv0=v[0],v1=v[1],sum=0,i;/*setup*/
uint32_tdelta=0x9e3779b9;/*akeyscheleconstant*/
uint32_tk0=k[0],k1=k[1],k2=k[2],k3=k[3];/*cachekey*/
for(i=0;i<32;i++){/*basiccyclestart*/
sum+=delta;
v0+=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
v1+=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
}/*endcycle*/
v[0]=v0;v[1]=v1;
}
voiddecrypt(uint32_t*v,uint32_t*k){
uint32_tv0=v[0],v1=v[1],sum=0xC6EF3720,i;/*setup*/
uint32_tdelta=0x9e3779b9;/*akeyscheleconstant*/
uint32_tk0=k[0],k1=k[1],k2=k[2],k3=k[3];/*cachekey*/
for(i=0;i<32;i++){/*basiccyclestart*/
v1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
v0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
sum-=delta;
}/*endcycle*/
v[0]=v0;v[1]=v1;
}
PHP部分代码非我原创，大家可以了解一下这方面的知识
<?php
$date='8345354023476-3434';
$key='12345';
$t=newtea();
$tea=$t->encrypt($date,$key);
$eetea=$t->decrypt($tea,$key);
var_mp($tea);
var_mp($eetea);
classtea{
private$a,$b,$c,$d;
private$n_iter;
publicfunction__construct(){
$this->setIter(32);
}
privatefunctionsetIter($n_iter){
$this->n_iter=$n_iter;
}
privatefunctiongetIter(){
return$this->n_iter;
}
publicfunctionencrypt($data,$key){
//resizedatato32bits(4bytes)
$n=$this->_resize($data,4);
//convertdatatolong
$data_long[0]=$n;
$n_data_long=$this->_str2long(1,$data,$data_long);
//resizedata_longto64bits(2longsof32bits)
$n=count($data_long);
if(($n&1)==1){
$data_long[$n]=chr(0);
$n_data_long++;
}
//resizekeytoamultipleof128bits(16bytes)
$this->_resize($key,16,true);
if(''==$key)
$key='0000000000000000';
//convertkeytolong
$n_key_long=$this->_str2long(0,$key,$key_long);
//encryptthelongdatawiththekey
$enc_data='';
$w=array(0,0);
$j=0;
$k=array(0,0,0,0);
for($i=0;$i<$n_data_long;++$i){
//getnextkeypartof128bits
if($j+4<=$n_key_long){
$k[0]=$key_long[$j];
$k[1]=$key_long[$j+1];
$k[2]=$key_long[$j+2];
$k[3]=$key_long[$j+3];
}else{
$k[0]=$key_long[$j%$n_key_long];
$k[1]=$key_long[($j+1)%$n_key_long];
$k[2]=$key_long[($j+2)%$n_key_long];
$k[3]=$key_long[($j+3)%$n_key_long];
}
$j=($j+4)%$n_key_long;
$this->_encipherLong($data_long[$i],$data_long[++$i],$w,$k);
//
$enc_data.=$this->_long2str($w[0]);
$enc_data.=$this->_long2str($w[1]);
}
return$enc_data;
}
publicfunctiondecrypt($enc_data,$key){
//convertdatatolong
$n_enc_data_long=$this->_str2long(0,$enc_data,$enc_data_long);
//resizekeytoamultipleof128bits(16bytes)
$this->_resize($key,16,true);
if(''==$key)
$key='0000000000000000';
//convertkeytolong
$n_key_long=$this->_str2long(0,$key,$key_long);
//decryptthelongdatawiththekey
$data='';
$w=array(0,0);
$j=0;
$len=0;
$k=array(0,0,0,0);
$pos=0;
for($i=0;$i<$n_enc_data_long;$i+=2){
//getnextkeypartof128bits
if($j+4<=$n_key_long){
$k[0]=$key_long[$j];
$k[1]=$key_long[$j+1];
$k[2]=$key_long[$j+2];
$k[3]=$key_long[$j+3];
}else{
$k[0]=$key_long[$j%$n_key_long];
$k[1]=$key_long[($j+1)%$n_key_long];
$k[2]=$key_long[($j+2)%$n_key_long];
$k[3]=$key_long[($j+3)%$n_key_long];
}
$j=($j+4)%$n_key_long;
$this->_decipherLong($enc_data_long[$i],$enc_data_long[$i+1],$w,$k);
//(removepadding)
if(0==$i){
$len=$w[0];
if(4<=$len){
$data.=$this->_long2str($w[1]);
}else{
$data.=substr($this->_long2str($w[1]),0,$len%4);
}
}else{
$pos=($i-1)*4;
if($pos+4<=$len){
$data.=$this->_long2str($w[0]);
if($pos+8<=$len){
$data.=$this->_long2str($w[1]);
}elseif($pos+4<$len){
$data.=substr($this->_long2str($w[1]),0,$len%4);
}
}else{
$data.=substr($this->_long2str($w[0]),0,$len%4);
}
}
}
return$data;
}
privatefunction_encipherLong($y,$z,&$w,&$k){
$sum=(integer)0;
$delta=0x9E3779B9;
$n=(integer)$this->n_iter;
while($n-->0){
//Cv0+=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
//Cv1+=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
$sum=$this->_add($sum,$delta);
$y=$this->_add($y,$this->_add(($z<<4),$this->a)^$this->_add($z,$sum)^$this->_add($this->_rshift($z,5),$this->b));
$z=$this->_add($z,$this->_add(($y<<4),$this->a)^$this->_add($y,$sum)^$this->_add($this->_rshift($y,5),$this->b));
}
$w[0]=$y;
$w[1]=$z;
}
privatefunction_decipherLong($y,$z,&$w,&$k){
//sum=delta<<5,ingeneralsum=delta*n
$sum=0xC6EF3720;
$delta=0x9E3779B9;
$n=(integer)$this->n_iter;
while($n-->0){
//Cv1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
//Cv0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
$z=$this->_add($z,-($this->_add(($y<<4),$this->a)^$this->_add($y,$sum)^$this->_add($this->_rshift($y,5),$this->b)));
$y=$this->_add($y,-($this->_add(($z<<4),$this->a)^$this->_add($z,$sum)^$this->_add($this->_rshift($z,5),$this->b)));
$sum=$this->_add($sum,-$delta);
}
$w[0]=$y;
$w[1]=$z;
}
privatefunction_resize(&$data,$size,$nonull=false){
$n=strlen($data);
$nmod=$n%$size;
if(0==$nmod)
$nmod=$size;
if($nmod>0){
if($nonull){
for($i=$n;$i<$n-$nmod+$size;++$i){
$data[$i]=$data[$i%$n];
}
}else{
for($i=$n;$i<$n-$nmod+$size;++$i){
$data[$i]=chr(0);
}
}
}
return$n;
}
privatefunction_hex2bin($str){
$len=strlen($str);
returnpack('H'.$len,$str);
}
privatefunction_str2long($start,&$data,&$data_long){
$n=strlen($data);
$tmp=unpack('N*',$data);
$j=$start;
foreach($tmpas$value)
$data_long[$j++]=$value;
return$j;
}
privatefunction_long2str($l){
returnpack('N',$l);
}
privatefunction_rshift($integer,$n){
//convertto32bits
if(0xffffffff<$integer||-0xffffffff>$integer){
$integer=fmod($integer,0xffffffff+1);
}
//converttounsignedinteger
if(0x7fffffff<$integer){
$integer-=0xffffffff+1.0;
}elseif(-0x80000000>$integer){
$integer+=0xffffffff+1.0;
}
//dorightshift
if(0>$integer){
$integer&=0x7fffffff;//removesignbitbeforeshift
$integer>>=$n;//rightshift
$integer|=1<<(31-$n);//setshiftedsignbit
}else{
$integer>>=$n;//usenormalrightshift
}
return$integer;
}
privatefunction_add($i1,$i2){
$result=0.0;
foreach(func_get_args()as$value){
//removesignifnecessary
if(0.0>$value){
$value-=1.0+0xffffffff;
}
$result+=$value;
}
//convertto32bits
if(0xffffffff<$result||-0xffffffff>$result){
$result=fmod($result,0xffffffff+1);
}
//converttosignedinteger
if(0x7fffffff<$result){
$result-=0xffffffff+1.0;
}elseif(-0x80000000>$result){
$result+=0xffffffff+1.0;
}
return$result;
}
//}}}
}
?>
上面的是TEA的算法，XTEA的算法为：
#include <stdint.h>
void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const k[4]) {
unsigned int i;
uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;
for (i=0; i < num_rounds; i++) {
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
}
v[0]=v0; v[1]=v1;
}
void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const k[4]) {
unsigned int i;
uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds;
for (i=0; i < num_rounds; i++) {
v1 −= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
sum −= delta;
v0 −= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
}
v[0]=v0; v[1]=v1;
}
那PHP中只需要把运算的位置改下就OK
private function _teaencipherLong($y, $z, &$w, &$k) {
$sum = ( integer ) 0;
$delta = 0x9E3779B9;
$n = ( integer ) $this->n_iter;
while ( $n -- > 0 ) {
$y = $this->_add ( $y, $this->_add ( $z << 4 ^ $this->_rshift ( $z, 5 ), $z ) ^ $this->_add ( $sum, $k [$sum & 3] ) );
$sum = $this->_add ( $sum, $delta );
$z = $this->_add ( $z, $this->_add ( $y << 4 ^ $this->_rshift ( $y, 5 ), $y ) ^ $this->_add ( $sum, $k [$this->_rshift ( $sum, 11 ) & 3] ) );
}
$w [0] = $y;
$w [1] = $z;
}
private function _decipherLong($y, $z, &$w, &$k) {
// sum = delta<<5, in general sum = delta * n
$sum = 0xC6EF3720;
$delta = 0x9E3779B9;
$n = ( integer ) $this->n_iter;
while ( $n -- > 0 ) {
$z = $this->_add ( $z, - ($this->_add ( $y << 4 ^ $this->_rshift ( $y, 5 ), $y ) ^ $this->_add ( $sum, $k [$this->_rshift ( $sum, 11 ) & 3] )) );
$sum = $this->_add ( $sum, - $delta );
$y = $this->_add ( $y, - ($this->_add ( $z << 4 ^ $this->_rshift ( $z, 5 ), $z ) ^ $this->_add ( $sum, $k [$sum & 3] )) );
}
$w [0] = $y;
$w [1] = $z;
8. PHP快速排序算法实现的原理及代码详解
算法原理
下列动图来自五分钟学算法，演示了快速排序算法的原理和步骤。
步骤:
从数组中选个基准值
将数组中大于基准值的放同一边、小于基准值的放另一边，基准值位于中间位置
递归的对分列两边的数组再排序
代码实现
function
quickSort($arr)
{
$len
=
count($arr);
if
($len
<=
1)
{
return
$arr;
}
$v
=
$arr[0];
$low
=
$up
=
array();
for
($i
=
1;
$i
<
$len;
++$i)
{
if
($arr[$i]
>
$v)
{
$up[]
=
$arr[$i];
}
else
{
$low[]
=
$arr[$i];
}
}
$low
=
quickSort($low);
$up
=
quickSort($up);
return
array_merge($low,
array($v),
$up);
}
测试代码:
$startTime
=
microtime(1);
$arr
=
range(1,
10);
shuffle($arr);
echo
"before
sort:
",
implode(',
',
$arr),
"\n";
$sortArr
=
quickSort($arr);
echo
"after
sort:
",
implode(',
',
$sortArr),
"\n";
echo
"use
time:
",
microtime(1)
-
$startTime,
"s\n";
测试结果:
before
sort:
1,
7,
10,
9,
6,
3,
2,
5,
4,
8
after
sort:
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
use
time:
0.0009009838104248s
时间复杂度
快速排序的时间复杂度在最坏情况下是O(N2)，平均的时间复杂度是O(N*lgN)。
这句话很好理解：假设被排序的数列中有N个数。遍历一次的时间复杂度是O(N)，需要遍历多少次呢？至少lg(N+1)次，最多N次。
1)
为什么最少是lg(N+1)次？快速排序是采用的分治法进行遍历的，我们将它看作一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是lg(N+1)。因此，快速排序的遍历次数最少是lg(N+1)次。
2)
为什么最多是N次？这个应该非常简单，还是将快速排序看作一棵二叉树，它的深度最大是N。因此，快读排序的遍历次数最多是N次。
您可能感兴趣的文章:PHP快速排序算法实例分析PHP四种排序算法实现及效率分析【冒泡排序,插入排序,选择排序和快速排序】PHP排序算法之快速排序(Quick
Sort)及其优化算法详解PHP递归实现快速排序的方法示例php
二维数组快速排序算法的实现代码PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】PHP快速排序quicksort实例详解
9. 深入研究php的redlock算法
为了应对服务器高并发，可以采用锁进行控制。
如果redis是单节点部署，基本上不会出现什么问题。但如果redis是多节点的集群部署，那么使用redis集群作为分布式锁就会存在一些问题。本文参（抄）考（袭）了以下文章。
闲聊Redis分布式锁
基于Redis的分布式锁到底安全吗（上）？
基于Redis的分布式锁到底安全吗（下）？
SET resource_name my_random_value NX PX 30000
如果返回成功，则说明客户端获取锁成功，然后就可以访问公共资源了，如果失败则获取锁失败。对于这条命令，需要注意
my_random_value：必须是一个随机字符，并且唯一。如果不唯一，可能会出现以下情况：
1.客户端1获取资源成功
2.客户端1阻塞超时，锁自动释放
3.客户端2获取锁成功
4.客户端1从阻塞中醒来，释放了客户端2的锁
必须设置NX，表示只有resource_name不存在时才会设置成功，保证只有第一个请求的客户端获取锁成功
PX 30000 表示过期时间为30s，为了保证原子操作必须在SET时设置过期时间
释放锁时使用下面的redis lua脚本执行来保证原子性。
只有当resource_name的值和客户端持有的数据相等时才能够调用del删除resource_name，否则不进行删除操作。从而防止一个客户端释放另一个客户端持有的锁。
分析一下redis锁的原理，我们在redis实例中创建一个键值，同时设置该键值的超时时间。创建该键值的客户端获取锁成功，访问公共资源。同时如果客户端宕机则锁会自动释放。客户端需要释放锁时只需要删除该键即可。但一旦单节点的Redis宕机则不能再提供服务，即使是基于Master-Slave模式的故障切换也是不安全的，例如下面场景
客户端1从Master获取锁
Master宕机，但锁key还没有同步到Slave上
Slave升级为Master
客户端2从新的Master上获取锁成功
算法实现
php源码实现
10. PHP程序算法
用户加入购物车 3个A and 2个B
在购物车下提示
当前使用(A+B) * 2 + A * 1 的方式可以节省多少钱
在数据库建立商品组合表
自增ID 组合名称 组合商品ID（1,2,3,4）优惠折扣
1 测试组合 1(A商品ID),2(B商品ID) 0.99
在每次用户确认订单之时判断当前加入购物车的商品是符合组合优惠
如果有则提示，没有就略过