我正在为闭源程序创建一个工具。调试后，我有我想要访问的结构的基地址。经过仔细检查后，我发现它是一个多链表，前3个整数是指针，所有其他值都是数据。
我已经设法从我的分析中重建了这个结构：
struct UnitsInfo
{
//pointers to UnitsInfo structures, null when no structure available at that location
DWORD * a;//0x00
DWORD * b;//0x04
DWORD * c;//0x08
//data
int unkown_1; //0x0C
unsigned int Type; //0x10
unsigned int Amount;//ox14
};
UnitsInfo * Base_Node = ((UnitsInfo*)( (*(DWORD*)( (*(DWORD*)(0x00400000+0x008E98EC)) + 0x38)) + 0x0C);
现在，我对链接结构很陌生，更不用说多链接结构了。
我在想的是制作一张地图并强制执行，直到我得到所有地址。 （可能无限循环）？
但我知道这不是遍历此链表的方法。如何在不知道如何连接的情况下有效地遍历这个多链表中的所有节点（并避免使用我已经拥有的节点）？
编辑：感谢我的答案，我终于成功了！
这是我的代码，对其他人来说可能会派上用场吗？
#define MAX_PLAYERS (6)
#define POINTER(type,addr) (*(type*)(addr))
struct UnitsInfo
{
//pointers to UnitsInfo structures, null when no structure available at that location
DWORD * nodes[3];//0x00
//data
int unkown_1; //0x0C
unsigned int Type; //0x10
unsigned int Amount;//ox14
};
struct pinfo
{
bool in;
enum Controller {Ctrl_UNKNOWN, Ctrl_HUMAN, Ctrl_AI };
enum Nation {N_UNKNOWN, N_ALLIES, N_SOVIET, N_JAPAN };
std::string Name;
Nation Side;
short Team;
Controller Who;
int *Money;
int *Power;
int *Usage;
unsigned int *Color;
bool GotUnits;
DWORD *unit_start_node;
};
std::map<DWORD*,UnitsInfo*> UnitList[MAX_PLAYERS];
void GenerateUnitList(unsigned short slot)
{
std::set<DWORD*> todo;
unsigned int inserted = 1;
while(inserted)
{
inserted = 0;
for(auto it = UnitList[slot].begin(); it != UnitList[slot].end(); ++it)
{
for(short i = 0; i < 3; ++i)
{
if(it->second->nodes[i] != NULL)
{
if(UnitList[slot].find(it->second->nodes[i]) == UnitList[slot].end())
{
todo.insert(it->second->nodes[i]);
++inserted;
}
}
}
}
while(!todo.empty())
{
UnitList[slot][*todo.begin()] = &POINTER(UnitsInfo,*todo.begin());
todo.erase(todo.begin());
}
}
}
pinfo Player[MAX_PLAYERS];
//adding the first node
unsigned int CurrentSlot = (0xD8+(0x4*slot));
if(POINTER(DWORD,POINTER(DWORD,0x00400000+0x008E98EC)+CurrentSlot) != NULL)
{
Player[slot].unit_start_node = &POINTER(DWORD,POINTER(DWORD,POINTER(DWORD,POINTER(DWORD,0x00400000+0x008E98EC)+CurrentSlot) + 0x38) + 0x0C);
}
//adding first unit if available, if yes continue generating list
if(!Player[i].GotUnits)
{
if(POINTER(DWORD,*Player[i].unit_start_node+0x10) != NULL)
{
Player[i].GotUnits = true;
UnitList[i][(Player[i].unit_start_node)] = &POINTER(UnitsInfo,*Player[i].unit_start_node);
}
}
else
{
GenerateUnitList(i);
}
最重要的是，它的作用就像一个魅力而且不会懈怠：）
答案 0 :(得分：2)
它们都常用于遍历图表。链接结构中的循环将在bost情况下被检测到，因此如果实现正确，则不存在无限循环的风险。
基本上说两种方法都可以（至少在概念层面）标记任何被检查的节点，同时保留迄今为止在某种列表中看到的任何未访问的节点。
虽然广度优先遍历将使节点处于节点中以某种FIFO方式处理节点深度，但首先遍历会将新节点推送到堆栈，从而首先访问新发现的节点。
实现深度优先遍历的最简单方法之一即使不必实现堆栈也是如此，因为通过递归调用自身它只是（miss）使用程序的调用堆栈来跟踪仍然要访问的位置。 / p>
假设要遍历的图形节点具有以下结构：
struct Node {
int visited;
struct Node **edges;
void *some_data;
}
边是一个以NULL结尾的链接数组，通向另一个节点。从您选择的任何节点开始。你基本上只是调用一个函数，也许叫做访问，你就完成了：
void visit (struct Node *node) {
struct Node *n;
node->visited = 1;
for (n=node->edges; *n!=NULL; ++n)
if (!(*n)->visited)
visit (*n, depth+1);
}
当然，你仍然需要对每个访问过的节点做一些有用的事情。但是，为了访问从起始节点到达的所有节点而不在圆圈中运行，这已经是必须完成的所有事情。
这里尝试为您提供完整的工作示例。经过一些努力尝试后，我想我想出了一个相对不错的图表，显示了不同的选择。
我试着在下面的评论栏中将其描绘下来：
#include <stdio.h>
struct Node {
int visited;
int id;
struct Node **edges;
};
/* recursively visit this node and all unvisited nodes
reachable from here */
void visit (struct Node *node, int depth) {
struct Node **n;
node->visited = 1;
/* show the node id surrounded with '[' ']' characters
to indicate this node has been visited in the output */
printf ("[%d]\n", node->id);
for (n=node->edges; *n!=NULL; ++n) {
/* indent this line according the depth that has
been reached in recursion and show the id
of the reachable node currently inspected */
printf ("%*s %d ", 5*depth, "", (*n)->id);
if (!(*n)->visited) {
/* indicate the search goes down one recursion level
by drawing a '=>' next to the node id */
printf ("=>");
visit (*n, depth+1);
}
else
printf ("\n");
}
}
int main (int argc, char *argv[]) {
/* This is the graph that will be modeled and traversed
+----+
v \
+ -- 0 -+ \
/ ^ \ |
| / v /
v / 2 -
1- ^ \
\ / v
+---> 3 4
*/
struct Node v[5]; /* These will form the vertices of the graph */
/ * These will be the edges */
struct Node *e[][5] = {
{v+1, v+2, NULL},
{v+0, v+3, NULL},
{v+0, v+4, NULL},
{v+2, NULL},
{ NULL}
};
/* initialize graph */
int i;
for (i=0; i<5; ++i) {
v[i].id = i;
v[i].visited = 0;
v[i].edges=e[i];
}
/* starting with each vertex in turn traverse the graph */
int j;
for (j=0; j<5; ++j) {
visit (v+j, 0);
printf ("---\n");
/* reset the visited flags before the
next round starts */
for (i=0; i<5; ++i)
v[i].visited = 0;
}
return 0;
}
输出会以某种或多或少的神秘方式显示算法在递归过程中来回跳跃。
根据起始节点，您将获得不同的结果。例如，从节点4开始，将找不到任何其他节点，因为没有路径远离那里。
此处输出的起始节点范围为0到4。访问过的节点将被[ ]个字符包围，因为已经检查过的字符不会被访问，而是没有访问过。
我希望这个例子有助于了解该算法的工作原理和原因。
[0]
1 =>[1]
0
3 =>[3]
2 =>[2]
0
4 =>[4]
2
---
[1]
0 =>[0]
1
2 =>[2]
0
4 =>[4]
3 =>[3]
2
---
[2]
0 =>[0]
1 =>[1]
0
3 =>[3]
2
2
4 =>[4]
---
[3]
2 =>[2]
0 =>[0]
1 =>[1]
0
3
2
4 =>[4]
---
[4]
---
答案 1 :(得分：1)
我在想的是制作一张地图并强制执行，直到我得到所有地址。 （可能无限循环）？
总的来说，我认为这是可行的。您所需要的只是一组您已经处理过的地址，以及一组要处理的地址。每当遇到不在任何一组中的地址时，都会将其添加到“todo”集中。你继续在“todo”集中处理地址（并将它们移动到“完成”集），直到前者变空。