PHP简单选择排序算法实例

简单的选择排序算法:通过n-i次关键字间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i(1<=i<=n)个记录交换

简单的选择排序算法:通过n-i次关键字间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i个记录交换

基本思想:

复制代码 代码如下:
    class Sort{
        /**
         * 简单的选择排序
         *
         * @param unknown_type $arr
         */
        public function selectSort(&$arr) {
            $len=count($arr);
            for ($i=0;$i                 $min=$i;
                for ($j=$i+1;$j<=$len-1;$j++) {
                    if ($arr[$min]>$arr[$j])
{//如果找到比$arr[$min]较小的值,则将该下标赋给$min
                        $min=$j;
                    }
                }
                if
($min!=$i){//若$min不等于$i,说明找到了最小值,则交换
                    $this->swap($arr[$i],$arr[$min]);
                }
            }
        }
        /**
         * 将$a和$b两个值进行位置交换
         */
        public function swap(&$a,&$b) {
            $temp=$a;
            $a=$b;
            $b=$temp;
        }
    }
    $arr=array(4,6,1,2,9,8,7,3,5);
    $test=new Sort();
    $test->selectSort($arr);//简单的选择排序
//    var_dump($arr);
?>

复制代码 代码如下:swap; } } } /** *
将$a和$b两个值进行位置交换 */ public function swap { $temp=$a; $a=$b;
$b=$temp; } } $arr=array; $test=new Sort();
$test->selectSort;//简单的选择排序// var_dump;?>

冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。

简单选择排序的特点:交换移动数据次数相当少,从而节约了相应的时间
简单选择排序的时间复杂度分析:
无论最好最差的情况,其比较次数都是一样多,第i趟排序需要进行n-i次关键字的比较,此时需要比较n(n-1)/2次。所以最终的时间复杂度是O(n^2)
尽管与冒泡排序同为O(n^2),但选择排序的性能还是略优于冒泡排序的。

简单选择排序的特点:交换移动数据次数相当少,从而节约了相应的时间简单选择排序的时间复杂度分析:无论最好最差的情况,其比较次数都是一样多,第i趟排序需要进行n-i次关键字的比较,此时需要比较n/2次。所以最终的时间复杂度是O,但选择排序的性能还是略优于冒泡排序的。

最简单的排序实现:

//这里使用了类型提示(type hint)
array,不熟悉或者不习惯的同学大可去掉,不影响运算结果

function MySort(array &$arr){

      $length = count($arr);

      for($i = 0;$i < $length – 1;$i ++){

            for($j = $i + 1;$j < $length;$j ++){

                  //将小的关键字放前面

                  if($arr[$i] > $arr[$j]){

                        $temp = $arr[$i];

                        $arr[$i] = $arr[$j];

                          $arr[$j] = $temp;

                          }

                }

           }

}

$arr = array(9,1,5,8,3,7,4,6,2);

MySort($arr);

上面的这段代码严格意义上说,不算是标准的冒泡排序,因为它不满足“两两比较相邻记录”的冒泡排序思想,它仅仅是一个简单的交换排序。思路不过是:从第一个关键字开始,将每一位关键字与它后面的所有关键字相比较,交换得到其中的最小值。但这个算法是非常低效的。

冒泡排序算法:

       
它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

这个算法的名字由来是因为数组中越大的元素会由于一次次排序后逐渐“沉”到数组的后面,而越小的元素会逐渐“浮”到数组的前面,故名。

冒泡排序算法的运作如下:(从后往前)

            比较相邻的元素。如果第一个比第二个大,就交换他们两个。

           
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

            针对所有的元素重复以上的步骤,除了最后一个。

            针对所有的元素重复以上的步骤,除了最后一个。

看文字描述不一定看得懂,看代码吧:

//交换方法

function   swap(array &$arr,$a,$b){

         $temp=$arr[$a];

          $arr[$a] =$arr[$b];

         $arr[$b] =$temp;

}

//冒泡排序

function  BubbleSort(array &$arr){

          $length= count($arr);

          for($i=0;$i<$length-1;$i++){

           //从后往前逐层上浮小的元素

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

                 //两两比较相邻记录

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

                              swap($arr,$j,$j+1);

                            }

                     }

              }

}

冒泡排序算法改进:

《大话数据结构》果然是本好书,还给我们介绍了冒泡排序算法的改进,这里我就直接搬它的陈述:

上面的冒泡排序算法是否还可以优化呢?答案是肯定的。试想一下,如果我们待排序的序列是{2,1,3,4,5,6,7,8,9},也就是说,除了第一和第二个关键字需要交换外,别的都已经是正常的顺序了。当
i = 0 时,交换了 2 和 1
,此时的序列已经是有序的了,但是算法仍然不依不挠地将 i = 2 到 9
以及每个循环中的 j
循环都执行了一遍,尽管并没有交换数据,但是之后的大量比较还是大大地多余了。

当 i = 2 时,我们已经对 9 与 8,8 与 7,·······,3 与 2
做了比较,没有任何数据交换,这就说明此序列已经有序,不需要再继续后面的循判断工作了(后面的工作也是不会发生任何数据交换,再做也是没有意义了)。为了实现这个想法,我们需要改进一下代码,增加一个标记变量
flag 来实现这一算法的改进:

//交换方法

function     swap(array &$arr,$a,$b){

$temp=$arr[$a];

$arr[$a] =$arr[$b];

$arr[$b] =$temp;

}

/冒泡排序的优化(如果某一次循环的时候没有发生元素的交换,则整个数组已经是有序的了)

function    BubbleSort1(array &$arr){

                   $length= count($arr);

                    $flag=TRUE;

                    for($i=0;($i<$length-1) &&$flag;$i++){

                            $flag=FALSE;

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

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

                                         swap($arr,$j,$j+1);

                                           $flag=TRUE;

                                     }

                              }

                 }

}

代码改动的关键就是在 i 变量的for循环中,增加了对flag是否为 true
的判断,经过这样的改进,冒泡排序在性能上就有了一些提升,可以避免因已经有序的情况下的无意义循环判断。

冒泡算法总的时间复杂度是 O(n^2)。

冒泡排序是稳定排序。

发表评论

电子邮件地址不会被公开。 必填项已用*标注