PHP 哈夫曼的实现

<?php
namespace Test;

use Iterator;
use ArrayAccess;
use Exception;

// 叶子结点或者连接结点的基类
class HuffmanBase
{
    protected $weight;       // 权重
    protected $parent;

    public function setParent($parent)
    {
        $this->parent = $parent;
    }

    public function getWeight()
    {
        return $this->weight;
    }

    public function getParent()
    {
        return $this->parent;
    }
}

// 叶子结点
class HuffmanLeafNode extends HuffmanBase
{
    protected $code;   // 需要编码的字母

    public function __construct($weight,$code,$parent = null)
    {
        if(!is_int($weight) || $weight <= 0 || is_null($code))
        {
            throw new Exception('Param is error!' .__FILE__.__LINE__);
        }
        $this->weight = abs($weight);
        $this->code = $code;
        $this->parent = $parent;
    }

    public function getCode()
    {
        return $this->code;
    }
}

// 连接结点
class HuffmanJoinNode extends HuffmanBase
{
    protected $lChild;
    protected $rChild;

    public function __construct($weight = 0,$lChild = null,$rChild = null)
    {
        $this->weight = $weight;
        $this->rChild = $rChild;
        $this->lChild = $lChild;
    }

    public function setWeight($leftWeight,$rightWeight)
    {
        if(!is_int($this->rChild) || !is_int($this->lChild))
        {
            throw new \Exception("Please initialize the left child or the right child!\n");
        }
        $this->weight = $leftWeight + $rightWeight;
    }

    public function setChild($child,$leftOrRight)
    {
        if('left' == $leftOrRight)
        {
            $this->lChild = $child;
        }
        elseif('right' == $leftOrRight)
        {
            $this->rChild = $child;
        }
        else
        {
            throw new \Exception("Please input 'left' or 'right' to leftOrRight!\n");
        }
    }

    public function getChild($leftOrRight)
    {
        if('left' == $leftOrRight)
        {
            return $this->lChild;
        }
        elseif('right' == $leftOrRight)
        {
            return $this->rChild;
        }
        else
        {
            throw new \Exception("Please input 'left' or 'right' to leftOrRight!\n");
        }
    }
}

// 哈夫曼树
class HuffmanTree implements \ArrayAccess,\Iterator
{
    protected $nodes = array();

    public function &getAllNodes()
    {
        return $this->nodes;
    }

    public function offsetExists($offset)
    {
        // TODO: Implement offsetExists() method.
        return isset($this->nodes[$offset]);
    }

    public function offsetGet($offset)
    {
        // TODO: Implement offsetGet() method.
        if(isset($this->nodes[$offset]))
        {
            return $this->nodes[$offset];
        }
        else
        {
            return null;
        }
    }

    public function offsetSet($offset,$value)
    {
        // TODO: Implement offsetSet() method.
        if(!($value instanceof HuffmanBase))
        {
            throw new Exception('Param is error!' .__FILE__.__LINE__);
        }

        if(is_null($offset))
        {
            $this->nodes[] = $value;
        }
        else
        {
            $this->nodes[$offset] = $value;
        }
    }

    public function offsetUnset($offset)
    {
        // TODO: Implement offsetUnset() method.
        unset($this->nodes[$offset]);
    }

    public function current()
    {
        // TODO: Implement current() method.
        return current($this->nodes);
    }

    public function key()
    {
        // TODO: Implement key() method.
        return key($this->nodes);
    }

    public function next()
    {
        // TODO: Implement next() method.
        next($this->nodes);
    }

    public function rewind()
    {
        // TODO: Implement rewind() method.
        reset($this->nodes);
    }

    public function valid()
    {
        // TODO: Implement valid() method.
        return $this->offsetExists(key($this->nodes));
    }

    public function length()
    {
        return count($this->nodes);
    }
}

// 从[$left,$right]区间选择parent=0并且weight最小的两个结点，其序号分别为$minNode1,$minNode2;
function selectTwoMinWeightNode(HuffmanTree &$huffmanTree,$left,$right,&$minNode1,&$minNode2)
{
    $left = abs($left);
    $right = abs($right);

    if(!is_int($left) || !is_int($right) || $left == $right)
    {
        throw new Exception('Param is error!' .__FILE__.__LINE__);
    }

    if($left > $right)
    {
        $tmp = $left;
        $left = $right;
        $right = $tmp;
    }

    $nodes = $huffmanTree->getAllNodes();
    if(!isset($nodes[$right]))
    {
        throw new Exception('Over the array index!'.__FILE__.__LINE__);
    }

    $tmp = array();
    for($i = $left;$i <= $right; ++$i)
    {
        $huffmanNode = $huffmanTree[$i];
        if(!is_null($huffmanNode->getParent()))
        {
            continue;
        }
        $tmp[$i] = $huffmanNode->getWeight();
    }

    if(count($tmp) <= 1)
    {
        throw new Exception('Not enough number!'.__FILE__.__LINE__);
    }
    asort($tmp,SORT_NUMERIC);
    $t = array_keys($tmp);
    $minNode1 = $t[0];
    $minNode2 = $t[1];
}

// (编码 => 权重)
$nodes = array('A' => 3, 'B' => 4, 'C' => 7, 'D' => 10);

$huffmanTree = new HuffmanTree();

// 初始化哈夫曼树的叶子结点
foreach($nodes as $code => $weight)
{
    $huffmanNode = new HuffmanLeafNode($weight,$code);
    $huffmanTree[] = $huffmanNode;
}

$leafCount = $huffmanTree->length();        // 叶子结点的数量（大于1的值）
$nodeCount = 2 * $leafCount -1 ;           // 哈夫曼树结点的数量

// 初始化哈夫曼树的非叶子结点(如果编译器未优化，--$i应该是比$i++效率高点的)
for($i = $nodeCount - $leafCount;$i >= 1; --$i)
{
    $huffmanNode = new HuffmanJoinNode();
    $huffmanTree[] = $huffmanNode;
}

// 建立哈夫曼树
for($i = $leafCount;$i < $nodeCount; ++$i)
{
    selectTwoMinWeightNode($huffmanTree,0,$i-1,$minNode1,$minNode2);
    $huffmanNode1 = $huffmanTree[$minNode1];
    $huffmanNode2 = $huffmanTree[$minNode2];
    $huffmanNode1->setParent($i);
    $huffmanNode2->setParent($i);
    $huffmanTree[$i]->setChild($minNode1,'left');
    $huffmanTree[$i]->setChild($minNode2,'right');
    $huffmanTree[$i]->setWeight($huffmanNode1->getWeight(),$huffmanNode2->getWeight());
}

// 从叶子到根的遍历，得到字母的编码
$huffmanCode = array();
for($i = 0;$i < $leafCount; ++$i)
{
    $leafNode = $huffmanTree[$i];
    $code = $leafNode->getCode();
    $reverseCode = array();
    for($c = $i,$pi = $leafNode->getParent();!is_null($pi);$pi = $huffmanTree[$pi]->getParent())
    {
        $huffmanNode = $huffmanTree[$pi];
        if($huffmanNode->getChild('left') === $c)
        {
            $reverseCode[] = 0;
        }
        elseif($huffmanNode->getChild('right') === $c)
        {
            $reverseCode[] = 1;
        }
        else
        {
            throw new Exception('Something error happened!' .__FILE__.__LINE__);
        }
        $c = $pi;
    }
    $huffmanCode[$code] = array_reverse($reverseCode);
}

foreach($huffmanCode as $key => $value)
{
    $s = implode(',',$value);
    echo $key. " : " .$s ."\n";
}

运行结果：

 

运行环境：

ArrayAccess  ：(PHP 5 >= 5.0.0, PHP 7)