PHP实现二叉树的深度优先遍历（前序、中序、后序）和广度优先遍历（层次）

前言：

深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

• 前序遍历：根节点->左子树->右子树
• 中序遍历：左子树->根节点->右子树
• 后序遍历：左子树->右子树->根节点

广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。

例如对于一下这棵树：

深度优先遍历：

• 前序遍历：10 8 7 9 12 11 13
• 中序遍历：7 8 9 10 11 12 13
• 后序遍历：7 9 8 11 13 12 10

广度优先遍历：

• 层次遍历：10 8 12 7 9 11 13

二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

代码示例：

 <?php
 header("Content-type: text/html; charset=utf-8");
 class Node
 {
     public $value;
     public $left;
     public $right;

     public function __construct($value)
     {
         $this->value = $value;
     }
 }

 class Tree
 {
     /**
      * 先序遍历(递归方法)
      */
     public function recursion_preorder($root)
     {
         static $res = array();
         if (!is_null($root))
         {
             $function = __FUNCTION__;
             $res[] = $root->value;
             $this->$function($root->left);
             $this->$function($root->right);
         }
         return $res;
     }

     /**
      * 中序遍历(递归方法)
      */
     public function recursion_midorder($root)
     {
         static $res = array();
         if(!is_null($root))
         {
             $function = __FUNCTION__;
             $this->$function($root->left);
             $res[] = $root->value;
             $this->$function($root->right);
         }
         return $res;
     }

     /**
      * 后序遍历(递归方法)
      */
     public function recursion_postorder($root)
     {
         static $res = array();
         if (!is_null($root))
         {
             $function = __FUNCTION__;
             $this->$function($root->left);
             $this->$function($root->right);
             $res[] = $root->value;
         }
         return $res;
     }

     /**
      * 先序遍历(非递归)
      */
     public function preorder($node)
     {
         $res = array();
         $stack = new splstack();
         while(!is_null($node) || !$stack->isEmpty())
         {
             while(!is_null($node))//节点不为空就入栈
             {
                 $stack->push($node);
                 $res[] = $node->value;
                 $node = $node->left;
             }
             $node = $stack->pop();
             $node = $node->right;
         }
         return $res;
     }

     /**
      * 中序遍历(非递归)
      */
     public function midorder($node)
     {
         $res = array();
         $stack = new splstack();
         while(!is_null($node) || !$stack->isEmpty())
         {
             while(!is_null($node))
             {
                 $stack->push($node);
                 $node = $node->left;
             }
             $node = $stack->pop();
             $res[] = $node->value;
             $node = $node->right;
         }
         return $res;
     }

     /**
      * 后序遍历(非递归)
      */
     public function postorder($node)
     {
         $stack = new splstack();
         $outstack = new splstack();

         $stack->push($node);
         while(!$stack->isEmpty())
         {
             $center_node = $stack->pop();
             $outstack->push($center_node);//最先压入根节点，最后输出
             if(!is_null($center_node->left))
             {
                 $stack->push($center_node->left);
             }
             if(!is_null($center_node->right))
             {
                 $stack->push($center_node->right);
             }
         }

         $res = array();
         while(!$outstack->isEmpty())
         {
             $node = $outstack->pop();
             $res[] = $node->value;
         }
         return $res;
     }

     /**
      * 广度优先遍历(层次遍历、非递归)
      */
     public function level_order($node)
     {
         $res = array();
         $queue = new splqueue();
         $queue->enqueue($node);
         while(!$queue->isEmpty())
         {
             $node = $queue->dequeue();
             $res[] = $node->value;
             if(!is_null($node->left))
             {
                 $queue->enqueue($node->left);
             }
             if(!is_null($node->right))
             {
                 $queue->enqueue($node->right);
             }
         }
         return $res;
     }
 }

 $a = new Node(10);
 $b = new Node(8);
 $c = new Node(12);
 $d = new Node(7);
 $e = new Node(9);
 $f = new Node(11);
 $g = new Node(13);

 $a->left = $b;
 $a->right = $c;
 $b->left = $d;
 $b->right = $e;
 $c->left = $f;
 $c->right = $g;

 $tree = new Tree();
 $res = $tree->recursion_preorder($a);
 echo "先序遍历结果(递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->preorder($a);
 echo "先序遍历结果(非递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->recursion_midorder($a);
 echo "中序遍历结果(递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->midorder($a);
 echo "中序遍历结果(非递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->recursion_postorder($a);
 echo "后序遍历结果(递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->postorder($a);
 echo "后序遍历结果(非递归)：" . implode('-', $res) . "<br/>";

 $res = $tree->level_order($a);
 echo "层次遍历结果(非递归)：" . implode('-', $res) . "<br/>";