邻接表有向图(一)之 C语言详解

最新推荐文章于 2024-07-03 11:57:05 发布
最新推荐文章于 2024-07-03 11:57:05 发布
阅读量1.1w 收藏 53
点赞数 4

出自：http://www.cnblogs.com/skywang12345/p/3707621.html

邻接表有向图(一)之 C语言详解

本章介绍邻接表有向图。在"图的理论基础"中已经对图进行了理论介绍，这里就不再对图的概念进行重复说明了。和以往一样，本文会先给出C语言的实现；后续再分别给出C++和Java版本的实现。实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！

目录 
1. 邻接表有向图的介绍 
2. 邻接表有向图的代码说明 
3. 邻接表有向图的完整源码

转载请注明出处：http://www.cnblogs.com/skywang12345/

更多内容：数据结构与算法系列 目录

邻接表有向图的介绍

邻接表有向图是指通过邻接表表示的有向图。

上面的图G2包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了"<A,B>,<B,C>,<B,E>,<B,F>,<C,E>,<D,C>,<E,B>,<E,D>,<F,G>"共9条边。

上图右边的矩阵是G2在内存中的邻接表示意图。每一个顶点都包含一条链表，该链表记录了"该顶点所对应的出边的另一个顶点的序号"。例如，第1个顶点(顶点B)包含的链表所包含的节点的数据分别是"2,4,5"；而这"2,4,5"分别对应"C,E,F"的序号，"C,E,F"都属于B的出边的另一个顶点。

邻接表有向图的代码说明

1. 基本定义

复制代码 
// 邻接表中表对应的链表的顶点
typedef struct _ENode
{
    int ivex;                   // 该边所指向的顶点的位置
    struct _ENode *next_edge;   // 指向下一条弧的指针
}ENode, *PENode;

// 邻接表中表的顶点
typedef struct _VNode
{
    char data;              // 顶点信息
    ENode *first_edge;      // 指向第一条依附该顶点的弧
}VNode;

// 邻接表
typedef struct _LGraph
{
    int vexnum;             // 图的顶点的数目
    int edgnum;             // 图的边的数目
    VNode vexs[MAX];
}LGraph;
复制代码

(01) LGraph是邻接表对应的结构体。 vexnum是顶点数，edgnum是边数；vexs则是保存顶点信息的一维数组。 
(02) VNode是邻接表顶点对应的结构体。 data是顶点所包含的数据，而firstedge是该顶点所包含链表的表头指针。 
(03) ENode是邻接表顶点所包含的链表的节点对应的结构体。 ivex是该节点所对应的顶点在vexs中的索引，而nextedge是指向下一个节点的。

2. 创建矩阵

这里介绍提供了两个创建矩阵的方法。一个是用已知数据，另一个则需要用户手动输入数据。

2.1 创建图(用已提供的矩阵)

复制代码 
/*
 * 创建邻接表对应的图(用已提供的数据)
 */
LGraph* create_example_lgraph()
{
    char c1, c2;
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    char edges[][2] = {
        {'A', 'B'}, 
        {'B', 'C'}, 
        {'B', 'E'}, 
        {'B', 'F'}, 
        {'C', 'E'}, 
        {'D', 'C'}, 
        {'E', 'B'}, 
        {'E', 'D'}, 
        {'F', 'G'}}; 
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    int i, p1, p2;
    ENode *node1, *node2;
    LGraph* pG;


    if ((pG=(LGraph*)malloc(sizeof(LGraph))) == NULL )
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = vlen;
    pG->edgnum = elen;
    // 初始化"邻接表"的顶点
    for(i=0; i<pG->vexnum; i++)
    {
        pG->vexs[i].data = vexs[i];
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for(i=0; i<pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = edges[i][0];
        c2 = edges[i][1];

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);
        // 初始化node1
        node1 = (ENode*)malloc(sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if(pG->vexs[p1].first_edge == NULL)
          pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
    }

    return pG;
}
复制代码

该函数的作用是创建一个邻接表有向图。实际上，该方法创建的有向图，就是上面的图G2。

2.2 创建图(自己输入)

复制代码 
/*
 * 创建邻接表对应的图(自己输入)
 */
LGraph* create_lgraph()
{
    char c1, c2;
    int v, e;
    int i, p1, p2;
    ENode *node1, *node2;
    LGraph* pG;

    // 输入"顶点数"和"边数"
    printf("input vertex number: ");
    scanf("%d", &v);
    printf("input edge number: ");
    scanf("%d", &e);
    if ( v < 1 || e < 1 || (e > (v * (v-1))))
    {
        printf("input error: invalid parameters!\n");
        return NULL;
    }

    if ((pG=(LGraph*)malloc(sizeof(LGraph))) == NULL )
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = v;
    pG->edgnum = e;
    // 初始化"邻接表"的顶点
    for(i=0; i<pG->vexnum; i++)
    {
        printf("vertex(%d): ", i);
        pG->vexs[i].data = read_char();
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for(i=0; i<pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        printf("edge(%d): ", i);
        c1 = read_char();
        c2 = read_char();

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);
        // 初始化node1
        node1 = (ENode*)malloc(sizeof(ENode));
        node1->ivex             = p2;
        // 将node1链接到"p1所在链表的末尾"
        if(pG->vexs[p1].first_edge == NULL)
          pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
    }

    return pG;
}
复制代码

create_lgraph()是读取用户的输入，将输入的数据转换成对应的有向图。

邻接表有向图的完整源码

点击查看：源代码

 
 

  
  /**
 
 

 
 

  
   * C: 邻接表表示的"有向图(List Directed Graph)"
 
 

 
 

  
   *
 
 

 
 

  
   * @author skywang
 
 

 
 

  
   * @date 2014/04/18
 
 

 
 

  
   */
 
 

 
 

  
  

 
 

 
 

  
  #include <stdio.h>
 
 

 
 

  
  #include <stdlib.h>
 
 

 
 

  
  #include <malloc.h>
 
 

 
 

  
  #include <string.h>
 
 

 
 

  
  

 
 

 
 

  
  #define MAX 100
 
 

 
 

  
  #define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
 
 

 
 

  
  #define LENGTH(a)  (sizeof(a)/sizeof(a[0]))
 
 

 
 

  
  

 
 

 
 

  
  // 邻接表中表对应的链表的顶点
 
 

 
 

  
  typedef 
  
  struct 
  
  _ENode
 
 

 
 

  
  {
 
 

 
 

  
      
  
  int 
  
  ivex
  
  ;                   
  
  // 该边所指向的顶点的位置
 
 

 
 

  
      
  
  struct 
  
  _ENode 
  
  *
  
  next_edge
  
  ;   
  
  // 指向下一条弧的指针
 
 

 
 

  
  }
  
  ENode
  
  , 
  
  *
  
  PENode
  
  ;
 
 

 
 

  
  

 
 

 
 

  
  // 邻接表中表的顶点
 
 

 
 

  
  typedef 
  
  struct 
  
  _VNode
 
 

 
 

  
  {
 
 

 
 

  
      
  
  char 
  
  data
  
  ;              
  
  // 顶点信息
 
 

 
 

  
      
  
  ENode 
  
  *
  
  first_edge
  
  ;      
  
  // 指向第一条依附该顶点的弧
 
 

 
 

  
  }
  
  VNode
  
  ;
 
 

 
 

  
  

 
 

 
 

  
  // 邻接表
 
 

 
 

  
  typedef 
  
  struct 
  
  _LGraph
 
 

 
 

  
  {
 
 

 
 

  
      
  
  int 
  
  vexnum
  
  ;             
  
  // 图的顶点的数目
 
 

 
 

  
      
  
  int 
  
  edgnum
  
  ;             
  
  // 图的边的数目
 
 

 
 

  
      
  
  VNode 
  
  vexs
  
  [
  
  MAX
  
  ];
 
 

 
 

  
  }
  
  LGraph
  
  ;
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 返回ch在matrix矩阵中的位置
 
 

 
 

  
   */
 
 

 
 

  
  static 
  
  int 
  
  get_position
  
  (
  
  LGraph 
  
  g
  
  , 
  
  char 
  
  ch
  
  )
 
 

 
 

  
  {
 
 

 
 

  
      
  
  int 
  
  i
  
  ;
 
 

 
 

  
      
  
  for
  
  (
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  g
  
  .
  
  vexnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
          
  
  if
  
  (
  
  g
  
  .
  
  vexs
  
  [
  
  i
  
  ].
  
  data
  
  ==
  
  ch
  
  )
 
 

 
 

  
              
  
  return 
  
  i
  
  ;
 
 

 
 

  
      
  
  return 
  
  -
  
  1
  
  ;
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 读取一个输入字符
 
 

 
 

  
   */
 
 

 
 

  
  static 
  
  char 
  
  read_char
  
  ()
 
 

 
 

  
  {
 
 

 
 

  
      
  
  char 
  
  ch
  
  ;
 
 

 
 

  
  

 
 

 
 

  
      
  
  do 
  
  {
 
 

 
 

  
          
  
  ch 
  
  = 
  
  getchar
  
  ();
 
 

 
 

  
      
  
  } 
  
  while
  
  (
  
  !
  
  isLetter
  
  (
  
  ch
  
  ));
 
 

 
 

  
  

 
 

 
 

  
      
  
  return 
  
  ch
  
  ;
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 将node链接到list的末尾
 
 

 
 

  
   */
 
 

 
 

  
  static 
  
  void 
  
  link_last
  
  (
  
  ENode 
  
  *
  
  list
  
  , 
  
  ENode 
  
  *
  
  node
  
  )
 
 

 
 

  
  {
 
 

 
 

  
      
  
  ENode 
  
  *
  
  p 
  
  = 
  
  list
  
  ;
 
 

 
 

  
  

 
 

 
 

  
      
  
  while
  
  (
  
  p
  
  ->
  
  next_edge
  
  )
 
 

 
 

  
          
  
  p 
  
  = 
  
  p
  
  ->
  
  next_edge
  
  ;
 
 

 
 

  
      
  
  p
  
  ->
  
  next_edge 
  
  = 
  
  node
  
  ;
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 创建邻接表对应的图(自己输入)
 
 

 
 

  
   */
 
 

 
 

  
  LGraph
  
  * 
  
  create_lgraph
  
  ()
 
 

 
 

  
  {
 
 

 
 

  
      
  
  char 
  
  c1
  
  , 
  
  c2
  
  ;
 
 

 
 

  
      
  
  int 
  
  v
  
  , 
  
  e
  
  ;
 
 

 
 

  
      
  
  int 
  
  i
  
  , 
  
  p1
  
  , 
  
  p2
  
  ;
 
 

 
 

  
      
  
  ENode 
  
  *
  
  node1
  
  , 
  
  *
  
  node2
  
  ;
 
 

 
 

  
      
  
  LGraph
  
  * 
  
  pG
  
  ;
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 输入"顶点数"和"边数"
 
 

 
 

  
      
  
  printf
  
  (
  
  "input vertex number: "
  
  );
 
 

 
 

  
      
  
  scanf
  
  (
  
  "%d"
  
  , 
  
  &
  
  v
  
  );
 
 

 
 

  
      
  
  printf
  
  (
  
  "input edge number: "
  
  );
 
 

 
 

  
      
  
  scanf
  
  (
  
  "%d"
  
  , 
  
  &
  
  e
  
  );
 
 

 
 

  
      
  
  if 
  
  ( 
  
  v 
  
  < 
  
  1 
  
  || 
  
  e 
  
  < 
  
  1 
  
  || 
  
  (
  
  e 
  
  > 
  
  (
  
  v 
  
  * 
  
  (
  
  v
  
  -
  
  1
  
  ))))
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  printf
  
  (
  
  "input error: invalid parameters!
  
  \n
  
  "
  
  );
 
 

 
 

  
          
  
  return 
  
  NULL
  
  ;
 
 

 
 

  
      
  
  }
 
 

 
 

  
   
 
 

 
 

  
      
  
  if 
  
  ((
  
  pG
  
  =
  
  (
  
  LGraph
  
  *
  
  )
  
  malloc
  
  (
  
  sizeof
  
  (
  
  LGraph
  
  ))) 
  
  == 
  
  NULL 
  
  )
 
 

 
 

  
          
  
  return 
  
  NULL
  
  ;
 
 

 
 

  
      
  
  memset
  
  (
  
  pG
  
  , 
  
  0
  
  , 
  
  sizeof
  
  (
  
  LGraph
  
  ));
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 初始化"顶点数"和"边数"
 
 

 
 

  
      
  
  pG
  
  ->
  
  vexnum 
  
  = 
  
  v
  
  ;
 
 

 
 

  
      
  
  pG
  
  ->
  
  edgnum 
  
  = 
  
  e
  
  ;
 
 

 
 

  
      
  
  // 初始化"邻接表"的顶点
 
 

 
 

  
      
  
  for
  
  (
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  pG
  
  ->
  
  vexnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  printf
  
  (
  
  "vertex(%d): "
  
  , 
  
  i
  
  );
 
 

 
 

  
          
  
  pG
  
  ->
  
  vexs
  
  [
  
  i
  
  ].
  
  data 
  
  = 
  
  read_char
  
  ();
 
 

 
 

  
          
  
  pG
  
  ->
  
  vexs
  
  [
  
  i
  
  ].
  
  first_edge 
  
  = 
  
  NULL
  
  ;
 
 

 
 

  
      
  
  }
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 初始化"邻接表"的边
 
 

 
 

  
      
  
  for
  
  (
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  pG
  
  ->
  
  edgnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  // 读取边的起始顶点和结束顶点
 
 

 
 

  
          
  
  printf
  
  (
  
  "edge(%d): "
  
  , 
  
  i
  
  );
 
 

 
 

  
          
  
  c1 
  
  = 
  
  read_char
  
  ();
 
 

 
 

  
          
  
  c2 
  
  = 
  
  read_char
  
  ();
 
 

 
 

  
  

 
 

 
 

  
          
  
  p1 
  
  = 
  
  get_position
  
  (
  
  *
  
  pG
  
  , 
  
  c1
  
  );
 
 

 
 

  
          
  
  p2 
  
  = 
  
  get_position
  
  (
  
  *
  
  pG
  
  , 
  
  c2
  
  );
 
 

 
 

  
          
  
  // 初始化node1
 
 

 
 

  
          
  
  node1 
  
  = 
  
  (
  
  ENode
  
  *
  
  )
  
  malloc
  
  (
  
  sizeof
  
  (
  
  ENode
  
  ));
 
 

 
 

  
          
  
  node1
  
  ->
  
  ivex             
  
  = 
  
  p2
  
  ;
 
 

 
 

  
          
  
  // 将node1链接到"p1所在链表的末尾"
 
 

 
 

  
          
  
  if
  
  (
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge 
  
  == 
  
  NULL
  
  )
 
 

 
 

  
            
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge 
  
  = 
  
  node1
  
  ;
 
 

 
 

  
          
  
  else
 
 

 
 

  
              
  
  link_last
  
  (
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge
  
  , 
  
  node1
  
  );
 
 

 
 

  
      
  
  }
 
 

 
 

  
  

 
 

 
 

  
      
  
  return 
  
  pG
  
  ;
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 创建邻接表对应的图(用已提供的数据)
 
 

 
 

  
   */
 
 

 
 

  
  LGraph
  
  * 
  
  create_example_lgraph
  
  ()
 
 

 
 

  
  {
 
 

 
 

  
      
  
  char 
  
  c1
  
  , 
  
  c2
  
  ;
 
 

 
 

  
      
  
  char 
  
  vexs
  
  [] 
  
  = 
  
  {
  
  'A'
  
  , 
  
  'B'
  
  , 
  
  'C'
  
  , 
  
  'D'
  
  , 
  
  'E'
  
  , 
  
  'F'
  
  , 
  
  'G'
  
  };
 
 

 
 

  
      
  
  char 
  
  edges
  
  [][
  
  2
  
  ] 
  
  = 
  
  {
 
 

 
 

  
          
  
  {
  
  'A'
  
  , 
  
  'B'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'B'
  
  , 
  
  'C'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'B'
  
  , 
  
  'E'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'B'
  
  , 
  
  'F'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'C'
  
  , 
  
  'E'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'D'
  
  , 
  
  'C'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'E'
  
  , 
  
  'B'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'E'
  
  , 
  
  'D'
  
  }, 
 
 

 
 

  
          
  
  {
  
  'F'
  
  , 
  
  'G'
  
  }}; 
 
 

 
 

  
      
  
  int 
  
  vlen 
  
  = 
  
  LENGTH
  
  (
  
  vexs
  
  );
 
 

 
 

  
      
  
  int 
  
  elen 
  
  = 
  
  LENGTH
  
  (
  
  edges
  
  );
 
 

 
 

  
      
  
  int 
  
  i
  
  , 
  
  p1
  
  , 
  
  p2
  
  ;
 
 

 
 

  
      
  
  ENode 
  
  *
  
  node1
  
  , 
  
  *
  
  node2
  
  ;
 
 

 
 

  
      
  
  LGraph
  
  * 
  
  pG
  
  ;
 
 

 
 

  
  

 
 

 
 

  
  

 
 

 
 

  
      
  
  if 
  
  ((
  
  pG
  
  =
  
  (
  
  LGraph
  
  *
  
  )
  
  malloc
  
  (
  
  sizeof
  
  (
  
  LGraph
  
  ))) 
  
  == 
  
  NULL 
  
  )
 
 

 
 

  
          
  
  return 
  
  NULL
  
  ;
 
 

 
 

  
      
  
  memset
  
  (
  
  pG
  
  , 
  
  0
  
  , 
  
  sizeof
  
  (
  
  LGraph
  
  ));
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 初始化"顶点数"和"边数"
 
 

 
 

  
      
  
  pG
  
  ->
  
  vexnum 
  
  = 
  
  vlen
  
  ;
 
 

 
 

  
      
  
  pG
  
  ->
  
  edgnum 
  
  = 
  
  elen
  
  ;
 
 

 
 

  
      
  
  // 初始化"邻接表"的顶点
 
 

 
 

  
      
  
  for
  
  (
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  pG
  
  ->
  
  vexnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  pG
  
  ->
  
  vexs
  
  [
  
  i
  
  ].
  
  data 
  
  = 
  
  vexs
  
  [
  
  i
  
  ];
 
 

 
 

  
          
  
  pG
  
  ->
  
  vexs
  
  [
  
  i
  
  ].
  
  first_edge 
  
  = 
  
  NULL
  
  ;
 
 

 
 

  
      
  
  }
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 初始化"邻接表"的边
 
 

 
 

  
      
  
  for
  
  (
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  pG
  
  ->
  
  edgnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  // 读取边的起始顶点和结束顶点
 
 

 
 

  
          
  
  c1 
  
  = 
  
  edges
  
  [
  
  i
  
  ][
  
  0
  
  ];
 
 

 
 

  
          
  
  c2 
  
  = 
  
  edges
  
  [
  
  i
  
  ][
  
  1
  
  ];
 
 

 
 

  
  

 
 

 
 

  
          
  
  p1 
  
  = 
  
  get_position
  
  (
  
  *
  
  pG
  
  , 
  
  c1
  
  );
 
 

 
 

  
          
  
  p2 
  
  = 
  
  get_position
  
  (
  
  *
  
  pG
  
  , 
  
  c2
  
  );
 
 

 
 

  
          
  
  // 初始化node1
 
 

 
 

  
          
  
  node1 
  
  = 
  
  (
  
  ENode
  
  *
  
  )
  
  malloc
  
  (
  
  sizeof
  
  (
  
  ENode
  
  ));
 
 

 
 

  
          
  
  node1
  
  ->
  
  ivex 
  
  = 
  
  p2
  
  ;
 
 

 
 

  
          
  
  // 将node1链接到"p1所在链表的末尾"
 
 

 
 

  
          
  
  if
  
  (
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge 
  
  == 
  
  NULL
  
  )
 
 

 
 

  
            
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge 
  
  = 
  
  node1
  
  ;
 
 

 
 

  
          
  
  else
 
 

 
 

  
              
  
  link_last
  
  (
  
  pG
  
  ->
  
  vexs
  
  [
  
  p1
  
  ].
  
  first_edge
  
  , 
  
  node1
  
  );
 
 

 
 

  
      
  
  }
 
 

 
 

  
  

 
 

 
 

  
      
  
  return 
  
  pG
  
  ;
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  /*
 
 

 
 

  
   * 打印邻接表图
 
 

 
 

  
   */
 
 

 
 

  
  void 
  
  print_lgraph
  
  (
  
  LGraph 
  
  G
  
  )
 
 

 
 

  
  {
 
 

 
 

  
      
  
  int 
  
  i
  
  ,
  
  j
  
  ;
 
 

 
 

  
      
  
  ENode 
  
  *
  
  node
  
  ;
 
 

 
 

  
  

 
 

 
 

  
      
  
  printf
  
  (
  
  "List Graph:
  
  \n
  
  "
  
  );
 
 

 
 

  
      
  
  for 
  
  (
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  < 
  
  G
  
  .
  
  vexnum
  
  ; 
  
  i
  
  ++
  
  )
 
 

 
 

  
      
  
  {
 
 

 
 

  
          
  
  printf
  
  (
  
  "%d(%c): "
  
  , 
  
  i
  
  , 
  
  G
  
  .
  
  vexs
  
  [
  
  i
  
  ].
  
  data
  
  );
 
 

 
 

  
          
  
  node 
  
  = 
  
  G
  
  .
  
  vexs
  
  [
  
  i
  
  ].
  
  first_edge
  
  ;
 
 

 
 

  
          
  
  while 
  
  (
  
  node 
  
  != 
  
  NULL
  
  )
 
 

 
 

  
          
  
  {
 
 

 
 

  
              
  
  printf
  
  (
  
  "%d(%c) "
  
  , 
  
  node
  
  ->
  
  ivex
  
  , 
  
  G
  
  .
  
  vexs
  
  [
  
  node
  
  ->
  
  ivex
  
  ].
  
  data
  
  );
 
 

 
 

  
              
  
  node 
  
  = 
  
  node
  
  ->
  
  next_edge
  
  ;
 
 

 
 

  
          
  
  }
 
 

 
 

  
          
  
  printf
  
  (
  
  "
  
  \n
  
  "
  
  );
 
 

 
 

  
      
  
  }
 
 

 
 

  
  }
 
 

 
 

  
  

 
 

 
 

  
  void 
  
  main
  
  ()
 
 

 
 

  
  {
 
 

 
 

  
      
  
  LGraph
  
  * 
  
  pG
  
  ;
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 自定义"图"(自己输入数据)
 
 

 
 

  
      
  
  //pG = create_lgraph();
 
 

 
 

  
      
  
  // 采用已有的"图"
 
 

 
 

  
      
  
  pG 
  
  = 
  
  create_example_lgraph
  
  ();
 
 

 
 

  
  

 
 

 
 

  
      
  
  // 打印图
 
 

 
 

  
      
  
  print_lgraph
  
  (
  
  *
  
  pG
  
  );
 
 

 
 

  
  }

xiedeacc
关注
  • 4
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
有向图的邻接表(C语言)
06-17
c语言写的有向图的邻接表的实现，通过使用图的邻接表实现图的存储结构存储。
邻接表存储的有向图的基本操作(C语言实现)
Touch的博客
06-06 2865
/* * 邻接表存储的有向图的基本操作 */ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MAX_VERTEX 20 typedef char VertexType; //用数组vertex按序存放遍历的各个顶点，广度遍历时看成队列，深度遍历时看成栈 VertexType vertex[MAX_VER...
C++_使用邻接表(链表-指针)实现有向图[完整示例及解释]
book_dw5189的博客
05-05 877
// newNode->next = nodes[sourceIndex].head;将新节点 newNode 的 next 指针指向了源节点的邻接表的头部。这样，新节点就被插入到了邻接表的头部位置。
c++ 实现邻接表有向图结构
qq_41816368的博客
07-06 1098
建立头文件#ifndef ALGraph_h #define ALGraph_h const int MaxSize = 20; struct ArcNode{ //邻接结点 int adjvex; ArcNode *next; }; template &lt;class DataType&gt; struct VertexNode{ //头结点 Da...
数据结构与算法（C语言实现） 6.图的综合应用（邻接表有向图）
CaptainUniverse_的博客
05-16 1259
数据结构与算法（C语言实现） 实验六：图的综合应用（邻接表有向图）
图之邻接表详解（C语言版）.rar
04-25
对于无向图，添加边时需要同时在两个顶点的邻接表中插入对方。此外，邻接表还可以与其他数据结构结合，如 Fibonacci heap（斐波那契堆）用于求最短路径，或者并查集（Disjoint Set）用于判断连通性。 总之，邻接表...
C语言数据结构之图的遍历实例详解
08-30
"C语言数据结构之图的遍历实例详解" 本文主要介绍了C语言数据结构之图的遍历实例详解的相关知识点，包括图的遍历算法、图的存储结构、图的遍历实现等。 一、图的遍历算法 图的遍历算法是指从图的一点出发，遍历图...
图的邻接表存储C语言实现
01-06
为了有效地存储和处理图结构，我们通常采用多种存储方式，其中邻接表是用于无向图和有向图的一种高效存储方法。 #### 邻接表的定义与特性 邻接表通过将每个顶点关联到一个链表来存储图，这个链表包含了与该顶点...
c语言图结构邻接表
01-14
对于一个无向图或有向图，邻接表通过一系列链表来表示图中的顶点及其连接的边。每个顶点都对应着一个链表，链表中的节点（称为边节点）存储了与该顶点相连的所有邻接顶点的信息。这种方式特别适用于稀疏图（即边的...
C语言单向链表的表示与实现实例详解
09-04
相对于双向链表，这种普通的，每个节点只有一个指针的链表也叫单向链表，或者单链表，通常用在每次都只会按顺序遍历这个链表的时候（例如图的邻接表，通常都是按固定顺序访问的）。 在C语言中，单向链表的实现可以...
数据结构-图基本操作代码.doc
07-11
实验五 图 //图的邻接矩阵存储 #include "stdio.h" #include "stdlib.h" typedef struct { int adj; }AdjMatrix[10][10]; typedef struct { int vexs[10]; AdjMatrix arcs; int vexnum,arcnum; }MGraph; int LocateVex(MGraph &G,int v) { int k,j=0; for(k=0;k<G.vexnum;k++) if(G.vexs[k]==v) { j=k; break; } return j; } void Create(MGraph &G) { int i,j,k; int v1=0,v2=0,w=0; printf("请输入图的顶点数:"); scanf("%d",&G.vexnum); printf("请输入图的边数:"); scanf("%d",&G.arcnum); //printf("请输入图的顶点:"); for(i=0;i<G.vexnum;i++) G.vexs[i]=i+1; for(i=0
使用邻接表来完成有向图的存储
weixin_46390732的博客
04-19 1439
了解利用邻接表对有向图存储的相关知识 题目要求 private: typedef struct EdgeNode { int dest;//目标顶点的下标 int cost;//边上的权值 struct EdgeNode* link;//下一边的链接指针 }EdgeNode; struct Vex { ...
数据结构用邻接表存储图c语言,[转载]数据结构之C语言实现图（邻接表）（最后一篇程序）...
weixin_40000457的博客
05-20 827
注：本学期的数据结构上机课随着图的操作的完成而结束，期末之后会继续更新。本程序用邻接表存储图，主要有以下操作：(1)以邻接表作为图的存储结构，从键盘输入图的顶点与弧的信息建立一个有向图；(2)对(1)中生成的有向图进行深度优先遍历并打印结果；(3)在(1)中生成的有向图中，分别插入与删除一条弧并打印其结果；(4)在(1)中生成的有向图中，分别插入与删除一个顶点并打印结果；(5) 在(1)中生成的有...
邻接表实现的有向带权图 及 图算法（C++）
m0_52313753的博客
06-03 3012
邻接表（Adjacency List）： 我实现的方法相当于加 邻接表是一个 Vertex类型的数组（ adj = new Vertex[ ] ）数组元素Vertex中有一个指向Edge对象的指针（相当于链表的头节点），用来存放与对应Vertex相连的边 前面 public 的结构体是后面一些成员函数的返回值（因为有的要返回多个值有点要用特定的方式处理返回值）和一些后面的算法会用到的（并查集）。没有边的 从输入流获取边的 2. 析构函数 就删除边和顶点对象 3. 深度优先遍历 接受一个参数为Verte
c语言实现图的邻接表存储方式
qq_41277195的博客
11-23 2747
有向图的邻接表实现 初学图的邻接表存储方式，费了很多的时间去理解它。走了很多弯路，终于用代码上实现了这个存储结构，在这里把的感悟和过程做个总结，希望能帮到和我一样的初学者。 对于以下这个图 它的邻接表存储结构我相信大部分的朋友肯定是能够理解的，但是大部分的资料讲解都是在画一个邻接表的结构表示图之后直接上代码，然后对代码进行解释。 但对与我这样的初学者来说，这个由理论到代码的中间转换过程其实是最难...
基于邻接表的图建立（有向图+无向图）
Hacker_vision
06-06 2万+
图的表示（建立）有两种方法： ①邻接矩阵：A(i,j)=1表示i,j存在一条边，空间复杂度O(n^2)，稠密图 ②邻接表：只记录存在的边，Vector+List的数据结构，稀疏图 邻接矩阵的图建立这里不做赘述，接下来我们看一下邻接表的图建立： 有向图 注意理解头插入节点的过程 int n,m;//n表示城镇个数，m表示道路条数 struct LinkNode//列表
有向图、无向图邻接表（Adjacency List）的简单实现（C++ Graph）
最新发布
u011208918的专栏
07-03 199
有向图、无向图邻接表（Adjacency List）的简单实现，以及如何从有向图中找到所有的环
邻接表详解（C/C++）
热门推荐
莫浅子的博客
08-24 4万+
一、概念 二、分类 1）无向图的邻接表 2）有向图的邻接表（出弧） 3）有向图的逆邻接表（入弧） 三.步骤 四、代码
邻接多重表与普通邻接表的差异详解（C语言数据结构）
邻接多重表与邻接表是数据结构中两种常见的表示图的方法，特别是在处理有向或无向图时。它们之间的主要区别在于对图中边的表示方式。 首先，邻接表通常用一个链表来表示每个顶点的所有邻接点，即每条边仅由两个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值