PHP实现图的邻接矩阵表示及几种简单遍历算法分析

本文实例讲述了php实现图的邻接矩阵表示及几种简单遍历算法。分享给大家供大家参考，具体如下：

在web开发中图这种数据结构的应用比树要少很多,但在一些业务中也常有出现,下面介绍几种图的寻径算法,并用php加以实现.

佛洛依德算法,主要是在顶点集内,按点与点相邻边的权重做遍历,如果两点不相连则权重无穷大,这样通过多次遍历可以得到点到点的最短路径,逻辑上最好理解,实现也较为简单,时间复杂度为o(n^3);

迪杰斯特拉算法,ospf中实现最短路由所用到的经典算法,djisktra算法的本质是贪心算法,不断的遍历扩充顶点路径集合s,一旦发现更短的点到点路径就替换s中原有的最短路径,完成所有遍历后s便是所有顶点的最短路径集合了.迪杰斯特拉算法的时间复杂度为o(n^2);

克鲁斯卡尔算法,在图内构造最小生成树,达到图中所有顶点联通.从而得到最短路径.时间复杂度为o(n*logn);

<?php
/**
 * php 实现图邻接矩阵
 */
class mgraph{
  private $vexs; //顶点数组
  private $arc; //边邻接矩阵,即二维数组
  private $arcdata; //边的数组信息
  private $direct; //图的类型(无向或有向)
  private $haslist; //尝试遍历时存储遍历过的结点
  private $queue; //广度优先遍历时存储孩子结点的队列,用数组模仿
  private $infinity = 65535;//代表无穷,即两点无连接,建带权值的图时用,本示例不带权值
  private $primvexs; //prim算法时保存顶点
  private $primarc; //prim算法时保存边
  private $krus;//kruscal算法时保存边的信息
  public function mgraph($vexs, $arc, $direct = 0){
    $this->vexs = $vexs;
    $this->arcdata = $arc;
    $this->direct = $direct;
    $this->initalizearc();
    $this->createarc();
  }
  private function initalizearc(){
    foreach($this->vexs as $value){
      foreach($this->vexs as $cvalue){
        $this->arc[$value][$cvalue] = ($value == $cvalue ? 0 : $this->infinity);
      }
    }
  }
  //创建图 $direct:0表示无向图,1表示有向图
  private function createarc(){
    foreach($this->arcdata as $key=>$value){
      $strarr = str_split($key);
      $first = $strarr[0];
      $last = $strarr[1];
      $this->arc[$first][$last] = $value;
      if(!$this->direct){
        $this->arc[$last][$first] = $value;
      }
    }
  }
  //floyd算法
  public function floyd(){
    $path = array();//路径数组
    $distance = array();//距离数组
    foreach($this->arc as $key=>$value){
      foreach($value as $k=>$v){
        $path[$key][$k] = $k;
        $distance[$key][$k] = $v;
      }
    }
    for($j = 0; $j < count($this->vexs); $j ++){
      for($i = 0; $i < count($this->vexs); $i ++){
        for($k = 0; $k < count($this->vexs); $k ++){
          if($distance[$this->vexs[$i]][$this->vexs[$k]] > $distance[$this->vexs[$i]][$this->vexs[$j]] + $distance[$this->vexs[$j]][$this->vexs[$k]]){
            $path[$this->vexs[$i]][$this->vexs[$k]] = $path[$this->vexs[$i]][$this->vexs[$j]];
            $distance[$this->vexs[$i]][$this->vexs[$k]] = $distance[$this->vexs[$i]][$this->vexs[$j]] + $distance[$this->vexs[$j]][$this->vexs[$k]];
          }
        }
      }
    }
    return array($path, $distance);
  }
  //djikstra算法
  public function dijkstra(){
    $final = array();
    $pre = array();//要查找的结点的前一个结点数组
    $weight = array();//权值和数组
    foreach($this->arc[$this->vexs[0]] as $k=>$v){
      $final[$k] = 0;
      $pre[$k] = $this->vexs[0];
      $weight[$k] = $v;
    }
    $final[$this->vexs[0]] = 1;
    for($i = 0; $i < count($this->vexs); $i ++){
      $key = 0;
      $min = $this->infinity;
      for($j = 1; $j < count($this->vexs); $j ++){
        $temp = $this->vexs[$j];
        if($final[$temp] != 1 && $weight[$temp] < $min){
          $key = $temp;
          $min = $weight[$temp];
        }
      }
      $final[$key] = 1;
      for($j = 0; $j < count($this->vexs); $j ++){
        $temp = $this->vexs[$j];
        if($final[$temp] != 1 && ($min + $this->arc[$key][$temp]) < $weight[$temp]){
          $pre[$temp] = $key;
          $weight[$temp] = $min + $this->arc[$key][$temp];
        }
      }
    }
    return $pre;
  }
  //kruscal算法
  private function kruscal(){
    $this->krus = array();
    foreach($this->vexs as $value){
      $krus[$value] = 0;
    }
    foreach($this->arc as $key=>$value){
      $begin = $this->findroot($key);
      foreach($value as $k=>$v){
        $end = $this->findroot($k);
        if($begin != $end){
          $this->krus[$begin] = $end;
        }
      }
    }
  }
  //查找子树的尾结点
  private function findroot($node){
    while($this->krus[$node] > 0){
      $node = $this->krus[$node];
    }
    return $node;
  }
  //prim算法,生成最小生成树
  public function prim(){
    $this->primvexs = array();
    $this->primarc = array($this->vexs[0]=>0);
    for($i = 1; $i < count($this->vexs); $i ++){
      $this->primarc[$this->vexs[$i]] = $this->arc[$this->vexs[0]][$this->vexs[$i]];
      $this->primvexs[$this->vexs[$i]] = $this->vexs[0];
    }
    for($i = 0; $i < count($this->vexs); $i ++){
      $min = $this->infinity;
      $key;
      foreach($this->vexs as $k=>$v){
        if($this->primarc[$v] != 0 && $this->primarc[$v] < $min){
          $key = $v;
          $min = $this->primarc[$v];
        }
      }
      $this->primarc[$key] = 0;
      foreach($this->arc[$key] as $k=>$v){
        if($this->primarc[$k] != 0 && $v < $this->primarc[$k]){
          $this->primarc[$k] = $v;
          $this->primvexs[$k] = $key;
        }
      }
    }
    return $this->primvexs;
  }
  //一般算法,生成最小生成树
  public function bst(){
    $this->primvexs = array($this->vexs[0]);
    $this->primarc = array();
    next($this->arc[key($this->arc)]);
    $key = null;
    $current = null;
    while(count($this->primvexs) < count($this->vexs)){
      foreach($this->primvexs as $value){
        foreach($this->arc[$value] as $k=>$v){
          if(!in_array($k, $this->primvexs) && $v != 0 && $v != $this->infinity){
            if($key == null || $v < current($current)){
              $key = $k;
              $current = array($value . $k=>$v);
            }
          }
        }
      }
      $this->primvexs[] = $key;
      $this->primarc[key($current)] = current($current);
      $key = null;
      $current = null;
    }
    return array('vexs'=>$this->primvexs, 'arc'=>$this->primarc);
  }
  //一般遍历
  public function reserve(){
    $this->haslist = array();
    foreach($this->arc as $key=>$value){
      if(!in_array($key, $this->haslist)){
        $this->haslist[] = $key;
      }
      foreach($value as $k=>$v){
        if($v == 1 && !in_array($k, $this->haslist)){
          $this->haslist[] = $k;
        }
      }
    }
    foreach($this->vexs as $v){
      if(!in_array($v, $this->haslist))
        $this->haslist[] = $v;
    }
    return implode($this->haslist);
  }
  //广度优先遍历
  public function bfs(){
    $this->haslist = array();
    $this->queue = array();
    foreach($this->arc as $key=>$value){
      if(!in_array($key, $this->haslist)){
        $this->haslist[] = $key;
        $this->queue[] = $value;
        while(!empty($this->queue)){
          $child = array_shift($this->queue);
          foreach($child as $k=>$v){
            if($v == 1 && !in_array($k, $this->haslist)){
              $this->haslist[] = $k;
              $this->queue[] = $this->arc[$k];
            }
          }
        }
      }
    }
    return implode($this->haslist);
  }
  //执行深度优先遍历
  public function excutedfs($key){
    $this->haslist[] = $key;
    foreach($this->arc[$key] as $k=>$v){
      if($v == 1 && !in_array($k, $this->haslist))
        $this->excutedfs($k);
    }
  }
  //深度优先遍历
  public function dfs(){
    $this->haslist = array();
    foreach($this->vexs as $key){
      if(!in_array($key, $this->haslist))
        $this->excutedfs($key);
    }
    return implode($this->haslist);
  }
  //返回图的二维数组表示
  public function getarc(){
    return $this->arc;
  }
  //返回结点个数
  public function getvexcount(){
    return count($this->vexs);
  }
}
$a = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i');
$b = array('ab'=>'10', 'af'=>'11', 'bg'=>'16', 'fg'=>'17', 'bc'=>'18', 'bi'=>'12', 'ci'=>'8', 'cd'=>'22', 'di'=>'21', 'dg'=>'24', 'gh'=>'19', 'dh'=>'16', 'de'=>'20', 'eh'=>'7','fe'=>'26');//键为边,值权值
$test = new mgraph($a, $b);
print_r($test->bst());

运行结果：

array
(
  [vexs] => array
    (
      [0] => a
      [1] => b
      [2] => f
      [3] => i
      [4] => c
      [5] => g
      [6] => h
      [7] => e
      [8] => d
    )
  [arc] => array
    (
      [ab] => 10
      [af] => 11
      [bi] => 12
      [ic] => 8
      [bg] => 16
      [gh] => 19
      [he] => 7
      [hd] => 16
    )
)

更多关于php相关内容感兴趣的读者可查看本站专题：《php数据结构与算法教程》、《php程序设计算法总结》、《php字符串(string)用法总结》、《php数组(array)操作技巧大全》、《php常用遍历算法与技巧总结》及《php数学运算技巧总结》

希望本文所述对大家php程序设计有所帮助。