php 除不尽的算法,PHP 排序算法之希尔排序

最新推荐文章于 2021-04-08 11:10:19 发布
最新推荐文章于 2021-04-08 11:10:19 发布
阅读量147 收藏
点赞数
文章标签： php 除不尽的算法

希尔排序之交换排序

问题引入：

在插入排序中，如果数组元素的排列情况比较乐观，那么插入的次数就比较少，那么效率就很高了，可是很多时候，数据就是那么的不敬人意，比如如下的一个待\

排序的数组：[2,3,4,5,6,7,1]，这个数组，如果使用插入排序，那么就会发生如下的样子：

第一轮:[2,3,4,5,6,7,7]

第二轮:[2,3,4,5,6,6,7]

第三轮:[2,3,4,5,5,6,7]

第四轮:[2,3,4,4,5,6,7]

第五轮:[2,3,3,4,5,6,7]

第六轮:[2,2,3,4,5,6,7]

第七轮:[1,2,3,4,5,6,7]

这样的就是最不乐观的情况，很浪费时间，所以，后来就有大神研究了一下，优化优化，就发明了希尔排序。

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort)，是直接插入排序算法的一种更高效的改进版本。

希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，

整个文件恰被分成一组，算法便终止

数组实例说明：

比如有一个待排序的数组 [9,6,1,3,0,5.7,2,8,4]

上面的数组一共有10个元素，它把数组第一次分为 10/2 = 5 组，然后两两比较，大小位置交换：如下：

$arr = [9,6,1,3,0, 5,7,2,8,4];

$arr[0] > $arr[5] ? '交换位置,小数交换在前，大数交换在后' : '不交换位置';

$arr[1] > $arr[6] ? '交换位置,小数交换在前，大数交换在后' : '不交换位置';

$arr[2] > $arr[7] ? '交换位置,小数交换在前，大数交换在后' : '不交换位置';

$arr[3] > $arr[8] ? '交换位置,小数交换在前，大数交换在后' : '不交换位置';

$arr[4] > $arr[9] ? '交换位置,小数交换在前，大数交换在后' : '不交换位置';

for ($i = 5; $i < 10; $i++) {

for ($j = $i - 5; $j >= 0; $j-=5) {

if ($data[$j] > $data[$j+5]) {

$temp = $data[$j];

$data[$j] = $data[$j+5];

$data[$j+5] = $temp;

}

}

}

最后第一轮得到的结果就是：[5,6,1,3,0,9,7,2,8,4]

第二轮又开始比较，第二轮是在之前第一轮的基础上，再次分为 5/2 = 2 组，然后两两交换位置，大小指互换：如下:

$arr = [5,6,1,3,0,9,7,2,8,4];

$arr[0] > $arr[2];//1,5 [1,6,5,3,0,9,7,2,8,4]

$arr[2] > $arr[4];//0,5 [1,6,0,3,5,9,7,2,8,4]

$arr[4] > $arr[6];//5,7 [1,6,0,3,5,9,7,2,8,4]

$arr[6] > $arr[8];//7,8 [1,6,0,3,5,9,7,2,8,4]

$arr[1] > $arr[3];//3,6 [1,3,0,6,5,9,7,2,8,4]

$arr[3] > $arr[5];//6,9 [1,3,0,6,5,9,7,2,8,4]

$arr[5] > $arr[7];//2,9 [1,3,0,6,5,2,7,9,8,4]

$arr[7] > $arr[9];//4,9 [1,3,0,6,5,2,7,4,8,9]

...

for ($i = 2; $i < 10; $i++) {

for ($j = $i - 2; $j >= 0; $j-=2) {

if ($data[$j] > $data[$j+2]) {

$temp = $data[$j];

$data[$j] = $data[$j+2];

$data[$j+2] = $temp;

}

}

}

最后得到的结果就是：[0,2,1,3,6,4,7,6,8,9]

最后再次分组比较：2/2 = 1组。也就是最后，每两个都要比较，然后再次互换位置

$arr = [0,2,1,3,5,4,7,6,8,9];

$arr[0] > $arr[1];//[1,3,0,6,5,2,7,4,8,9]

$arr[1] > $arr[2];//[1,0,3,6,5,2,7,4,8,9]

$arr[2] > $arr[3];//[1,0,3,6,5,2,7,4,8,9]

$arr[3] > $arr[4];//[1,0,3,5,6,2,7,4,8,9]

$arr[4] > $arr[5];//[1,0,3,5,2,6,7,4,8,9]

$arr[5] > $arr[6];//[1,0,3,5,2,6,7,4,8,9]

$arr[6] > $arr[7];//[1,0,3,5,2,6,4,7,8,9]

$arr[7] > $arr[8];//[1,0,3,5,2,6,4,7,8,9]

$arr[8] > $arr[9];//[1,0,3,5,2,6,4,7,8,9]

...

for ($i = 1; $i < 10; $i++) {

for ($j = $i - 1; $j >= 0; $j-=1) {

if ($data[$j] > $data[$j+1]) {

$temp = $data[$j];

$data[$j] = $data[$j+1];

$data[$j+1] = $temp;

}

}

}

最后就得到结果：[0,1,2,3,4,5,6,7,8,9]

完整代码如下：

class ShellSort

{

/*** Notes: 希尔排序之交换法排序

* User: LiYi\ * Date: 2019/11/12 0012\ * Time: 14:30\ * @param array $data\ * @return array\ */\

public static function shellSortArray(array $data):array

{

if (!is_array($data)) {

return ['message' => '必须传入数组比较排序'];

}

$count = count($data);//得到数组的个数

//如果数组的个数小于等于1就直接返回

if ($count <= 1) {return $data;}

//$gap 是每次减半的分组，直到只可以分为一组结束，在php里面需要注意，两个整数相除，除不尽的情况下，得到的是一个浮点数，不是一个向下

//取整的的整数，所以在最后判断gap 退出循环的时候，需要判断它 >= 1

for ($gap = $count / 2; $gap >= 1; $gap /= 2) {

for ($i = $gap; $i < $count; $i++) {

for ($j = $i - $gap; $j >= 0; $j-=$gap) {

if ($data[$j] > $data[$j+$gap]) {

//这个地方是比较第一个数和它的步长做比较，交换也是一样

$temp = $data[$j];

$data[$j] = $data[$j+$gap];

$data[$j+$gap] = $temp;

}

}

}

}

return $data;

}

public static function validate(array $data)

{

if (!is_array($data)) {

return ['message' => '必须传入数组比较排序'];

}

$count = count($data);//得到数组的个数

//如果数组的个数小于等于1就直接返回

if ($count <= 1){

return $data;

}

return [$data, $count];

}

/**\ * Notes: 希尔排序之移位法排序

* User: LiYi

* Date: 2019/11/12 0012

* Time: 14:29

* @param array $data

* @return array*/

public static function ShellSortMoveArray(array $data)

{

$count = count($data);//得到数组总数

for ($gap = $count / 2; $gap > 0; $gap /= 2) {

//缩小增量，每次减半

$gap = floor($gap);

for ($i = $gap; $i < $count; $i++) {

// $insertIndex = $i;//待插入元素的下表

$insertValue = $data[$insertIndex];//待插入元素的值

echo "insertIndex=$insertIndex" . PHP_EOL;

echo "insertValue=$insertValue" . PHP_EOL;

if ($data[$insertIndex] < $data[$insertIndex - $gap]) {

//判断待插入元素和它步长的元素比较，待插入元素小就进入循环

//判断是否越界了，第一个元素的下标是要大于等于0的，否则退出循环

//判断后面的元素比前面的元素小，进入循环，否则退出循环

while ($insertIndex - $gap >= 0 && $insertValue < $data[$insertIndex - $gap]) {

//把步长前面的大的值向后移动

$data[$insertIndex] = $data[$insertIndex - $gap];

$insertIndex -= $gap;//每循环一次就把带插入的坐标减去补偿\

} //把带插的小值插入到前面

$data[$insertIndex] = $insertValue;

}

}

}

return $data;

}

public static function testShellOne(array $data)

{

$temp = 0;

$count = count($data);

for ($i = 5; $i < $count; $i++) {

for ($j = $i - 5; $j >= 0; $j-=5) {

if ($data[$j] > $data[$j+5]) {

$temp = $data[$j];

$data[$j] = $data[$j+5];

$data[$j+5] = $temp;

}

}

}

for ($i = 2; $i < $count; $i++) {

for ($j = $i - 2; $j >= 0; $j-=2) {

if ($data[$j] > $data[$j+2]) {

$temp = $data[$j];

$data[$j] = $data[$j+2];

$data[$j+2] = $temp;

}

}

}

for ($i = 1; $i < 10; $i++) {

for ($j = $i - 1; $j >= 0; $j-=1) {

if ($data[$j] > $data[$j+1]) {

$temp = $data[$j];

$data[$j] = $data[$j+1];

$data[$j+1] = $temp;

}

}

}

var_dump($data);

}

}

var_dump(ShellSort::shellSortMoveArray([0 => 9, 1 => 6, 2 => 1, 3 => 3, 4 => 0, 5 => 5, 6 => 7, 7 => 2, 8 => 8, 9 => 4]));

// $gap = 10 / 2 = 5

// $insertIndex = $i = $gap = 5

// $insertValue = $data[$insertIndex] = $data[5] = 5;

// $data[$insertIndex] < $data[$insertIndex - $gap] == $data[5] < $data[5-5] = $data[0] ==> 5 < 9

// while(5 - 5 >= 0 && 5 < 9) {

// $data[5] = $data[5-5] = $data[0] = 9

// $insertIndex -= 5 = 0;

//}

// $data[$insertIndex] = $data[0] = $insertValue = 5

// $i++ = 6;

// $insertIndex = $i = 6

// $insertValue = $data[$insertIndex] = $data[6] = 7;

// $data[$insertIndex] < $data[$insertIndex - $gap] == $data[6] < $data[6-5] = $data[1] ==> 7 < 6

// $i++ = 7;

// $insertIndex = $i = 7

// $insertValue = $data[$insertIndex] = $data[7] = 2;

// $data[$insertIndex] < $data[$insertIndex - $gap] == $data[7] < $data[7-5] = $data[2] ==> 2 < 1

// $i++ = 8;

// $insertIndex = $i = 8

// $insertValue = $data[$insertIndex] = $data[8] = 8;

// $data[$insertIndex] < $data[$insertIndex - $gap] == $data[8] < $data[8-5] = $data[3] ==> 8 < 3

// $i++ = 9;

// $insertIndex = $i = 9

// $insertValue = $data[$insertIndex] = $data[9] = 4;

// $data[$insertIndex] < $data[$insertIndex - $gap] == $data[9] < $data[9-5] = $data[4] ==> 4 < 0

本作品采用《CC 协议》，转载必须注明作者和本文链接

LIYi ---- github地址

天中浪客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
排序之希尔排序
qq_36464947的博客
06-12 187
一.原理 1.什么是希尔排序？ 我们在之前已经接触了直接插入排序，希尔排序是插入排序的一种又称“缩小增量排序”，是直接插入排序算法的一种更高效的改进版本。那么究竟什么是希尔排序呢？ 　　首先，我们用语言来描述是这样的： 　　先将要排序的一组数按某个增量d = n / 2 (n为待排序数的个数)分成若干组，每组中数据记录的下标相差d.对每组中全部元素进行直接插入排序。 　　然后再用一个较小的增量（d...
希尔排序
weixin_42293337的博客
10-16 258
要点 希尔(Shell)排序又称为缩小增量排序，它是一种插入排序。它是直接插入排序算法的一种威力加强版。该方法因DL．Shell于1959年提出而得名。 希尔排序的基本思想是： 把记录按步长 gap 分组，对每组记录采用直接插入排序方法进行排序。 随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到 1 时，整个数据合成为一组，构成一组有序记录，则完成排序。 我们来通过演示图，更深入的...
PHP 排序算法（五） 希尔排序
Forever 流伤的博客
07-05 284
希尔排序 希尔排序又称缩小增量排序，是指将无序序列，按照增量的不同大小，分成若干个序列，然后对子序列进行插入排序，本质上就是插入排序。 思路： 我们先确定增量，一般初始增量我们都设置为数组长度的一半(向下取整); 我们根据增量，将数组分成了若干个子序列： 分别对这四个子序列进行插入排序： 然后再一次遍历，增量设置为原先的一半，也就是继续除以2(向下取整)，得出的序列： 分别对这两个序列进行插入排序，结果为： 再将增量除以2得到新增量为1，便...
php实现希尔排序（总结）
weixin_34253126的博客
05-06 336
php实现希尔排序（总结） 一、总结 1、希尔排序的算法思路：分组排序， 缩小增量排序，插入排序 2、算法思路： 循环非常好写 有几次gap：log2（n） 每次gap有几组：gap组 每组有几个元素：以gap做增加量就知道了 然后每组的几个元素做简单插入排序就好   二、希尔排序 希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishin...
JS判断两个数是否能除尽
qq_25261441的博客
11-05 1956
function judgeDivisor(m, n) {//JS判断两个数是否能除尽 var num = {}; var i = 0; var x = parseInt(m / n); m = m % n; var result = ""; while (m != 0 && !(m in num)) { num[m] = i++; result += parseInt(m * 10 / n); m = m * 10 % n; } return m == 0; }
排序算法（二）---- 希尔排序
chenkaixin_1024的博客
08-31 256
希尔排序又叫缩小增量排序，在直接插入排序的基础上，给定了一个增量gap，作为对给定序列的区间划分依据，如上gap=3，将原序列分为{5，4，1}，{2，7，3}，{9，6，8}三组数据，而对它们分别进行直接插入排序，在对每组完成直接插入排序之后，随即对增量进行缩小，直到gap=1时，此时在完成对应的直接插入排序之后，整个序列随即有序 希尔排序的时间复杂度大致为O(N^1.25)~O(1.6N^1
php实现希尔排序算法的方法分析
10-18
主要介绍了php实现希尔排序算法的方法,简单说明了希尔排序的原理,并结合实例形式分析了php实现希尔排序的具体操作技巧,需要的朋友可以参考下
PHP排序算法之希尔排序(Shell Sort)实例分析
10-18
主要介绍了PHP排序算法之希尔排序(Shell Sort),结合实例形式较为详细的分析了希尔排序的原理、实现方法及相关注意事项,需要的朋友可以参考下
C++ 算法之希尔排序详解及实例
08-30
主要介绍了C++ 算法之希尔排序算法详解及实例的相关资料,需要的朋友可以参考下
PHP 希尔排序
weixin_33858485的博客
08-17 78
希尔排序平均时间复杂度O(n^1.3),最好情况O(n),最坏情况O(n^2) 1 &lt;?php 2 #希尔排序 3 function shellSort(Array $arr) { 4 $k = initStep(count($arr)); 5 $step = pow(2, $k) - 1; 6 ...
php实现希尔排序
weixin_30814223的博客
11-23 95
对于排序的算法我想大家首先想到的事 冒泡排序；快速排序；或者想起选择和插入排序； 今天的讲解并不是以上四种；而是希尔排序； 对18W个数字排序，时间比较（毫秒） 希尔排序 0.1s 就完成了，有点不敢相信，插入排序用了4.2s 理解这些复杂的排序算法还是很有意思的，体会这些排序算法的精妙~ 　　一、希尔排序（shell sort）：希尔排序是基于插入排序的...
PHP-希尔排序
技无涯的博客
03-29 157
function shell(array $arr,array $gaps=[]){ if(!$arr) return $arr; //测试用，默认指定间隔数组,正常传入即可 $gaps = [10,5,2,1]; $l_g = count($gaps); $l = count($arr); for($i=0;$i<$l_g;$i+...
PHP实现排序算法----希尔排序（Shell Sort）
LSGOZJ的博客
11-08 3312
基本思想：希尔排序是指记录按下标的一定增量分组，对每一组使用 直接插入排序 ，随着增量逐渐减少，每组包含的关键字越来越多，当增量减少至 1 时，整个序列恰好被分成一组，算法便终止。操作步骤：先取一个小于 n（序列记录个数） 的整数 d1 作为第一个增量，把文件的全部记录分组。所有距离为 d1 的倍数的记录放在同一个组中。先在各组内进行 直接插入排序；然后，取第二个增量 d2 < d1 重复上述的分组
php 希尔排序
我只是个小学生 能力有限 一直抱着学习的态度
08-31 151
/* 1、间隔为4,每间隔4个人，这些人排成一组 2、在每一组的组内进行排序,数组交换,比大小 3、重新设置间隔分组,例如 黄色一组 ，黑色一组 、在进行组内排序交换(用的是插入法) 重点、分组的间隔都会越来越小,最后变成1，如果变成1的时候,说明已变成了一组 排序用的是插入排序 分组间隔不停的减少，不停的分组，不停做组内的排序最终变为1为止 */ 希尔排序算法的php实现2 php实现希尔排序 ...
PHP Array -- PHP 排序 -- 希尔排序(Shell Sort)
dengzonghuan的专栏
03-16 1855
 希尔排序(Shell Sort)以插入排序为基础，虽然它每次也只是移动一个数值，但它每次移动的距离更大。下面的例子中，我们选择的列数满足表达式2x+1， 其中x等于系列取值中的前一个值。(必须很好选择每次分解的列数，否则需要的步骤会迅速的增加)。// 来自 PHP5 in Practice  (U.S.)Elliott III & Jonathan D.Eisenhamer<?php
希尔排序-PHP版
代码小白的博客
11-07 131
<?php function shellSort($arr) :Array { if($arr == null || count($arr) <=1){ return $arr; } //希尔排序 升序 for($d = floor(count($arr)/2);$d>0;){ //$d:增量 7 3 1 ech...
php的希尔排序
weixin_30882895的博客
07-02 96
算是改进了的插入排序， 从性能时间上来看，也确实更有改进。 但比起php内置的功能，性能还有十倍之差呢 <?php /** * 原理：把排序的数据根据增量分成几个子序列，对子序列进行插入排序， * 直到增量为1，直接进行插入排序，增量的排序，一般是数组长度的一半，再变为原来增量的一半，直到增量为1 * 时间复杂度：最差 Θ(n2) 平均时间复杂度 O(log2n) ...
php 希尔排序算法
凄魅旋律
04-08 143
希尔排序 希尔排序(Shell’s Sort)是 插入排序 的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序的最好时间复杂度O(n)和最坏时间复杂度O(n2)。想要理解希尔排序，首先得理解插入排序。 图解参考： 参考文章： https://www.cnblogs.com/chengxiao/p/6104371.html https://zhuanlan.zhihu.com/p/56836177 以下是希尔排序的php版本
php-希尔排序
疯狂coder
04-01 251
//希尔排序(对直接插入排序的改进) function ShellSort(array &$arr) { $count = count($arr); $inc = $count; //增量 do { //计算增量 //$inc = floor($inc / 3) + 1; $inc = ceil($inc /...
c语言数据结构与算法 希尔排序算法
最新发布
12-23
希尔排序是一种插入排序的改进算法，它通过动态定义间隔的方式，对数据进行分组，...总之，希尔排序算法是C语言中常用的排序算法之一，通过动态定义间隔和分组排序的方式，可以提高排序效率，适用于大规模数据的排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值