PHP 时间种子 批量 随机数的例子

对于时间种子 批量 随机数我相信各位朋友都会想到mt_rand()和rand()函数了，下面我们一起来利用php自带的函数来实现我们想要的东西．

PHP函数mt_rand()和rand()会在批量生成的时候是会有几率出现重复的随机数。srand()和mt_srand()在PHP4.1开始已经不在显式调用了，在mt_rand和rand的时候会自动生成种子。因为，在批量随机的时候，我们自己显式条用生成种子，就可以避免重复。为什么呢？因为种子不一样了呀。种子为什么不一样了呢？因为他是时间种子。

<?php
//存储生存的随机数
$randArr = array();
//生成十万个吧
for($i=0;$i<100000;$i++){
    //生成种子
    $date = explode(' ', microtime());
    $seed = $date[0];
    //种子发生器
    mt_srand($seed);
    //生成随机数
    $randArr[] = mt_rand();
}
?>

随机数生成了。并且不会重复的哦。以时间为种子的好处就是省略了在普通的伪随机数会出现重复的情况时进行do{生成随机数code}while(!isset(新生成的一个随机数))的判断步骤。

PHP投票程序在做活动时会用到了，我们今天就为各位朋友分享一个PHP投票程序，有需要了解的同学不防一起来看看吧．

PHP刷投票，让你高居榜首！本文附上刷票方法和防御策略。

案例为一个半月以前。没有及时放出原因有二，一是因为博客域名备案没有下来，没有心情写东西。二是最主要的，及时放出对案例网站有严重的损害，不是我等IT人应有的。
Ps：刷票有风险，使用需谨慎。本文谨做学习研究讨论之用，不可用作不正当用途！

本文为本博客的处女之作，题材源于近日一朋友要求，是因为她的姐姐参加了一个书法比赛，问我能不能在网站上刷投票。作为刚刚出道一年的小菜鸟，我很惶恐。一年前刚刚接触PHP的时候，完全不知道做，现在第一反应就是Curl。

废话不多说了，直接上代码。

<?php
header('Content-type: text/html; charset=gb2312');
//随机生成IP
$ip1 = rand(101, 255).'.';
$ip2 = rand(1, 255).'.';
$ip3 = rand(1, 255).'.';
$ip4 = rand(1, 255);
$ip = $ip1 . $ip2 . $ip3 . $ip4;
$clientIp = 'CLIENT-IP:'.$ip;
$xforwarded = 'X-FORWARDED-FOR:'.$ip;
//设置目标和来源
$url = 'http://www.dunhuangwomen.org.cn/vote/Vote.asp?id=67';
$referer = 'http://www.dunhuangwomen.org.cn/vote/list.asp?id=2';
//Curl
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url); //目标
curl_setopt($ch, CURLOPT_HTTPHEADER, array($xforwarded, $clientIp));  //构造IP
curl_setopt($ch, CURLOPT_REFERER, $referer); //来源
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);

$ret = curl_exec($ch);
curl_close($ch);
echo $ret;
?>

好，来分析一下。
1、仿造IP，网站有限制一个IP在一天只可以投一次
2、填写来源，网站会判断请求的来源是否合法路径
其他就是Curl的常规了选项了。

如何防治？

本人才疏学浅，仅作跑砖引玉。

1、限制IP

本文已经破解

2、限制来源

本文已经破解

3、验证码。作为最反人类的发明之一，可以使用这个拥有高大上的名字的全自动区分计算机和人类的图灵测试。
    可用Opencv。
4、记录MAC地址。
    理论上每块网卡都有一个唯一的MAC地址，如果更改可能引起冲突而无法上网。目前也可以用软件修改
5、注册会员
    虽说仍然可以突破验证码，Curl填写参数然后POST过去，但是门槛毕竟高了一丁点，还是忽略吧。
6、手机
    投票时输入手机号和短信验证码，成本高，单位不愿意。用户发送某某指令到某某，用户自掏腰包，用户不愿意。

目前来说，只有验证码，手机并且验证手机的有效性是最好的防治措施。

很多人对于四则运算可能不太明天了，下面我们来看看关于php四则运算：中缀表达式转后缀表达式例子，有需要了解的朋友可以一起来看看吧．

四则运算表达式，我们书面使用的叫做中缀表达式，而计算器，却更加喜欢后缀表达，括号优先级，加减乘除优先级等使得运算中缀四则表达式变得困难。这个时候引入了一种计算机喜欢的格式，叫做后缀表达式。本文以PHP代码，实现中缀表达式转后缀表达式的逻辑。

    本文以PHP为代码环境，有人会说高级语言直接写表达式就好了，它们会算，可是他们为什么会算，怎么算的，还是需要把中缀表达式转为后缀表达式。因此本文代码只是模拟一个逻辑。

    比如：传统的四则运算表达式（中缀表达式）是9 + ( 3 - 1 ) * 3 + 10 / 2，对应的后缀表达式就是9 3 1 - 3 * + 10 2 / +。

    转换逻辑：一个字符一个字符的输入，如果是数字则直接输出；如果是左括号则直接入栈；如果是右括号则开始出栈，直到遇到第一次左括号为止；如果是加减乘除，则判断，如果栈顶也是符号，且输入的符号的优先级不高于栈顶的符号优先级，则全部出栈，否则该输入的符号入栈。

<?php

/**

 * 将输入的字符按照中缀表达式转后缀表达式的规则处理

 * @param $str 输入的字符

 * @param $stack 栈

 * @param $newStrList 新的表达式

 */

function suffix($str, &$stack, &$newStrList){

    //如果是数字则输出

    if(is_numeric($str)){

        $newStrList .= $str . ' ';

    }

    //如果是左括号则入栈

    else if($str == '('){

        $stack[] = $str;

    }

    //如果是右括号则将最近的左括号之前的所有数据出栈

    else if($str == ')'){

        while($arrPop = array_pop($stack)){

            if($arrPop == '('){

                break;

            }

            $newStrList .= $arrPop . ' ';

        }

    }

    //如果是加减乘除则判断与栈顶符号优先级

    else if(in_array($str, array('+', '-', '*', '/')) && count($stack) > 0){

        $key  = (count($stack) - 1);

        if(in_array($stack[$key], array('+', '-', '*', '/'))){

            //该符号优先级不高于栈顶符号的

            if(checkPriority($str, $stack[$key]) != 1){

                for($i=$key; $i>=0; $i--){

                    if($stack[$i] == '('){

                        break;

                    }

                    $newStrList .= $stack[$i] . ' ';

                    unset($stack[$i]);

                    $stack = array_values($stack);

                }

            }

        }

        //本次的符号入栈

        $stack[] = $str;

    }else{

        $stack[] = $str;

    }

}

 

/**

 * 判断运算符的优先级

 * @param $operatorA

 * @param $operatorB

 * @return A大于B返回1，A等于B返回0，A小于B返回-1

 */

function checkPriority($operatorA, $operatorB){

    switch($operatorA){

        case '+':

        case '-':

            if($operatorB == '+' || $operatorB == '-'){

                return 0;

            }else if($operatorB == '*' || $operatorB == '/'){

                return -1;

            }

            break;

        case '*':

        case '/':

            if($operatorB == '+' || $operatorB == '-'){

                return 1;

            }else if($operatorB == '*' || $operatorB == '/'){

                return 0;

            }

            break;

        default:

            exit('error');

    }

}

//栈

$stack = array();

//待转换的表达式

$strList = '9 + ( 3 - 1 ) * 3 + 10 / 2';

//新的表达式

$newStrList = '';

$strList = explode(' ', $strList);

foreach($strList as $str){

    if($str != ' '){

        suffix($str, $stack, $newStrList);

    }

}

//数组反转

while($s = array_pop($stack)){

    $newStrList .= $s . ' ';

}

echo $newStrList;

二叉树算法在小编大学时学数据结构时会学到的一个算法了，这个可以在搜索与排序中提高50%的搜索性能了，下面我们来看一些关于php 二叉树遍历算法与例子吧。

  二叉树遍历，是值从根节点出发，按照某种次序依次访问二叉树中的所有节点，使得每个节点被访问一次且仅被访问依

 

图是百度搜的。。。谢谢提供图的英雄。。

    前序遍历二叉树：如果二叉树为空则返回，若二叉树非空，则先遍历左树，再遍历右树，遍历顺序为ABCDEGF。

    中序遍历二叉树：如果二叉树为空则返回，若二叉树非空，则从根节点开始，中序遍历根节点的左子树，然后是访问根节点，最后中序遍历右子树，遍历顺序为CBEGDFA。

    后序遍历二叉树：如果二叉树为空则返回，若二叉树非空，则从左到右先叶子后节点的访问遍历访问左右子树，最后是访问根节点。访问顺序为CGEFDBA。

    层序遍历二叉树：如果二叉树为空则返回，若二叉树非空，则从树的第一层，也就是根节点开始访问，从上而下逐层遍历，在同一层中，按照从左到右的顺序对节点逐个访问。访问顺序为ABCDEFG。

 

    现在，我们用PHP代码，来遍历二叉树结构。二叉树是放一个大数组，每一个节点都有三个字段，data表示这个节点的值，lChild表示这个节点的左边子节点，rChild表示这个节点的右边子节点。二叉树的结构我们用上面那张图。

 

二叉树结构代码如下：

<?php

//二叉树

$arr = array(

    'data' => 'A',

    'lChild' => array(

        'data' => 'B',

        'lChild' => array(

            'data' => 'C',

            'lChild' => array(),

            'rChild' => array(),

        ),

        'rChild' => array(

            'data' => 'D',

            'lChild' => array(

                'data' => 'E',

                'lChild' => array(),

                'rChild' => array(

                    'data' => 'G',

                    'lChild' => array(),

                    'rChild' => array(),

                ),

            ),

            'rChild' => array(

                'data' => 'F',

                'lChild' => array(),

                'rChild' => array(),

            ),

        ),

    ),

    'rChild' => array(),

);

 

遍历算法一：前序遍历二叉树

<?php

//前序遍历二叉树算法

echo '前序遍历二叉树算法：';

PreOrderTraverse($arr);

echo '<Br>';

function PreOrderTraverse($node){

    if(empty($node)){

        return;

    }

    //输出值

    print_r($node['data']);

    //左节点

    PreOrderTraverse($node['lChild']);

    //右节点

    PreOrderTraverse($node['rChild']);

}

 

遍历算法二：中序遍历二叉树

<?php

//中序遍历二叉树算法

echo '中序遍历二叉树算法：';

inOrderTraverse($arr);

echo '<Br>';

function inOrderTraverse($node){

    if(empty($node)){

        return;

    }

    //左节点

    inOrderTraverse($node['lChild']);

    //输出值

    print_r($node['data']);

    //右节点

    inOrderTraverse($node['rChild']);

}

 

遍历算法三：后序遍历二叉树

<?php

//后序遍历二叉树算法

echo '后序遍历二叉树算法：';

postOrderTraverse($arr);

echo '<Br>';

function postOrderTraverse($node){

    if(empty($node)){

        return;

    }

    //左节点

    postOrderTraverse($node['lChild']);

    //右节点

    postOrderTraverse($node['rChild']);

    //输出值

    print_r($node['data']);

}

例子

<?php
/**
 *二叉树的创建及基本操作
 *
 *1.构造方法,初始化建立二叉树
 *2.按先序遍历方式建立二叉树
 *3.按先序遍历二叉树
 *4.先序遍历的非递归算法
 *5.中序遍历二叉树
 *6.中序遍历的非递归算法
 *7.后序遍历二叉树
 *8.后序遍历非递归算法
 *9.层次遍历二叉树
 *10.求二叉树叶子结点的个数
 *11.求二叉树的深度
 *12.判断二叉树是否为空树
 *13.置空二叉树
 *
 *@author xudianyang<>
 *@version $Id:BinaryTree.class.php,v 1.0 2011/02/13 13:33:00 uw Exp
 *@copyright &copy;2011,xudianyang
 */
header('content-type:text/html;charset=gb2312');

//在PHP数据结构之五 栈的PHP的实现和栈的基本操作 可以找到该类
include_once("./StackLinked.class.php");

//在 PHP数据结构之七 队列的链式存储和队列的基本操作 可以找到该类
include_once('./QueueLinked.class.php');
class BTNode{
 //左子树“指针”
 public $mLchild=null;
 //右子树“指针”
 public $mRchild=null;
 //结点数据域
 public $mData=null; //左标志域，为1时表示mLchild“指向”结点左孩子，为2表示“指向”结点直接前驱
 public $intLeftTag=null;
 //右标志域，为1时表示mRchild“指向”结点右孩子，为2表示“指向”结点直接后继
 public $intRightTag=null;
}
class BinaryTree{
 //根结点
 public $mRoot;
 //根据先序遍历录入的二叉树数据
 public $mPBTdata=null;
 /**
  *构造方法,初始化建立二叉树
  *
  *@param array $btdata 根据先序遍历录入的二叉树的数据，一维数组，每一个元素代表二叉树一个结点值,扩充结点值为''[长度为0的字符串]
  *@return void
  */
 public function __construct($btdata=array()){
  $this->mPBTdata=$btdata;
  $this->mRoot=null;
  $this->getPreorderTraversalCreate($this->mRoot);
 }
 /**
  *按先序遍历方式建立二叉树
  *
  *@param BTNode 二叉树结点，按引用方式传递
  *@return void
  */
 public function getPreorderTraversalCreate(&$btnode){
  $elem=array_shift($this->mPBTdata);
  if($elem === ''){
   $btnode=null;
  }else if($elem === null){
   return;
  }else{
   $btnode=new BTNode();
   $btnode->mData=$elem;
   $this->getPreorderTraversalCreate($btnode->mLchild);
   $this->getPreorderTraversalCreate($btnode->mRchild);
  }
 }
 /**
  *判断二叉树是否为空
  *
  *@return boolean 如果二叉树不空返回true,否则返回false
  **/
 public function getIsEmpty(){
  if($this->mRoot instanceof BTNode){
   return false;
  }else{
   return true;
  }
 }
 /**
  *将二叉树置空
  *
  *@return void
  */
 public function setBinaryTreeNull(){
  $this->mRoot=null;
 }
 /**
  *按先序遍历二叉树
  *
  *@param BTNode $rootnode 遍历过程中的根结点
  *@param array $btarr 接收值的数组变量，按引用方式传递
  *@return void
  */
 public function getPreorderTraversal($rootnode,&$btarr){
  if($rootnode!=null){
   $btarr[]=$rootnode->mData;
   $this->getPreorderTraversal($rootnode->mLchild,$btarr);
   $this->getPreorderTraversal($rootnode->mRchild,$btarr);
  }
 }
 /**
  *先序遍历的非递归算法
  *
  *@param BTNode $objRootNode 二叉树根节点
  *@param array $arrBTdata 接收值的数组变量，按引用方式传递
  *@return void
  */
 public function getPreorderTraversalNoRecursion($objRootNode,&$arrBTdata){
  if($objRootNode instanceof BTNode){
   $objNode=$objRootNode;
   $objStack=new StackLinked();
   do{
    $arrBTdata[]=$objNode->mData;
    $objRNode=$objNode->mRchild;
    if($objRNode !=null){
     $objStack->getPushStack($objRNode);
    }
    $objNode=$objNode->mLchild;
    if($objNode==null){
     $objStack->getPopStack($objNode);
    }
   }while($objNode!=null);
  }else{
   $arrBTdata=array();
  }
 }
 /**
  *中序遍历二叉树
  *
  *@param BTNode $objRootNode 过程中的根节点
  *@param array $arrBTdata 接收值的数组变量,按引用方式传递
  *@return void
  */
 public function getInorderTraversal($objRootNode,&$arrBTdata){
  if($objRootNode!=null){
   $this->getInorderTraversal($objRootNode->mLchild,$arrBTdata);
   $arrBTdata[]=$objRootNode->mData;
   $this->getInorderTraversal($objRootNode->mRchild,$arrBTdata);
  }
 }
 /**
  *中序遍历的非递归算法
  *
  *@param BTNode $objRootNode 二叉树根结点
  *@param array $arrBTdata 接收值的数组变量，按引用方式传递
  *@return void
  */
 public function getInorderTraversalNoRecursion($objRootNode,&$arrBTdata){
  if($objRootNode instanceof BTNode){
   $objNode=$objRootNode;
   $objStack=new StackLinked();
   //中序遍历左子树及访问根节点
   do{
    while($objNode!=null){
     $objStack->getPushStack($objNode);
     $objNode=$objNode->mLchild;
    }
    $objStack->getPopStack($objNode);
    $arrBTdata[]=$objNode->mData;
    $objNode=$objNode->mRchild;
   }while(!$objStack->getIsEmpty());
   //中序遍历右子树
   do{
    while($objNode!=null){
     $objStack->getPushStack($objNode);
     $objNode=$objNode->mLchild;
    }
    $objStack->getPopStack($objNode);
    $arrBTdata[]=$objNode->mData;
    $objNode=$objNode->mRchild;
   }while(!$objStack->getIsEmpty());
  }else{
   $arrBTdata=array();
  }
 }
 /**
  *后序遍历二叉树
  *
  *@param BTNode $objRootNode  遍历过程中的根结点
  *@param array $arrBTdata 接收值的数组变量，引用方式传递
  *@return void
  */
 public function getPostorderTraversal($objRootNode,&$arrBTdata){
  if($objRootNode!=null){
   $this->getPostorderTraversal($objRootNode->mLchild,$arrBTdata);
   $this->getPostorderTraversal($objRootNode->mRchild,$arrBTdata);
   $arrBTdata[]=$objRootNode->mData;
  }
 }
 /**
  *后序遍历非递归算法
  *
 BTNode $objRootNode 二叉树根节点
 array $arrBTdata 接收值的数组变量，按引用方式传递
 void
  */
 public function getPostorderTraversalNoRecursion($objRootNode,&$arrBTdata){
  if($objRootNode instanceof BTNode){
   $objNode=$objRootNode;
   $objStack=new StackLinked();
   $objTagStack=new StackLinked();
   $tag=1;
   do{
    while($objNode!=null){
     $objStack->getPushStack($objNode);
     $objTagStack->getPushStack(1);
     $objNode=$objNode->mLchild;
    }
    $objTagStack->getPopStack($tag);
    $objTagStack->getPushStack($tag);
    if($tag == 1){
     $objStack->getPopStack($objNode);
     $objStack->getPushStack($objNode);
     $objNode=$objNode->mRchild;
     $objTagStack->getPopStack($tag);
     $objTagStack->getPushStack(2);

    }else{
     $objStack->getPopStack($objNode);
     $arrBTdata[]=$objNode->mData;
     $objTagStack->getPopStack($tag);
     $objNode=null;
    }
   }while(!$objStack->getIsEmpty());
  }else{
   $arrBTdata=array();
  }
 }
 /**
  *层次遍历二叉树
  *
  *@param BTNode $objRootNode二叉树根节点
  *@param array $arrBTdata 接收值的数组变量，按引用方式传递
  *@return void
  */
 public function getLevelorderTraversal($objRootNode,&$arrBTdata){
  if($objRootNode instanceof BTNode){
   $objNode=$objRootNode;
   $objQueue=new QueueLinked();
   $objQueue->getInsertElem($objNode);
   while(!$objQueue->getIsEmpty()){
    $objQueue->getDeleteElem($objNode);
    $arrBTdata[]=$objNode->mData;
    if($objNode->mLchild != null){
     $objQueue->getInsertElem($objNode->mLchild);
    }
    if($objNode->mRchild != null){
     $objQueue->getInsertElem($objNode->mRchild);
    }
   }
  }else{
   $arrBTdata=array();
  }
 }
 /**
  *求二叉树叶子结点的个数
  *
  *@param BTNode $objRootNode 二叉树根节点
  *@return int 参数传递错误返回-1
  **/
 public function getLeafNodeCount($objRootNode){
  if($objRootNode instanceof BTNode){
   $intLeafNodeCount=0;
   $objNode=$objRootNode;
   $objStack=new StackLinked();
   do{
    if($objNode->mLchild == null && $objNode->mRchild == null){
     $intLeafNodeCount++;
    }
    $objRNode=$objNode->mRchild;
    if($objRNode != null){
     $objStack->getPushStack($objRNode);
    }
    $objNode=$objNode->mLchild;
    if($objNode == null){
     $objStack->getPopStack($objNode);
    }
   }while($objNode != null);
   return $intLeafNodeCount;
  }else{
   return -1;
  }
 }
 /**
  *求二叉树的深度
  *
  *@param BTNode $objRootNode 二叉树根节点
  *@return int 参数传递错误返回-1
  */
 public function getBinaryTreeDepth($objRootNode){
  if($objRootNode instanceof BTNode){
   $objNode=$objRootNode;
   $objQueue=new QueueLinked();
   $intBinaryTreeDepth=0;
   $objQueue->getInsertElem($objNode);
   $objLevel=$objNode;
   while(!$objQueue->getIsEmpty()){
    $objQueue->getDeleteElem($objNode);
    if($objNode->mLchild != null){
     $objQueue->getInsertElem($objNode->mLchild);
    }
    if($objNode->mRchild != null){
     $objQueue->getInsertElem($objNode->mRchild);
    }
    if($objLevel == $objNode){
     $intBinaryTreeDepth++;
     $objLevel=@$objQueue->mRear->mElem;
    }
   }
   return $intBinaryTreeDepth;
  }else{
   return -1;
  }
 }
}
echo "<pre>";
$bt=new BinaryTree(array('A','B','D','','','E','','G','','','C','F','','',''));
echo "二叉树结构：＼r＼n";
var_dump($bt);
$btarr=array();
echo "先序递归遍历二叉树：＼r＼n";
$bt->getPreorderTraversal($bt->mRoot,$btarr);
var_dump($btarr);
echo "先序非递归遍历二叉树：＼r＼n";
$arrBTdata=array();
$bt->getPreorderTraversalNoRecursion($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "中序递归遍历二叉树：＼r＼n";
$arrBTdata=array();
$bt->getInorderTraversal($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "中序非递归遍历二叉树：＼r＼n";
$arrBTdata=array();
$bt->getInorderTraversalNoRecursion($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "后序递归遍历二叉树：＼r＼n";
$arrBTdata=array();
$bt->getPostorderTraversal($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "后序非递归遍历二叉树:＼r＼n";
$arrBTdata=array();
$bt->getPostorderTraversalNoRecursion($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "按层次遍历二叉树：＼r＼n";
$arrBTdata=array();
$bt->getLevelorderTraversal($bt->mRoot,$arrBTdata);
var_dump($arrBTdata);
echo "叶子结点的个数为：".$bt->getLeafNodeCount($bt->mRoot);
echo "＼r＼n";
echo "二叉树深度为:".$bt->getBinaryTreeDepth($bt->mRoot);
echo "＼r＼n";
echo "判断二叉树是否为空：";
var_dump($bt->getIsEmpty());
echo "将二叉树置空后：";
$bt->setBinaryTreeNull();
var_dump($bt);
echo "</pre>";
?>

在栏目比较多的网站中，经常会用到无限分类，本文我们来分享一个用php递归实现的无限分类实例，实例的返回值可以选择是字符串还是数组，很实用。

在一些复杂的系统中，要求对信息栏目进行无限级的分类，以增强系统的灵活性。那么PHP是如何实现无限级分类的呢?我们在本文中使用递归算法并结合mysql数据表实现无限级分类。

递归，简单的说就是一段程序代码的重复调用，当把代码写到一个自定义函数中，将参数等变量保存，函数中重复调用函数，直到达到某个条件才跳出，返回相应的数据。

Mysql

首先我们准备一张数据表class，记录商品分类信息。表中有三个字段，id：分类编号，主键自增长;title：分类名称;pid：所属上级分类id。

class表结构：

CREATE TABLE IF NOT EXISTS `class` (
  `id` mediumint(6) NOT NULL AUTO_INCREMENT,
  `title` varchar(30) NOT NULL,
  `pid` mediumint(6) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8;

插入数据后，如图：

PHP

根据不同的需求，我们提供两种不同格式的自定义函数，一种是返回字符串，一种是返回数组，两种函数都使用了递归方法。先看返回字符串格式的函数：

function get_str($id = 0) {
    global $str;
    $sql = "select id,title from class where pid= $id"; 
    $result = mysql_query($sql);//查询pid的子类的分类
    if($result && mysql_affected_rows()){//如果有子类
        $str .= '<ul>';
        while ($row = mysql_fetch_array($result)) { //循环记录集
            $str .= "<li>" . $row['id'] . "--" . $row['title'] . "</li>"; //构建字符串
            get_str($row['id']); //调用get_str()，将记录集中的id参数传入函数中，继续查询下级
        }
        $str .= '</ul>';
    }
    return $str;
}

以上函数get_str()通过递归，不断查询下级分类，并最终返回字符串，大家可以根据项目需求修改其中的str，最终生成一个无限分级列表：

include_once('connect.php'); //连接数据库，connect.php文件自己写一个啊
echo get_str(0); //输出无限级分类

效果如：

接着我们来看返回数组格式的函数，一样要使用递归：

function get_array($id=0){
    $sql = "select id,title from class where pid= $id";
    $result = mysql_query($sql);//查询子类
    $arr = array();
    if($result && mysql_affected_rows()){//如果有子类
        while($rows=mysql_fetch_assoc($result)){ //循环记录集
            $rows['list'] = get_array($rows['id']); //调用函数，传入参数，继续查询下级
            $arr[] = $rows; //组合数组
        }
        return $arr;
    }
}

函数get_array()返回了数组，这是我们期待的，所以笔者推荐使用get_array()得到数组，这样一来，我们可以对数组进行任意操作，比如我们可以将数组转换成json格式的数据传给前端页面，前端页面可以通过解析json数据灵活展示分类信息。比如树形结构的分类列表，下拉分类列表等。

include_once('connect.php'); //连接数据库
$list = get_array(0); //调用函数
print_r($list); //输出数组

输出效果如：

如果要输出json格式的数据，则可使用：

echo json_encode($list);

比如飘易实际中用到的，把无限级分类放到 select 元素中：

//递归无限极 读取所有分组
$qian_i=0;
function get_group_str($id = 0) { 
    global $conn,$qian_i; 
    $sql = "select * from `group` where fid= $id";  
    $result = mysql_query($sql);//查询pid的子类的分类 
    if($result && mysql_affected_rows()){//如果有子类 
        $qian_i++;
        while ($row = mysql_fetch_array($result)) { //循环记录集 
$qian = str_repeat("＆ｎｂｓｐ；", ($qian_i-1)*6);
            $str .= "<option value='" . $row['id'] . "'>$qian" . $row['title'] . "</option>"; //构建字符串 
            $str .= get_group_str($row['id']); //递归调用函数本身，将记录集中的id参数传入函数中，继续查询下级 
        }
        $qian_i--;
    } 
    return $str; 
} 
$opt="<option value='0'>顶级分组</option>";
$opt.=get_group_str(0);

注意，实际使用中请将上面红色的全角空格代码转换成半角代码。

效果图：