动画解析：图的遍历方式有哪些？

// 邻接矩阵的深度有限递归算法

#define TRUE 1
#define FALSE 0
#define MAX 256

typedef int Boolean; // 这里我们定义Boolean为布尔类型，其值为TRUE或FALSE
Boolean visited[MAX]; // 访问标志的数组

//进行递归的遍历包含顶点i的连通图
void DFS(MGraph G, int i)
{
  visited[i] = TRUE; // 访问过的顶点设置为TRUE
  printf("%c ", G.vexs[i]); // 打印顶点
  for( j=0; j < G.numVertexes; j++ )
  {
    if( G.arc[i][j]==1 && !visited[j] )
    {
      DFS(G, j); // 对为访问的邻接顶点递归调用
    }
  }
}

// 邻接矩阵的深度遍历操作
void DFSTraverse(MGraph G)
{
  int i;
    
  // 初始化所有顶点状态都是未访问过状态
  for( i=0; i < G.numVertexes; i++ )
  {
    visited[i] = FALSE;
  }
  //防止图为非联通的情况，遍历整个图
  for( i=0; i < G.numVertexes; i++ )
  {
    if( !visited[i] ) // 若是连通图，只会执行一次
    {
      DFS(G, i);
    }
  }
}

void DFS_Stack(MGraph G, int i)
{
  int node;
  int count = 1;
  printf("%c ", G.vexs[i]); // 打印已访问顶点
  visited[i] = TRUE;
  node = i;
  push(i); //开始的节点入栈
  while(count < G.numVertexes) //still has node not visited
  {
  /* 所有被访问的节点依次入栈，只有node当找不到下一个相连的节点时，才使用出栈节点 */
    for(j=0; j < G.numVertexes; j++)
    {
      if(G.arc[node][j] == 1 && visited[j] == FALSE)
      {
        visited[j] = TRUE;
        printf("%c ", G.vexs[j]);
        count++;
        push(j); //push node j
        break;
      }
    }
    if(j == G.numVertexes) //与node相连的顶点均已被访问过，所以需要从stack里取出node的上一个顶点，再看该顶点的邻接顶点是否未被访问
      node = pop();
    else      //找到与node相连并且未被访问的顶点，
      node = j;
  }
}

// 邻接表的深度有限递归算法

#define TRUE 1
#define FALSE 0
#define MAX 256

typedef int Boolean; // 这里我们定义Boolean为布尔类型，其值为TRUE或FALSE
Boolean visited[MAX]; // 访问标志的数组

void DFS(GraphAdjList GL, int i)
{
  EdgeNode *p;
  
  visited[i] = TRUE;
  printf("%c " GL->adjList[i].data);
  p = GL->adjList[i].firstEdge;
  
  while(p)
  {
    if( !visited[p->adjvex] )
    {
      DFS(GL, p->adjvex);
    }
    p = p->next;
  }
}

// 邻接表的深度遍历操作
void DFSTraverse(GraphAdjList GL)
{
  int i;
  
  for( i=0; i < GL->numVertexes; i++ )
  {
    visited[i] = FALSE; // 初始化所有顶点状态都是未访问过状态
  }
  
  for( i=0; i < GL->numVertexes; i++ )
  {
    if( !visited[i] ) // 若是连通图，只会执行一次
    {
      DFS(GL, i);
    }
  }
}

// 邻接矩阵的广度遍历算法
void BFSTraverse(MGraph G)
{
  int i, j;
  Queue Q;
  
  for( i=0; i < G.numVertexes; i++ )
  {
    visited[i] = FALSE;
  }
  
  initQueue( &Q );
  
  for( i=0; i < G.numVertexes; i++ )
  {
    if( !visited[i] )
    {
      printf("%c ", G.vex[i]);
      visited[i] = TRUE;
      EnQueue(&Q, i);
      
      while( !QueueEmpty(Q) )
      {
        DeQueue(&Q, &i);
        for( j=0; j < G.numVertexes; j++ )
        {
          if( G.art[i][j]==1 && !visited[j] )
          {
            printf("%c ", G.vex[j]);
            visited[j] = TRUE;
            EnQueue(&Q, j);
          }
        }
      }
    }
  }
}

public class Solution {
    public static int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)){
            return 0;
        } 

        int len = beginWord.length();

        HashMap<String, ArrayList<String>> allComboDict = new HashMap<>();
        //创建邻接链表
        wordList.forEach(curWord -> {
            for (int i = 0; i < len; i++) {

                String comboWord = curWord.substring(0, i) + "*" + curWord.substring(i + 1, len);
                ArrayList<String> comboWordList = allComboDict.getOrDefault(comboWord, new ArrayList<>());
                comboWordList.add(curWord);
                allComboDict.put(comboWord, comboWordList);
            }
        });
        // 广度优先遍历队列
        Queue<Pair<String, Integer>> queue = new LinkedList<>();
        HashMap<String, Boolean> hasVistedList = new HashMap<>();

        queue.add(new Pair<>(beginWord, 1));

        hasVistedList.put(beginWord, true);

        // 广度优先遍历，逐个取出队列中元素进行操作
        while (!queue.isEmpty()) {

            Pair<String, Integer> node = queue.remove();
            String currWord = node.getKey();
            int level = node.getValue();
            for (int i = 0; i < len; i++) {
                String currComboWord = currWord.substring(0, i) + "*" + currWord.substring(i + 1, len);
                ArrayList<String> currComboWordList = allComboDict.getOrDefault(currComboWord, new ArrayList<>());

                for (String word : currComboWordList) {
                    if (word.equals(endWord))
                        return level + 1;

                    if (!hasVistedList.containsKey(word)){
                        queue.add(new Pair<>(word, level + 1));
                        hasVistedList.put(word, true);
                    }
                }
            }
        }
        return 0;
    }
}