数据结构：图（邻接表存储 c++实现）

#include <iostream>
#include <string>
#include <queue>
using namespace std;

#define MAXVEX 10
#define INFINITY 0XFFFFFFFF
#define SUCCESS 1
#define UNSUCCESS 0
typedef int Status;
bool visited[MAXVEX]; //全局数组，记录结点是否已补访问

typedef int EdgeWeight;
typedef struct EdgeNode  
{
  int adjvex; //邻接点
  EdgeWeight weight; //权值
  struct EdgeNode* next; //指向下一条边

}EdgeNode;

typedef string VertexType; //顶点类型
typedef struct 
{
  VertexType data;
  EdgeNode* pFirstEdge; //指示第一条边
}VertexNode;

typedef VertexNode AdjList[MAXVEX];//邻接表

typedef struct  
{
  AdjList adjList; //邻接表
  int iVexNum; //顶点个数
  int iEdgeNum; //边数
}AdjListGraph;


//由顶点值得到顶点索引
int GetIndexByVertexVal( const AdjListGraph& G, VertexType val )
{
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    if ( val == G.adjList[i].data )
      return i;
  }
  return -1;
}

//创建有向图
Status CreateAdjListGraph( AdjListGraph& G )
{
  cout << "输入顶点个数以及边数：";
  cin >> G.iVexNum >> G.iEdgeNum;
  cout << "请输入" << G.iVexNum << "个顶点:";
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    cin >> G.adjList[i].data;
    G.adjList[i].pFirstEdge = NULL;
  }

  cout << "请输入由两点构成的边(" << G.iEdgeNum << "条):";
  for ( int i = 0; i < G.iEdgeNum; ++i )
  {
    VertexType first;
    VertexType second;
    cin >> first >> second;
    int m = GetIndexByVertexVal( G, first );
    int n = GetIndexByVertexVal( G, second ); 
    if ( m == -1 || n == -1 )
      return UNSUCCESS;

    EdgeNode* pEdgeNode = new EdgeNode;
    pEdgeNode->adjvex = n;
    pEdgeNode->weight = 0;  //权值暂时不用

    //表头插入法
    pEdgeNode->next = G.adjList[m].pFirstEdge;
    G.adjList[m].pFirstEdge = pEdgeNode;
  }
  return SUCCESS;
}


//销毁图
void DestroyGraph( AdjListGraph& G )
{
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    EdgeNode* pEdge = G.adjList[i].pFirstEdge;
    while( pEdge )
    {
      EdgeNode* q = pEdge;
      pEdge = pEdge->next;
      delete q;
    }
    G.adjList[i].pFirstEdge = NULL;
  }
  G.iVexNum = 0;
  G.iEdgeNum = 0;
}


//得到顶点的度
int GetVertexDegree(  const AdjListGraph& G, VertexType val )
{
  int m = GetIndexByVertexVal( G, val );//得到顶点的下标
  int iCount = 0; //顶点的度

  for ( int i = 0; i < G.iVexNum; ++i )
  {
    if ( i == m )
    {
      EdgeNode* pEdgeOut = G.adjList[i].pFirstEdge;
      while ( pEdgeOut ) 
      {
        ++iCount;//累加出度
        pEdgeOut = pEdgeOut->next;
      }
    }
    else
    {
      EdgeNode* pEdgeIn = G.adjList[i].pFirstEdge;
      while ( pEdgeIn )
      {
        if ( pEdgeIn->adjvex == m )
          ++iCount;   //累加入度
        pEdgeIn = pEdgeIn->next;
      }
    }
  }
  return iCount;
}


//深度优先遍历图
void DFS( const AdjListGraph& G, int i )
{
  cout << G.adjList[i].data << " ";
  visited[i] = true;

  EdgeNode* pEdge = G.adjList[i].pFirstEdge;
  while( pEdge )
  {
    int j = pEdge->adjvex;
    if ( !visited[j] )
    {
      DFS( G, j);
    }
    pEdge = pEdge->next;
  }
}
void DFSTraverse( const AdjListGraph& G )
{
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    visited[i] = false;
  }

  for ( int i = 0; i < G.iVexNum; ++i )
  {
    if ( !visited[i] )
      DFS( G, i );
  }
}

//广度优先遍历
void BFSTraverse( const AdjListGraph& G )
{
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    visited[i] = false;
  }

  queue<int> Q;
  for ( int i = 0; i < G.iVexNum; ++i )
  {
    if ( !visited[i] )
    {
      cout << G.adjList[i].data << " ";
      visited[i] = true;
      Q.push( i );
      while( !Q.empty() )
      {
        int iVex = Q.front();
        Q.pop();

        EdgeNode* pEdge = G.adjList[iVex].pFirstEdge;
        while ( pEdge )
        {
          if ( !visited[pEdge->adjvex] )
          {
            cout << G.adjList[pEdge->adjvex].data << " ";
            visited[pEdge->adjvex] = true;
            Q.push( pEdge->adjvex );
          }
          pEdge = pEdge->next;
        }
      }
    }
  }
}

int main()
{
  //创建有向图
  AdjListGraph G;
  CreateAdjListGraph( G );

  //深度优先遍历图
  DFSTraverse( G );
  cout << endl << endl;

  //广度优先遍历图
  BFSTraverse( G );
  cout << endl << endl;

  //结点的度
  cout << "输入求度的结点:";
  VertexType v;
  cin >> v;
  cout << "度为：" << GetVertexDegree( G, v ) << endl;

  //销毁有向图
  DestroyGraph( G );

  return 0;
}