二叉树php

A. php面试有什么技巧么

PHP程序员在面试的时候一般应该抓住以下几个点。
一、应该介绍自己掌握的开发一种，主要介绍PHP语言的独特语法以及如何使用，比如PHP语言会比CGI更快的执行动态页面。
二、必须熟悉Oracle、Mysql等数据库，并能简单的介绍自己掌握的程度。由于php做出的动态页面比用其他语言做出来的页面在执行效率以及CGI方面高得多，所以你还需要在面试中说出自己的文档撰写能力很强。
三、PHP程序员应该具备独立分析和解决问题的能力，可以在自我介绍中讲讲自己曾经遇到过的问题是如何解决的。让面试官看到你的能力，这将会直接影响到你自我介绍的成功与否。
四、一个PHP程序员必须有良好的职业道德和工作态度，所以在面试中应该尽量讲自己在做项目时的认真态度以及今后的工作规划，表现出自己的进取心。
五、还有关于沟通能力和理解能力的体现，这个在与HR的交谈中就可以表现出来，所以需要做的工作就是从容的有条理的把自我介绍说完，回答每一个问题时都应该简洁明了，关于自我介绍可以提前做个草稿，背一下。
六、团队合作能力也是企业非常看重的，在培训中老师一般都会带领大家做项目，大的项目一般会分小组，每个人都有相对应的任务，这就模拟了公司中的团队合作，在自我介绍过程中要把做项目的具体流程以及相互协作的过程说出来，让HR看到自己具备团队合作的能力。
七、最后就是执行力，每当任务分配下来的时候该如何执行，还有自己讲过职业规划后该如何执行，还有在学习的过程中是如何人字形的，遇到困难又是如何执行的，这些都可以体现出php程序员的执行力，回答的时候抓住发现及时寻找原因，快速展开行动的这个主线即可。
八、最重要的是你的能力、技术以及自己的项目

B. 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实例详解

C. 求php+mysql 的二叉树每一层的叶子统计

Hi，这是一个很有意思的问题，二叉树，无限极分类一般都会用到递归。这里使用函数来模拟mysql查询，解决思路如下：

<?php
header("Content-type:text/html;charset=utf-8");

$data=array(
array('id'=>1,'pid'=>0,'name'=>'name1'),
array('id'=>2,'pid'=>1,'name'=>'name2'),
array('id'=>3,'pid'=>2,'name'=>'name3'),
array('id'=>4,'pid'=>3,'name'=>'name4'),
array('id'=>5,'pid'=>2,'name'=>'name5'),
array('id'=>6,'pid'=>2,'name'=>'name6'),
array('id'=>7,'pid'=>2,'name'=>'name7'),
array('id'=>8,'pid'=>7,'name'=>'name8'),
array('id'=>9,'pid'=>8,'name'=>'name9'),
array('id'=>10,'pid'=>9,'name'=>'name10'),
array('id'=>11,'pid'=>10,'name'=>'name11'),
array('id'=>12,'pid'=>11,'name'=>'name12'),
array('id'=>13,'pid'=>12,'name'=>'name13'),
array('id'=>14,'pid'=>13,'name'=>'name14'),
array('id'=>15,'pid'=>14,'name'=>'name15'),
array('id'=>16,'pid'=>1,'name'=>'name16'),
array('id'=>17,'pid'=>16,'name'=>'name17'),
array('id'=>18,'pid'=>17,'name'=>'name18'),
array('id'=>19,'pid'=>18,'name'=>'name19'),
array('id'=>20,'pid'=>3,'name'=>'name20'),
array('id'=>21,'pid'=>3,'name'=>'name21'),
array('id'=>22,'pid'=>2,'name'=>'name22'),
);

$result=array();
$id=2;
$lv=20;

get_child_node_nums($id,$lv,$result);

foreach($resultas$no=>$row)
{
echo'第'.($lv-$no+1).'层有'.count($row).'个叶子节点'.'<br/>';
}

p($result);

//模拟mysql根据pid获取多行记录
functionfetch_rows($pid=0)
{
global$data;
$pid=(int)$pid;
$items=array();
//相当于sql语句:select*fromtestwherepid=$pid
echo"select*fromtestwherepid=$pid;<br/>";
foreach($dataas$row)
{
if($row['pid']==$pid)
{
$items[]=$row;
}
}
return$items;
}

//$id为父节点id,$lv为深度,$result为引用传值结果数组
functionget_child_node_nums($id,$lv,&$result)
{
//首先根据其id作为子节点的pid获取其所有子节点
$children=fetch_rows($id);

if($children)
{
//存储其叶子节点
if(isset($result[$lv]))
{
$result[$lv]=array_merge($result[$lv],$children);
}else{
$result[$lv]=$children;
}
$lv--;
if($lv>0)
{
foreach($childrenas$child)
{
$id=$child['id'];
get_child_node_nums($id,$lv,$result);
}
}
}
}

functionp($var)
{
echo'<pre>';
if($var===false)
{
echo'false';
}elseif($var===null){
print_r("null");
}elseif($var===''){
print_r("''");
}else{
print_r($var);
}
echo'</pre>';
}

输出结果如下：

select*fromtestwherepid=2;
select*fromtestwherepid=3;
select*fromtestwherepid=4;
select*fromtestwherepid=20;
select*fromtestwherepid=21;
select*fromtestwherepid=5;
select*fromtestwherepid=6;
select*fromtestwherepid=7;
select*fromtestwherepid=8;
select*fromtestwherepid=9;
select*fromtestwherepid=10;
select*fromtestwherepid=11;
select*fromtestwherepid=12;
select*fromtestwherepid=13;
select*fromtestwherepid=14;
select*fromtestwherepid=15;
select*fromtestwherepid=22;
第1层有5个叶子节点
第2层有4个叶子节点
第3层有1个叶子节点
第4层有1个叶子节点
第5层有1个叶子节点
第6层有1个叶子节点
第7层有1个叶子节点
第8层有1个叶子节点
第9层有1个叶子节点
Array
(
[20]=>Array
(
[0]=>Array
(
[id]=>3
[pid]=>2
[name]=>name3
)

[1]=>Array
(
[id]=>5
[pid]=>2
[name]=>name5
)

[2]=>Array
(
[id]=>6
[pid]=>2
[name]=>name6
)

[3]=>Array
(
[id]=>7
[pid]=>2
[name]=>name7
)

[4]=>Array
(
[id]=>22
[pid]=>2
[name]=>name22
)

)

[19]=>Array
(
[0]=>Array
(
[id]=>4
[pid]=>3
[name]=>name4
)

[1]=>Array
(
[id]=>20
[pid]=>3
[name]=>name20
)

[2]=>Array
(
[id]=>21
[pid]=>3
[name]=>name21
)

[3]=>Array
(
[id]=>8
[pid]=>7
[name]=>name8
)

)

[18]=>Array
(
[0]=>Array
(
[id]=>9
[pid]=>8
[name]=>name9
)

)

[17]=>Array
(
[0]=>Array
(
[id]=>10
[pid]=>9
[name]=>name10
)

)

[16]=>Array
(
[0]=>Array
(
[id]=>11
[pid]=>10
[name]=>name11
)

)

[15]=>Array
(
[0]=>Array
(
[id]=>12
[pid]=>11
[name]=>name12
)

)

[14]=>Array
(
[0]=>Array
(
[id]=>13
[pid]=>12
[name]=>name13
)

)

[13]=>Array
(
[0]=>Array
(
[id]=>14
[pid]=>13
[name]=>name14
)

)

[12]=>Array
(
[0]=>Array
(
[id]=>15
[pid]=>14
[name]=>name15
)

)

)

亲测，望采纳^_^。

D. PHP，二叉树，求一个算法

var oNowNode;//现节点
var aArray;//所存数组

var i=0;
if(oNowNode.sibling.id>oNowNode.id){
alert(”位于左区“)；

}else{
alert(”位于右区“)；

}
while(oNowNode.id!=0){
oNowNode=oNowNode.parent;
aArray(i)=oNowNode.id;
i++;
}
print_r(aArray)；

E. php-红黑树、散列表、跳表理解入门

就是把链表的结构稍加改造，这种数据结构叫

为了提升链表的查询效率，怎么让链表支持类似‘数组’那样的‘二分’算法呢

跳表是一个各方面性能都比较优秀的 动态数据结构 ，可以支持快速地插入、删除、查找操作，写起来也不复杂，甚至可以替代红黑树。

Redis 中的有序集合（Sorted Set）就是用跳表来实现的。
那 Redis 为什么会选择用跳表(和散列表)来实现有序集合呢？ 为什么不用红黑树呢？这个问题一会在回答，先看看跳表的数据结构

其实概念很简单，就是在链表上加上了

当我们在不停插入数据，如果我们不更新索引，可能出现某 2 个索引结点之间数据非常多的情况。极端情况下，跳表还会退化成单链表。
红黑树、AVL 树这样平衡二叉树，是通过左右旋的方式保持左右子树的大小平衡，而跳表是通过 随机函数 来维护平衡性。

插入、删除、查找以及迭代输出有序序列这几个操作，红黑树也可以完成，时间复杂度跟跳表是一样的。但是， 按照区间来查找数据这个操作，红黑树的效率没有跳表高。

对于按照区间查找数据这个操作，跳表可以做到 O(logn) 的时间复杂度定位区间的起点，然后在原始链表中顺序往后遍历就可以了。

Redis 键值构建一个散列表，这样按照 key 来删除、查找一个成员对象的时间复杂度就变成了 O(1)。同时，借助跳表结构，其他操作也非常高效。

散列表的英文叫“Hash Table”，我们平时也叫它“哈希表”或者“Hash 表”

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字 key 对应一个存储位置 f(key)。查找时根据这个对应关系匠互给定的 key 的映射 f(key)

这种关系 f 称为散列函数（又称哈希函数）。散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表。那么关键字对应的记录存储位置称为散列地址。

散列函数的构造方法特点就是：计算简单、散列地址分布均匀

大家一定听说过 hash 碰撞。就是2个不同的 key 对应着不同的 f 关系。但这是几乎不可能的，即便像业界着名的MD5、SHA、CRC等哈希算法，也无法完全避免这种散列冲突。而且，因为数组的存储空间有限，也会加大散列冲突的概率。

我们只能通过其它途径来寻找方法。我们常用的散列冲突解决方法有两类，开放寻址法（open addressing）和链表法（chaining）。

所谓的开放寻址法就是一但发生了冲突，就去寻找下一个空的散地址，只要散列表足够大，空的散列表地址总能找到，并将记录存入。

链地址法又称链表法，其实当发生冲突时存入链表，如下图很容易就可以看明白。此时，已经不存在什么冲突地址的问题，无论有多少冲突，都只是在当前位置给单链表增加结点的问题。

这种不常见，就是把冲突的单独找个地方。

顾名思义，红黑树中的节点，一类被标记为黑色，一类被标记为红色。除此之外，一棵红黑

平衡二叉树 是一种二叉排序树，其中每一个节点的左子树和右子树的高度不能大于 1

红黑树是一种平衡二叉查找树。它是为了解决普通二叉查找树在数据更新的过程中，复杂度退化的问题而产生的。红黑树的高度近似 log2n，所以它是近似平衡，插入、删除、查找操作的时间复杂度都是 O(logn)。

平衡二叉查找树其实有很多，比如，Splay Tree（伸展树）、Treap（树堆）等，但是我们提到平衡二叉查找树，听到的基本都是红黑树。
红黑树在众多里面，表现的最为平衡。
“近似平衡”就等价为性能不会退化得太严重。

一棵红黑树还需要满足这样几个要求：

看到这里你会很头大，什么黑的红的，完全不懂。赋上连接，有时间在看

散列表 ：插入删除查找都是O(1), 是最常用的，但其缺点是不能顺序遍历(存入的数据是无顺序的)以及扩容缩容的性能损耗。适用于那些不需要顺序遍历，数据更新不那么频繁的。
散列表总和链表、跳表一起出现组合使用。

跳表 ：插入删除查找都是O(logn), 并且能顺序遍历。缺点是空间复杂度O(n)。适用于不那么在意内存空间的，其顺序遍历和区间查找非常方便。
跳表还可以和散列表组合让删除、查找一个成员对象操作变为O(1)，也就是说利用了散列表查找速度，跳表的顺序结构

红黑树 ：插入删除查找都是O(logn), 中序遍历即是顺序遍历，稳定。缺点是难以实现，去查找不方便。其实跳表更佳，但红黑树已经用于很多地方了。