/**
* ClearBiTree() 清空二叉树
* CreateBiTree() 创建二叉树
* BiTreeEmpty() 判断二叉树是否为空
* BiTreeDepth() 返回二叉树的深度
* root() 返回二叉树的根
* Parent() 返回给定元素的双亲
* LeftChild() 要返回左孩子的元素
* RightChild() 要返回右孩子的元素
* LeftSibling() 要返回左兄弟的元素
* RightSibling() 要返回右兄弟的元素
* Insert($data) 插入节点——递归算法
* insert2($data) 插入节点——非递归算法
* DeleteSubtree($elem,$LR) 删除某个节点的左(右)子树
* PreOrderTraverse() 先序遍历——递归算法
* InOrderTraverse() 中序遍历——递归算法
* PostOrderTraverse() 后序遍历——非递归算法
* preOrderTraverse2() 先序遍历——非递归算法
* preOrderTraverse3() 先序遍历——非递归算法
* inOrderTraverse2() 中序遍历——非递归算法
* inOrderTraverse3() 中序遍历——非递归算法
* postOrderTraverse2() 后序遍历——非递归算法
*/
class BiNode{
public $data;
public $lchild;
public $rchild;
public function __construct($data){
$this->data=$data; //节点数据
$this->lchild=null;//左孩子的指针
$this->rchild=null;//右孩子的指针
}
}
class LinkBiTree{
private $root; //二叉树的根节点
private static $preArr; //用于保存先序遍历后的数据
private static $inArr; //用于保存中序遍历后的数据
private static $postArr; //用于保存后序遍历后的数据
private static $levelArr; //用于保存后序遍历后的数据
private static $count; //记录创建二叉树结点的个数
const MAX_LEVEL=2;//二叉树最大的层数
public static $test;
public function __construct(){
$this->root=null;//指向根节点,初始化时为空树
self::$count=0;
}
/**
* 清空二叉树
*/
public function ClearBiTree(){
$this->clearTree($this->root);
}
/**
* @param $root 表示树的根节点
*/
private function clearTree($root){
if($root){
if($root->lchild){
$this->clearTree($root->lchild); //清空左子树
}
if($root->rchild){
$this->clearTree($root->rchild); //清空右子树
}
unset($root); //释放根节点
$root=null;
}
}
//先序遍历
public function PreOrderTraverse(){
$this->preTraverse($this->root);
return self::$preArr;
}
private function preTraverse($root){
if($root){
self::$preArr[]=$root->data; //先访问根节点
$this->preTraverse($root->lchild);//再先序遍历左子树
$this->preTraverse($root->rchild);//最后先序遍历右子树
}
}
//中序遍历
public function InOrderTraverse(){
$this->inTraverse($this->root);
return self::$inArr;
}
private function inTraverse($root){
if($root){
$this->inTraverse($root->lchild); //先中序遍历左子树
self::$inArr[]=$root->data; //再访问根节点
$this->inTraverse($root->rchild);//最后中序遍历右子树
}
}
//后序遍历
public function PostOrderTraverse(){
$this->postTraverse($this->root);
return self::$postArr;
}
private function postTraverse($root){
if($root){
$this->postTraverse($root->lchild); //先后序遍历左子树
$this->postTraverse($root->rchild); //再后序遍历右子树
self::$postArr[]=$root->data; //最后再访问根节点
}
}
//层序遍历
public function LevelOrderTraverse(){
for($i=1;$i<=$this->BiTreeDepth();$i++){
$this->levelTraverse($this->root,$i);
}
return self::$levelArr;
}
private function levelTraverse($root,$level){
if($root){
if($level==1){
self::$levelArr[]=$root->data;
}
$this->levelTraverse($root->lchild,$level-1);
$this->levelTraverse($root->rchild,$level-1);
}
}
//创建二叉树
public function CreateBiTree(){
$this->createTree($this->root);
}
//此处使用先序输入数据的方式来创建的
private function createTree(&$root){
$node=new BiNode(mt_rand(1,20));
self::$count++;
if(self::$count<=pow(2,self::MAX_LEVEL)-1){
$root=$node;
self::$test[]=$root->data;
$this->createTree($root->lchild);
$this->createTree($root->rchild);
}
}
//判断二叉树是否为空
public function BiTreeEmpty(){
// if($this->root){
// return false;
// }else{
// return true;
// }
return $this->root==null;
}
//返回二叉树的深度
public function BiTreeDepth(){
return $this->treeDepth($this->root);
}
private function treeDepth($root){
//求左子树的深度
$arr=array();
$root=$this->root;
$level=0;
$num=0;
array_push($arr,$root);
while(count($arr)!=0){
$root=array_shift($arr);
$num++;
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
while($num>pow(2,$level-1)-1){
$level++;
}
$level--;
return $level;
}
//返回二叉树的根
public function Root(){
return $this->root==null ? 'Null':$this->root->data;
}
//返回给定元素的双亲
//此处分别使用php内部的array_push()和array_shift()这两个函数模拟队列
/**
* @param $elem
* @return string
* 返回给定元素的双亲
* 思路：1.使用数组队列来保存节点的指针
* 2.将根节点从队尾压入数组队列中
* 3.然后取出队首元素，使其左节点、右节点分别于给定的元素比较
* 4.相等的就返回上一步中取出的队首元素，否则，将此队首元素的左右节点指针分别压入队尾
* 5.重复第3步
*/
public function Parent($elem){
if($this->root){
$arr=array();//此处数组是当队列来使用的，用于存放树(包括子树)的根指针
array_push($arr,$this->root);
while(count($arr)!=0){
$root=array_shift($arr);
if($root->lchild && $root->lchild->data==$elem ||
$root->rchild && $root->rchild->data==$elem){
return $root->data;
}else{
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
}
}
return false;
}
/**
* @param $elem 要返回左孩子的元素
* @return string
* 思路：同上
*/
public function LeftChild($elem){
if($this->root){
$arr=array();
array_push($arr,$this->root);
while(count($arr)!=0){
$root=array_shift($arr);
if($root->data==$elem && $root->lchild){
return $root->lchild->data;
}
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild) {
array_push($arr, $root->rchild);
}
}
}
return false;
}
/**
* @param $elem 要返回左孩子的元素
* @return string
* 思路：同上
*/
public function RightChild($elem){
if($this->root){
$arr=array();
array_push($arr,$this->root);
while(count($arr)!=0){
$root=array_shift($arr);
if($root->data==$elem && $root->rchild){
return $root->rchild->data;
}
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
}
return false;
}
/**
* @param $elem 要返回左兄弟的元素
* @return string
*/
public function LeftSibling($elem){
$parent=$this->Parent($elem);
$leftChild=$this->LeftChild($parent);
$rightChild=$this->RightChild($elem);
if($rightChild==$elem && $leftChild){
return $leftChild;
}
return 'Error';
}
/**
* @param $elem 要返回右兄弟的元素
* @return string
*/
public function RightSibling($elem){
$parent=$this->Parent($elem);
$leftChild=$this->LeftChild($parent);
$rightChild=$this->RightChild($elem);
if($leftChild==$elem && $rightChild){
return $rightChild;
}
return 'Error';
}
/**
* @param $data 要插入的数据
* 思路：1.插入的数据比树中的根(包括子树)节点小时，就放在根节点的左子树上；
* 2.比根节点大时，插入到右子树上；
* 注意：因为插入的位置不是叶节点就是只有左(或右)子树的节点，所以可以得知此递归的出口肯定是某个节点的左(或右)子树指针为空的时候。当此节点的左(右)都不为空的时候，递归就会持续下去，直到为左(右)子树有一边或全部为空的节点出现为止。
*/
public function Insert($data){
$node = new BiNode($data);
$this->insertNode($node,$this->root);
}
private function insertNode($node,&$root){
if(!$root){
$root=$node;
}else{
if($node->data > $root->data){
$this->insertNode($node,$root->rchild);
}else if($node->data data){
$this->insertNode($node,$root->lchild);
}else{
return;
}
}
}
//非递归算法实现插入节点操作
public function insert2($data){
$node=new BiNode($data);
if(!$this->root){
$this->root=$node;
}else {
$arr = array();
array_push($arr, $this->root);
while (count($arr) != 0) {
$root = array_shift($arr);
//表示如果要插入的数据$node->data大于根节点的数据$root->data并且根节点的
//左子树为空的话，那么就将$node->data赋值给左子树
if ($node->data data && !$root->lchild) {
$root->lchild = $node;
break;
//此处为大于，思路与小于相似
}else if($node->data > $root->data && !$root->rchild){
$root->rchild = $node;
break;
}
//以下两个if语句，表示如果上面的两个条件都不满足的话，那么就将跟的左右节点分别要入队列，继续循环
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
}
}
/**
* @param $elem 要删除的那个节点的子树
* @param $LR 表示是要删除左子树还是右子树
*/
public function DeleteSubtree($elem,$LR){
if($this->root){
$arr=array();
array_push($arr,$this->root);
while(count($arr)!=0){
$root=array_shift($arr);
if($root->data==$elem && $LR==0){
$root->lchild=null;
}
if($root->data==$elem && $LR==1){
$root->rchild=null;
}
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
}
}
/*
以下是先序，中序，后序，层序的非递归实现算法
除了层序遍历使用了队列外，其他的是利用栈来实现的
思路: 1.输出当前根节点
2.将当前根节点的右孩子做压栈处理
3.将当前节点的右孩子作为新的根节点，如果为空的话，将栈顶元素弹出作为新的根节点。
4.重复1,2,3
*/
public function preOrderTraverse2(){
$arr=array();
$root=$this->root;
$arrPre=array();
while($root || count($arr)!=0){
$arrPre[]=$root->data;
if($root->rchild){
$rootR=$this->rchild;
array_push($arr,$rootR);
}
$root=$root->lchild;
if(!$root){
$root=array_pop($arr);
}
}
return $arrPre;
}
/*
* 思路：1.将根节点压栈
* 2.弹出栈顶元素作为新的根节点
* 3.根据栈——先进后出的特性，先进根节点的右孩子做压栈处理，再将其左孩子做压栈处理；
* 4.重复2,3
* 注：此算法与上面的算法基本思想是相同的，只是细节处理上有所不同。
*/
public function preOrderTraverse3(){
$arr=array();
$root=$this->root;
array_push($arr,$root);
while(count($arr)!=0){
$root=array_pop($arr);
$arrPre[]=$root->data;
if($root->rchild){
array_push($arr,$root->rchild);
}
if($root->lchild){
array_push($arr,$root->lchild);
}
}
return $arrPre;
}
//中序遍历算法2
/*
* 思路：1.将根节点压栈
* 2.将根节点的左孩子作为新的根节点,对其进行遍历
* 3.如果左子树遍历完毕，就将栈中的左子树结点弹出并输出，然后将此弹出结点的右孩子作为新的根节点。
* 4.重复1,2,3
* 注：此处或许有人对while循环的判断条件有所不理解。因为假如说我们只用$root是否为空来作为判断条件的话，那么当我们遍历完左子树后，程序就结束了，显然不是我们要的结果；假如我们只用栈$arr是否为空为判断条件的话，那么循环根本无法进行。
*
*/
public function inOrderTraverse2(){
$arr=array();
$root=$this->root;
while($root || count($arr)!=0){
if($root){
//根指针进栈，遍历左子树.此处之所以没有在循环外先将整棵树的根节点做压栈处理，是因为，如果这样做了，那么此处对左子树的遍历就会出现死循环，因为这是的判断条件就是$root->lchild，而不是$root了，倘若还是$root那么栈中就会有两个根(整棵树)。
array_push($arr,$root);
$root=$root->lchild;
}else{
//根指针退栈，访问根节点，遍历右子树
$root=array_pop($arr);
$arrIn[]=$root->data;
$root=$root->rchild;
}
}
return $arrIn;
}
//中序遍历算法3
/*
* 思路：1.先进根做压栈处理
* 2.遍历左子树
* 3.取出栈顶元素并将输出的节点作为新的根节点
* 4.将根节点的右孩子压栈并重新作为新的根节点
* 5.重复2，3，4
* 注：此算法和上面的算法的整体思想是一样的
*/
public function inOrderTraverse3(){
$arr = array();
$root = $this->root;
array_push($arr,$root);
while (count($arr) != 0) {
while($root){
array_push($arr,$root->lchild);
$root=$root->lchild;
}
array_pop($arr);
if(count($arr)!=0){
$root=array_pop($arr);
$arrIn[]=$root->data;
array_push($arr,$root->rchild);
$root=$root->rchild;
}
}
return $arrIn;
}
//因为先序是根左右，而后序是左右根，如果将后序反转180度的话，那么顺序就是根右左.根据递归转换为非递归(栈)的方法——如果一个函数内有多于一个的递归调用那么此时，栈的进入顺序应该与递归调用的顺序相反。因为栈的特性是先进后出。
//后序遍历算法2
public function postOrderTraver2(){
$arr=array();
$root=$this->root;
array_push($arr,$root);
while(count($arr)!=0){
$root=array_pop($arr);
$arrPost[]=$root->data;
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
return array_reverse($arrPost);
}
//层级遍历算法2
public function levelOrderTraverse2(){
$arr=array();
$root=$this->root;
array_push($arr,$root);
while(count($arr)!=0){
$root=array_shift($arr);
$arrLevel[]=$root->data;
if($root->lchild){
array_push($arr,$root->lchild);
}
if($root->rchild){
array_push($arr,$root->rchild);
}
}
return $arrLevel;
}
/*
* 递归转非递归算法小结：
* 1.如果函数体内只有一个递归调用，那么直接使用栈或队列等转换即可；
* 2.如果有多个递归调用并且相邻，比如先序和后序遍历算法，那么转为非递归算法时，先后顺序要倒转；
* 3.如果有多个递归但不相邻，比如中序遍历，那么就直接按照原先的顺序依次转换即可。但如果里面依然有部分相邻，那么就按小结2操作。
* 4.转换时，我们应该将哪些数据放入栈中呢。根据函数调用的原理，在调用一个函数时，内存中就会开辟一个栈空间，里面保存了函数的实参，局部变量和函数调用时的返回地址等，而我们要放入栈中的就是实参和局部变量(此处的局部变量是指后序递归要用到的局部变量)。
*/
}
1340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
