C++ 为DFS创建邻接列表

我无法为我的程序创建深度优先搜索。到目前为止，我有一类边和一类区域。我想将所有连接的边存储在我所在区域的一个节点内。我可以通过已经实现的getKey（）函数判断是否连接了某些内容。如果两条边具有相同的关键点，则它们是连接的。对于下一个区域，我想在该区域内存储另一组连接边，等等。但是，我不完全理解DFS，并且在实现它时遇到了一些问题。我不确定何时/何地再打电话给DFS。任何帮助都将不胜感激

class edge
{ 
  private:
  int source, destination, length;
  int key;
  edge *next;
  public:
  getKey(){ return key; } 
}

class region
{
   edge *data;
   edge *next;
   region() { data = new edge(); next = NULL; }

};

void runDFS(int i, edge **edge, int a)
{
  region *head = new region();
  aa[i]->visited == true;//mark the first vertex as true
  for(int v = 0; v < a; v++)
  {
    if(tem->edge[i].getKey() == tem->edge[v].getKey()) //if the edges of the vertex have the same root
    {
        if(head->data == NULL)
        {
          head->data = aa[i];
          head->data->next == NULL;
        } //create an edge
        if(head->data)
        {
          head->data->next = aa[i];
          head->data->next->next == NULL;
        }//if there is already a node connected to ti
    }
    if(aa[v]->visited == false)
      runDFS(v, edge, a); //call the DFS again
  } //for loop
 }

类边缘
{ 
私人：
int源、目的地、长度；
int键；
边*下一步；
公众：
getKey（）{return key；}
}
阶级地区
{
边缘*数据；
边*下一步；
region（）{data=new edge（）；next=NULL；}
};
void runDFS（int i，边**边，int a）
{
区域*头部=新区域（）；
aa[i]->visted==true；//将第一个顶点标记为true
对于（int v=0；vedge[i].getKey（）==tem->edge[v].getKey（））//如果顶点的边具有相同的根
{
如果（头部->数据==NULL）
{
头部->数据=aa[i]；
head->data->next==NULL；
}//创建一条边
如果（头部->数据）
{
head->data->next=aa[i]；
head->data->next->next==NULL；
}//如果已经有一个节点连接到ti
}
如果（aa[v]->访问==错误）
runDFS（v，edge，a）；//再次调用DFS
}//for循环
}

假设n是边的总数，k是最终的区域数。 为必要的DFS创建邻接列表的成本可能太高O（n^2）（如果k=1，即所有边都属于同一区域），因此在最坏的情况下，DFS将花费O（V+e），即O（n^2）

否则，问题很容易在O（n*log（k））中解决，如下所示：

遍历所有边，将它们添加到相应区域的头部（使用平衡bst，例如stl映射）[您也可以使用哈希]

穿过所有区域，并以必要的线性方式将它们连接起来

---

我想这个问题不存在保证的O（n）解决方案。

我试图实现一个邻接列表创建函数。邻接列表结构的下一个指针会将您带到邻接列表（下一个连接的两个节点之间没有关系），列表指针就是邻接列表。该节点具有具有其邻接列表的邻接列表的地址

struct node{
    int id;
    adj_list* adj;

};


struct adj_list{
    adj_list* next;
    adj_list* list;
    node* n;
    adj_list(node& _n){
        n = &(_n);
        next = NULL;
        list = NULL;
    }
};

node* add_node(int id,std::queue<int> q , node* root)
{
    node* n = new node(id);
    adj_list* adj = new adj_list(*n);
    n->adj = adj;

    if(root == NULL){
      return n;
    }
    std::queue<adj_list*> q1;

    while(1){
        adj_list* iter = root->adj;
        if(q.empty())break;
        int k = q.front();
        q.pop();
        while(iter){    
            if(iter->n->id == k){
                q1.push(iter);
                adj_list*  temp = iter->list;
                iter->list = new adj_list(*n);
                break;
            }
            iter = iter->next;
        }
    }

    adj_list* iter = root->adj;
    while(iter->next){
        iter = iter->next;
    }

    iter->next = adj;

    while(!q1.empty()){
        adj_list* temp = q1.front();
        q1.pop();
        adj->list = temp;
        adj = temp;
    }
    return root;
}

struct节点{
int-id；
调整列表*adj；
};
结构调整列表{
调整列表*下一步；
调整列表*列表；
节点*n；
调整列表（节点和节点）{
n=&（_n）；
next=NULL；
列表=空；
}
};
节点*add_节点（int-id，std:：queue q，node*root）
{
节点*n=新节点（id）；
调整列表*调整=新调整列表（*n）；
n->adj=adj；
if（root==NULL）{
返回n；
}
std：：队列q1；
而(1){
调整列表*iter=root->adj；
如果（q.empty（））中断；
int k=q.front（）；
q、 pop（）；
而国际热核实验堆{
如果（iter->n->id==k）{
q1.推进（iter）；
调整列表*temp=iter->list；
iter->列表=新调整列表（*n）；
打破
}
iter=iter->next；
}
}
调整列表*iter=root->adj；
while（iter->next）{
iter=iter->next；
}
iter->next=adj；
而（！q1.empty（））{
调整列表*temp=q1.front（）；
q1.pop（）；
调整->列表=温度；
adj=温度；
}
返回根；
}