php面试题

1 用PHP打印出前一天的时间格式是2006-5-10 22:21:21php

$a = date("Y-m-d H:i:s", strtotime("-1 day"));
print_r($a);

2 eecho print var_dump()和print_r()的区别  web

echo是PHP语句, print和print_r是函数,语句没有返回值,函数能够有返回值(即使没有用)  
print只能打印出简单类型变量的值(如int,string)  
print_r能够打印出复杂类型变量的值(如数组,对象) 
echo -- 输出一个或者多个字符串

3 可以使HTML和PHP分离开使用的模板redis

Smarty, Dwoo, tinyButStrong Templete Lite Savant, phemplate XTemplate等模板引擎

4 isset、empty、is_null的区别算法

isset 判断变量是否认义或者是否为空
empty:判断变量的值是否为空,能转换为false的都是空,为空返回true,反     之返回false
is_null:检测传入的值(值、变量、表达式)是否为null

5 写出smarty模板的特色数据库

速度快,编译型,缓存技术,插件机制,强大的表现逻辑

6 语句include和require的区别是什么?为避免屡次包含同一文件,可用(?)语句代替它们?编程

include引入文件的时候,若是碰到错误,会给出提示,并继续运行下边的代码。 能够用include_once代替

require引入文件的时候,若是碰到错误,会给出提示,并中止运行下边的代码,能够用require_once代替

7 如何修改SESSION的生存时间?windows

setcookie(),session_set_cookie_params()

8 COOKIE、SESSION的联系和区别,多台web服务器如何共享SESSION?设计模式

1 COOKIE和SESSION都是用于会话机制,COOKIE保存在客户端,而SESSION则保存在服务器端。
在默认状况下,SESSION机制是基于COOKIE的,每生成一个SESSIONID,都会将其发送到浏览器端,让后将其保存到COOKIE当中,在下次请求的时候,由浏览器携带这个COOKIE
2 1、将本该保存在web服务器磁盘上的session数据保存到cookie中 即用cookie会话机制替代session会话机制,将session数据保存到客户端浏览器的cookie中,这样同一个用户访问同一网站时,不管负载均衡到哪台web服务器,都不用再去服务器请求session数据,而直接获取客户端cookie中的session数据。如此,同一个用户的登陆状态就不会丢失了。 但这样作,有三大弊端: 把session数据放到客户端的cookie中,通常都是重要数据(如用户id、昵称等),会存在安全问题,但能够将session数据加密后,再存放到cookie中,来下降安全风险。 浏览器对单个cookie的数据量大小限制为4K左右,所以会存在数据量的限制问题。 影响带宽性能,下降了页面的访问速度。在高访问量的状况下,用户每次请求时,都要将客户端cookie中的session数据发送到服务器,要占用较多的带宽,进而影响访问速度,服务器带宽成本增高。 2、将本该保存在web服务器磁盘上的session数据保存到MySQL数据库中 sessionid仍是利用cookie机制存储到客户端,但session数据却存放在MySQL服务器上。(须要创建sessionid和session数据行的对应关系) 但这样作,只适合访问量比较小的网站。若是网站的访问量比较大,对MySQL服务器会形成很大压力。由于每次用户请求页面(即便是刷新页面)都要查询MySQL数据库中的session数据表,进而判断用户的登陆状态和读取用户相关信息,势必会对数据库服务器形成很大压力,这样就会下降服务器的响应速度,影响用户体验。 3、将本该保存在web服务器磁盘上的session数据保存到内存数据库(memcache或redis)中 memcache或redis是基于内存存储数据的,性能很高,尤为是高并发的状况下尤其合适。主要是由于从内存中读取数据要比从磁盘读取数据快不少。 内存数据库还支持数据过时失效的机制,正好与session的过时机制对应,推荐使用redis内存数据库,由于它比memcache支持更多的 数据类型,且支持内存数据备份到磁盘

9 memcache和redis的区别?数组

1、存储方式:
memecache 把数据所有存在内存之中,断电后会挂掉,数据不能超过内存大小
redis有部份存在硬盘上,这样能保证数据的持久性。
2、数据支持类型:
redis在数据支持上要比memecache多的多。
3、使用底层模型不一样:
新版本的redis直接本身构建了VM 机制 ,由于通常的系统调用系统函数的话,会浪费必定的时间去移动和请求。
4、运行环境不一样:
redis目前官方只支持LINUX 上去行,从而省去了对于其它系统的支持,这样的话能够更好的把精力用于本系统 环境上的优化,虽而后来微软有一个小组为其写了补丁。可是没有放到主干上

10 在PHP中,heredoc是一种特殊的字符串,它的结束标志必须?浏览器

$a = <<EOD
good test
EOD;

11 谈谈对MVC的认识?

MVC是一种流行的程序架构,MVC是 模型(Model) 、视图(View)、控制器(Control) 的英文首字母的缩写,核心思想是:视图和用户交互  经过事件致使控制器改变  控制器改变致使模型改变  或者控制器同时改变二者  模型改变 致使视图改变 或者视图改变 潜在的从模型里面得到参数 来改变本身。
MVC(Model-View-Controller),即把一个应用的输入、处理、输出流程按照Model、View、Controller的方式进行分离,这样一个应用被分红三个层——模型层、视图层、控制层。
视图(View):表明用户交互界面,MVC设计模式对于视图的处理是限于视图上数据的采集和处理,以及用户的请求,而不包括在视图上的业务流程的处理。
模型(Model):业务流程/状态的处理以及业务规则的制定。业务流程的处理过程对其它层来讲是黑箱操做,模型接受视图请求的数据,并返回最终的处理结果。业务模型的设计能够说是MVC的核心。
控制(Controller):能够理解为从用户接收请求, 将模型与视图匹配在一块儿,共同完成用户的请求,可是它却不作任何的数据处理。

12 打开php.ini中的safe_mode,会影响哪些函数?至少说出6个

safe_mode,PHP安全模式,它提供一个基本安全的共享环境,在一个有多个用户帐户存在的php开发的web服务器上。当安全模式打开的时候,一些函数将被彻底的禁止,而另外一些函数的功能将会受到限制,如:chdir,move_uploaded_file,chgrp,parse_ini_file,chown,rmdir,copy,rename,fopen,require,mkdir,unlink等。
注意,在php5.3以上版本,safe_mode被弃用,在php5.4以上版本,则将此特性彻底去除了。

13 PHP的垃圾收集机制是怎样的?

PHP能够自动进行内存管理,清除再也不须要的对象。
PHP使用了引用计数(reference counting)这种单纯的垃圾回收(garbage collection)机制。每一个对象都内含一个引用计数器,每一个reference链接到对象,计数器加1。当reference离开生存空间或被设为NULL,计数器减1。当某个对象的引用计数器为零时,PHP知道你将再也不须要使用这个对象,释放其所占的内存空间。

 14 请描述PHP(或其余语言)Session的运行机制,大型网站中Session方面应注意什么?

session机制是一种服务器端的机制,它将数据保存到服务器端。
当程序须要为某个客户端的请求建立一个session的时候,服务器首先检查这个客户端的请求里是否已包含了一个session标识,称为sessionid,若是已包含一个sessionid则说明之前已经为此客户端建立过session,服务器就按照sessionid把这个session检索出来使用(若是检索不到,可能会新建一个),若是客户端请求不包含sessionid,则为此客户端建立一个session而且生成一个与此session相关联的sessionid,sessionid的值应该是一个既不会重复,又不容易被找到规律以仿造的字符串,这个sessionid将被在本次响应中返回给客户端以cookie的形式保存。

session在大访问量网站上确实影响系统性能,影响性能的缘由之一由文件系统设计形成,在同一个目录下超过10000个文件时,文件的定位将很是耗时。另外就是小文件的效率问题,通常咱们的session数据都不会太大(1~2K),若是有大量这样1~2K的文件在磁盘上,IO效率确定会不好,咱们能够采用改写session存储机制,好比存放到数据库中

 

 

14 写出一个能建立多级目录的PHP函数

<?php
    /**
     * 建立多级目录
     * @param $path string 要建立的目录
     * @param $mode int 建立目录的模式,在windows下可忽略
     */
    function create_dir($path,$mode = 0777)
    {
        if (is_dir($path)) {
            # 若是目录已经存在,则不建立
            echo "该目录已经存在";
        } else {
            # 不存在,建立
            if (mkdir($path,$mode,true)) {
                echo "建立目录成功";
            } else {
                echo "建立目录失败";
            }
        }
    }
?>

15 请写一段PHP代码,确保多个进程同时写入同一个文件成功?

$fp = fopen("lock.txt","w+");
    if (flock($fp,LOCK_EX)) {
        //得到写锁,写数据
        fwrite($fp, "write something");

        // 解除锁定
        flock($fp, LOCK_UN);
    } else {
        echo "file is locking...";
    }
    fclose($fp);

16 写一个函数,尽量高效的,从一个标准url里取出文件的扩展名,例如:http://www.sina.com.cn/abc/de/fg.php?id=1须要取出php或.php

<?php
    // 方案一
    function getExt1($url){
        $arr = parse_url($url);
        //Array ( [scheme] => http [host] => www.sina.com.cn [path] => /abc/de/fg.php [query] => id=1 )

        $file = basename($arr['path']);
        $ext = explode('.', $file);
        return $ext[count($ext)-1];
    }

    // 方案二
    function getExt2($url){
        $url = basename($url);
        $pos1 = strpos($url,'.');
        $pos2 = strpos($url,'?');

        if (strstr($url,'?')) {
            return substr($url,$pos1+1,$pos2-$pos1-1);
        } else {
            return substr($url,$pos1);
        }

    }

    $path = "http://www.sina.com.cn/abc/de/fg.php?id=1";
    echo getExt1($path);
    echo "<br />";
    echo getExt2($path);
?>

17 写一个函数,可以遍历一个文件夹下的全部文件和子文件夹

<?php
    function my_scandir($dir){
        $files = array();
        if(is_dir($dir)){
            if ($handle = opendir($dir)) {
                while (($flie = readdir($handle))!== false) {
                    if ($flie!="." && $file!="..") {
                        if (is_dir($dir."/".$file)) {
                            $files[$file] = my_scandir($dir."/".$file);
                        } else {
                            $files[] = $dir."/".$file;
                        }
                    }
                }
                closedir($handle);
                return $files;
            }
        }
    }
?>

18 简述论坛中无限分类的实现原理

1 建立表
    CREATE TABLE category(
    cat_id smallint unsigned not null auto_increment primary key comment'类别ID',
    cat_name VARCHAR(30)NOT NULL DEFAULT''COMMENT'类别名称',
    parent_id SMALLINT UNSIGNED NOT NULL DEFAULT 0 COMMENT'类别父ID'
  )engine=MyISAM charset=utf8;
2 编写一个函数,递归遍历,实现无限分类
    <?php
    function tree($arr,$pid=0,$level=0){
        static $list = array();
        foreach ($arr as $v) {
            //若是是顶级分类,则将其存到$list中,并以此节点为根节点,遍历其子节点
            if ($v['parent_id'] == $pid) {
                $v['level'] = $level;
                $list[] = $v;
                tree($arr,$v['cat_id'],$level+1);
            }
        }
        return $list;
    }
?>

19 写一个函数,算出两个文件的相对路径,如a=/a/b/c/d/e.php;b='/a/b/12/34/c.php';计算出ba的相对路径应该是../../c/d

<?php
    function releative_path($path1,$path2){
        $arr1 = explode("/",dirname($path1));
        $arr2 = explode("/",dirname($path2));

        for ($i=0,$len = count($arr2); $i < $len; $i++) {
            if ($arr1[$i]!=$arr2[$i]) {
                break;
            }
        }

        // 不在同一个根目录下
        if ($i==1) {
            $return_path = array();
        }

        // 在同一个根目录下
        if ($i != 1 && $i < $len) {
            $return_path = array_fill(0, $len - $i,"..");
        }

        // 在同一个目录下
        if ($i == $len) {
            $return_path = array('./');
        }

        $return_path = array_merge($return_path,array_slice($arr1,$i));
        return implode('/',$return_path);
    }

    $a = '/a/b/c/d/e.php';
    $b = '/a/b/12/34/c.php';
    $c = '/e/b/c/d/f.php';
    $d = '/a/b/c/d/g.php';

    echo releative_path($a,$b);//结果是../../c/d
    echo "<br />";
    echo releative_path($a,$c);//结果是a/b/c/d
    echo "<br />";
    echo releative_path($a,$d);//结果是./
    echo "<br />";
?>

 20 使对象能够像数组同样进行foreach循环,要求属性必须是私有。(Iterator模式的PHP5实现,写一类实现Iterator接口)

<?php
    class Test implements Iterator{
    private $item = array('id'=>1,'name'=>'php');

    public function rewind(){
        reset($this->item);
    }

    public function current(){
        return current($this->item);
    }

    public function key(){
        return key($this->item);
    }

    public function next(){
        return next($this->item);
    }

    public function valid(){
        return($this->current()!==false);
    }
}
    //测试
    $t=new Test;
    foreach($t as $k=>$v){
        echo$k,'--->',$v,'<br/>';
    }
?>

21 用PHP实现一个双向队列

<?php
    class Deque{
      private $queue=array();
      public function addFirst($item){
          return array_unshift($this->queue,$item);
      }

      public function addLast($item){
          return array_push($this->queue,$item);
      }
      public function removeFirst(){
          return array_shift($this->queue);
      }

      public function removeLast(){
          return array_pop($this->queue);
      }
  }
?>

22 请使用排序法对如下一组数据进行排序10 2 36 14 10 25 23 85 99 45。

<?php
    // 冒泡排序
    function bubble_sort(&$arr){
        for ($i=0,$len=count($arr); $i < $len; $i++) {
            for ($j=1; $j < $len-$i; $j++) {
                if ($arr[$j-1] > $arr[$j]) {
                    $temp = $arr[$j-1];
                    $arr[$j-1] = $arr[$j];
                    $arr[$j] = $temp;
                }
            }
        }
    }

    // 测试
    $arr = array(10,2,36,14,10,25,23,85,99,45);
    bubble_sort($arr);
    print_r($arr);

    //快速排序
    function quick_sort($arr) {  
        //先判断是否须要继续进行  
        $length = count($arr);  
        if($length <= 1) {  
            return $arr;  
        }  
        //若是没有返回,说明数组内的元素个数 多余1个,须要排序  
        //选择一个标尺  
        //选择第一个元素  
        $base_num = $arr[0];  
        //遍历 除了标尺外的全部元素,按照大小关系放入两个数组内  
        //初始化两个数组  
        $left_array = array();//小于标尺的  
        $right_array = array();//大于标尺的  
        for($i=1; $i<$length; $i++) {  
            if($base_num > $arr[$i]) {  
                //放入左边数组  
                $left_array[] = $arr[$i];  
            } else {  
                //放入右边  
                $right_array[] = $arr[$i];  
            }  
        }  
        //再分别对 左边 和 右边的数组进行相同的排序处理方式  
        //递归调用这个函数,并记录结果  
        $left_array = quick_sort($left_array);  
        $right_array = quick_sort($right_array);  
        //合并左边 标尺 右边  
        return array_merge($left_array, array($base_num),     $right_array);  
    }         
    quick_sort($arr);
    print_r($arr);
//选择排序(不稳定) 选择排序法的思路:就是再第一次循环中,假设第一个数是最小的;而后跟第二个数比较,一直比到最后,找出最小值,而后把最小值跟第一个数的位置互换;再进行下一次循环,找出最小值跟第二个位置的数互换;一直循环数组的个数减去1次;数组就成了有序的了 */ //用函数封装选择排序法 function select_sort(&$arr) //注意此处要加地址传递符号;由于数组默认传递的是值,不是地址;若不地址传递,排序的是$arr而不是$asd。 { //$arr = array(1,5,3,9,4,8,12,3,0,7,7.6,3.4,6); //定义一个中间变量 $temp = 0; //升序排序 for($i=0;$i<count($arr)-1;$i++) { //假设$i就是最小的数 $minVal=$arr[$i]; //记录我认为最小数的下标 $minIndex=$i; for($j=$i+1;$j<count($arr);$j++) { //若是我认为的最小值不是最小 if($minVal>$arr[$j]) { $minVal = $arr[$j]; $minIndex = $j; } } //最后交换 $temp = $arr[$i]; $arr[$i] = $arr[$minIndex]; $arr[$minIndex] = $temp; } return $arr; } select_sort($arr); print_r($arr);
//插入排序法 //插入排序法思路:将要排序的元素插入到已经 假定排序号的数组的指定位置。 function insert_sort($arr) { //区分 哪部分是已经排序好的 //哪部分是没有排序的 //找到其中一个须要排序的元素 //这个元素 就是从第二个元素开始,到最后一个元素都是这个须要排序的元素 //利用循环就能够标志出来 //i循环控制 每次须要插入的元素,一旦须要插入的元素控制好了, //间接已经将数组分红了2部分,下标小于当前的(左边的),是排序好的序列 for($i=1, $len=count($arr); $i<$len; $i++) { //得到当前须要比较的元素值。 $tmp = $arr[$i]; //内层循环控制 比较 并 插入 for($j=$i-1;$j>=0;$j--) { //$arr[$i];//须要插入的元素; $arr[$j];//须要比较的元素 if($tmp < $arr[$j]) { //发现插入的元素要小,交换位置 //将后边的元素与前面的元素互换 $arr[$j+1] = $arr[$j]; //将前面的数设置为 当前须要交换的数 $arr[$j] = $tmp; } else { //若是碰到不须要移动的元素 //因为是已经排序好是数组,则前面的就不须要再次比较了。 break; } } } //将这个元素 插入到已经排序好的序列内。 //返回 return $arr; } insert_sort($arr); print_r($arr); ?>

23 写出一种排序算法(要写出代码),并说出优化它的方法

<?php
    //快速排序
    function partition(&$arr,$low,$high){
        $pivotkey = $arr[$low];
        while($low<$high){
            while($low < $high && $arr[$high] >= $pivotkey){
                $high--;
            }
            $temp = $arr[$low];
            $arr[$low] = $arr[$high];
            $arr[$high] = $temp;
            while($low < $high && $arr[$low] <= $pivotkey){
                $low++;
            }
            $temp=$arr[$low];
            $arr[$low]=$arr[$high];
            $arr[$high]=$temp;
        }
        return$low;
    }


function quick_sort(&$arr,$low,$high){
    if($low < $high){
        $pivot = partition($arr,$low,$high);
        quick_sort($arr,$low,$pivot-1);
        quick_sort($arr,$pivot+1,$high);
    }
}
?>

24 一群猴子排成一圈,按1,2,...,n依次编号。而后从第1只开始数,数到第m只,把它踢出圈,从它后面再开始数,再数到第m只,在把它踢出去...,如此不停的进行下去,直到最后只剩下一只猴子为止,那只猴子就叫作大王。要求编程模拟此过程,输入m、n,输出最后那个大王的编号。

<?php
    // 方案一,使用php来模拟这个过程
    function king($n,$m){
        $mokey = range(1, $n);
        $i = 0;

        while (count($mokey) >1) {
            $i += 1;
            $head = array_shift($mokey);//一个个出列最前面的猴子
            if ($i % $m !=0) {
                #若是不是m的倍数,则把猴子返回尾部,不然就抛掉,也就是出列
                array_push($mokey,$head);
            }

            // 剩下的最后一个就是大王了
            return $mokey[0];
        }
    }
    // 测试
    echo king(10,7);

    // 方案二,使用数学方法解决
    function josephus($n,$m){
        $r = 0;
        for ($i=2; $i <= $m ; $i++) {
            $r = ($r + $m) % $i;
        }

        return $r+1;
    }
    // 测试
    print_r(josephus(10,7));
?>

25 写一个二维数组排序算法函数,可以具备通用性,能够调用php内置函数。

<?php
//二维数组排序,$arr是数据,$keys是排序的健值,$order是排序规则,1是降序,0是升序
function array_sort($arr,$keys,$order=0){
    if(!is_array($arr)){
        return false;
    }
    $keysvalue=array();
    foreach($arr as $key => $val){
        $keysvalue[$key] = $val[$keys];
    }
    if($order == 0){
        asort($keysvalue);
    }else{
        arsort($keysvalue);
    }
    reset($keysvalue);
    foreach($keysvalue as $key => $vals){
        $keysort[$key] = $key;
    }
    $new_array=array();
    foreach($keysort as $key=> $val){
        $new_array[$key]=$arr[$val];
    }
    return$new_array;
}
    //测试
    $person=array(
        array('id'=>2,'name'=>'zhangsan','age'=>23),
        array('id'=>5,'name'=>'lisi','age'=>28),
        array('id'=>3,'name'=>'apple','age'=>17)
    );
    $result = array_sort($person,'name',1);
    print_r($result);
?>

26 描述顺序查找和二分查找(也叫作折半查找)算法,顺序查找必须考虑效率,对象能够是一个有序数组

<?php
    /**
     * 顺序查找
     * @param  array $arr 数组
     * @param   $k   要查找的元素
     * @return   mixed  成功返回数组下标,失败返回-1
     */
    function seq_sch($arr,$k){
        for ($i=0,$n = count($arr); $i < $n; $i++) {
            if ($arr[$i] == $k) {
                break;
            }
        }
        if($i < $n){
            return $i;
        }else{
            return -1;
        }
    }

    /**
     * 二分查找,要求数组已经排好顺序
     * @param  array $array 数组
     * @param  int $low   数组起始元素下标
     * @param  int $high  数组末尾元素下标
     * @param   $k     要查找的元素
     * @return mixed        成功时返回数组下标,失败返回-1
     */
    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;
    }

    // 测试:顺序查找
    $arr1 = array(9,15,34,76,25,5,47,55);
    echo seq_sch($arr1,47);//结果为6

    echo "<br />";

    // 测试:二分查找
    $arr2 = array(5,9,15,25,34,47,55,76);
    echo bin_sch($arr2,0,7,47);//结果为5
?>

27 咱们但愿开发一款扑克游戏,请给出一套洗牌算法,公平的洗牌并将洗好的牌存储在一个整形数组里

<?php
    $card_num = 54;//牌数
    function wash_card($card_num){
        $cards = $tmp = array();
        for($i = 0;$i < $card_num;$i++){
            $tmp[$i] = $i;
        }

        for($i = 0;$i < $card_num;$i++){
            $index = rand(0,$card_num-$i-1);
            $cards[$i] = $tmp[$index];
            unset($tmp[$index]);
            $tmp = array_values($tmp);
        }
        return $cards;
    }
    // 测试:
    print_r(wash_card($card_num));
?>

 28 php实现线性表顺序存储(增删查改)

class linearList {
        private $arr;
        private $length;
        const   MAXSIZE=100;
 
        /*
         *构造函数,判断空表仍是飞空表,而且进行实例化 
         * @param array $arr 输入的数组
         * @param int $n 输入数组的长度
         * @ruturn void;
        */
          function __construct($arr,$n) {
              if($n>self::MAXSIZE) {
                   echo '对不起,数组的长度'.$n.'超出了内存空间!'.self::MAXSIZE;
              } else if($n<0) {
                   echo '异常,长度不能为负数。';
              } else if($n==0) {
                   echo '<br/>....你建立了一张空表,数组长度为0....<br/><br/>';
               $this->arr=$arr;
               $this->length=$n;
              }else{
                   echo '<br/>....成功建立一张表....<br/><br/>';
                   $this->arr=$arr;
                   $this->length=$n;
              }
           }
 


          /*
           *按位查找,返回查找到的值
           * @ruturn string; 
           * @param int $n 查找的位置
           */
           function findValue($n) {
               if($n>$this->length||$n<1){
                    return '输入的位置'.$n.'不正确,请在1到'.$this->length.'的范围内';
               }
                   return '你要找的第'.$n.'位的值为'.$this->arr[$n-1];
            }
  
          /*
           *按值查找,返回查找到的位置
          * @ruturn string;
          * @param int $n 查找的值
          */
          function findSite($n) {
               for($i=0;$i<$this->length;$i++){
                    if($this->arr[$i]==$n){
                         $b=$i+1;
                         return '你要找的值'.$n.'对应的位置为'.$b;
                    }else{
                         $v=false;
                    }
               }
               if(!$v){
                        return '你所找的值'.$n.'不存在';
               }   
           }
 
           /*
            *在选定的位置处插入某个值
            * @ruturn array;
            * @param int $i 插入位置
            * @param int $v 插入的值
            */
          function insertValue($i,$v) {
               if($i<1||$i>self::MAXSIZE){
                    echo '插入的位置'.$i.'不正确,请在1到'.self::MAXSIZE.'的范围内';
                    return ;
               }
               for($h=$this->length;$h>=$i;$h--){
                    $this->arr[$h]=$this->arr[$h-1];
               }
               if($i>$this->length){
                    $this->arr[$this->length]=$v;
               }else{
                    $this->arr[$i-1]=$v;
               }
                  $this->length++;
                  return $this->arr;
          }
  
              /*
               *在选定的位置删除某个值
              * @ruturn array;
              * @param int $i 位置
              */
              function deleteValue($i) {
                   if($i<1||$i>$this->length){
                        echo '选定的位置'.$i.'不正确,请在1到'.$this->length.'的范围内';
                        return ;
                   }
                   for($j=$i;$j<$this->length;$j++){
                        $this->arr[$j-1]=$this->arr[$j];
                   }
                   unset($this->arr[$this->length-1]);
                   $this->length--;
                   return $this->arr;
              }
  
              function __destruct(){
                   if($this->length==0){
                        echo '<br/>...销毁一张空表...<br/>';
                   }else{
                        echo '<br/>...成功销毁一张表..<br/>';
                   }
              }

 
}

//下面是使用案例

$arr=array(10,125,123,1,4);
$n=5;

$linearList=new linearList($arr, $n);

echo $linearList->findValue(5).'<br/>';

echo $linearList->findSite(4).'<br/>';

echo '<pre>';
print_r($linearList->insertValue(20,300));
echo '</pre>';
echo '<pre>';
print_r($linearList->deleteValue(1));
echo '</pre>';

29 用PHP模拟顺序栈的基本操做

class Stack{  
    //用默认值直接初始化栈了,也可用构造方法初始化栈  
    private $top = -1;  
    private $maxSize = 5;  
    private $stack = array();  
  
    //入栈  
    public function push($elem){  
        if($this->top >= $this->maxSize-1){  
            echo "栈已满!<br/>";  
            return;  
        }  
        $this->top++;  
        $this->stack[$this->top] = $elem;  
    }  
    //出栈  
    public function pop(){  
        if($this->top == -1){  
            echo "栈是空的!";  
            return ;  
        }  
        $elem = $this->stack[$this->top];  
        unset($this->stack[$this->top]);  
        $this->top--;  
        return $elem;  
    }  
    //打印栈  
    public function show(){  
        for($i=$this->top;$i>=0;$i--){  
            echo $this->stack[$i]." ";  
        }  
        echo "<br/>";  
    }  
}  
  
$stack = new Stack();  
$stack->push(3);  
$stack->push(5);  
$stack->push(8);  
$stack->push(7);  
$stack->push(9);  
$stack->push(2);  
$stack->show();  
$stack->pop();  
$stack->pop();  
$stack->pop();  
$stack->show();  

30 斐波那契数列 1 1 2 3 5 8 13 21 34 55 第n个数值

非递归写法:
function fbnq($n){  //传入数列中数字的个数
    if($n <= 0){
        return 0;
    }
    $array[1] = $array[2] = 1; //设第一个值和第二个值为1
    for($i=3;$i<=$n;$i++){ //从第三个值开始
        $array[$i] = $array[$i-1] + $array[$i-2]; 
        //后面的值都是当前值的前一个值加上前两个值的和
    }
    return $array;
}
递归写法:
function fbnq($n){
    if($n <= 0) return 0;
    if($n == 1 || $n == 2) return 1;
    return fbnq($n - 1) + fbnq($n - 2);
}
相关文章
相关标签/搜索