Question

目前我正在尝试在C中创建一个基于文本的小型地下城爬虫，其中应该随机生成地图。我试图通过使用四链接列表来实现这一点，其中每个节点（房间）最多可以有四个连接到下一个房间。

typedef struct Room {
    int x; //each room got its own number to be identified.
    struct Room *north;
    struct Room *east;
    struct Room *south;
    struct Room *west; } room;

某些房间也应该只有一个或两个或三个连接，而未使用的指向下一个节点的指针仍为NULL。出于各种原因，我需要一种搜索算法，该算法遍历房间以找到特定的搜索算法。我不知道如何实现这样的东西。有什么想法吗？

Answer 1

我认为你可以使用深度优先搜索技术来找到所需的值。由于可能有四个方面可以找到，所以这个算法将帮助你找到。

学习DFS（深度优先搜索）您可以阅读以下内容：）

http://en.wikipedia.org/wiki/Depth-first_search

http://www.ics.uci.edu/~eppstein/161/960215.html

http://www.geeksforgeeks.org/applications-of-depth-first-search/

Answer 2

一个简单的解决方案是创建一个Room数组，或Room *数组

然后，您可以使用循环搜索数组，直到找到搜索值为x的房间，或者到达数组的末尾。

如果您从初始房间开始，可以尝试递归搜索链式列表。

但是，我们必须在struct Room中添加一个bool以避免无限搜索，因为你的房间可能会像这样互相循环：

 O--O
 |  |
 O--O
  O : room, - and | : link between rooms

在开始搜索之前，checked值应初始化为false，并且在检查一次房间时该参数将转到true。

原则：

Room* search_room (int x_search, Room* current_room)
{
//if current_room is NULL, return NULL
//if checked is true, return NULL
//checked becomes true
//if current_room->x equals x_search, return current_room

//store the result of search_room(x_search, current_room->north) somewhere
//if it's not null, return what it has returned
//if not, then proceed to the store and check of the 3 others calls :
//search_room(x_search, current_room->east)
//search_room(x_search, current_room->south)
//search_room(x_search, current_room->west)

//if all the 4 calls returned NULL, return NULL
}

Answer 3

使用递归算法很容易，将{quad}列表视为具有graph，left，right和top连接的bottom。以下是搜索算法的伪代码： -

typedef enum{
    VISITED,
    NOT_VISITED
}status;
typedef struct vertex{
    int x;
    struct vertex* up;
    struct vertex* down;
    struct vertex* left;
    struct vertex* right;
    status node_status;
}node;
typedef struct{
    node* g_nodes;
    int capacity, length, width,curr_filled;
    int row_index, col_index;
}graph;
g_node* search_graph (graph* gph, int key)
{
    static g_node = get_first_node ( gph ); //you can get any node.
    if ( g_node->x == key){
        return g_node;
    }
    if ( g_node->node_status == VISITED){
        return NULL;
    } 
    g_node->node_status = VISITED;
    if (g_node->left != NULL){
        return search_graph (gph, g_node->left);
    }
    if (g_node->right != NULL){
        return print_graph (gph, g_node->right);
    }
    if (g_node->up != NULL){
        return print_graph (gph, g_node->up);
    }
    if (g_node->down != NULL){
        return print_graph (gph, g_node->down);
    }

}

我正在寻找一种特定的搜索算法

3 个答案: