人工智能基础-路径规划

#include <iostream>
 
struct _Node{
    int num;
    _Node *lChild;
    _Node *rChild;
};
 
void 前序遍历(_Node *node){
    if(node == nullptr) return;
    printf("num = %d\n",node->num);//访问自己
    前序遍历(node->lChild);
    前序遍历(node->rChild);
}
 
void 中序遍历(_Node *node){
    if(node == nullptr) return;
    中序遍历(node->lChild);
    printf("num = %d\n",node->num);//访问自己
    中序遍历(node->rChild);
}
 
void 后序遍历(_Node *node){
    if(node == nullptr) return;
    后序遍历(node->lChild);
    后序遍历(node->rChild);
    printf("num = %d\n",node->num);//访问自己
}

#include <iostream>
#include <queue>
 
using namespace std;
 
struct _Node{
    int num;
    _Node *lChild;
    _Node *rChild;
};
void BFS(_Node *node);
 
int main(){
    _Node *nodes[6];
    //初始化节点
    for(int i=0;i<6;i++){
        nodes[i] = (_Node*)malloc(sizeof(_Node));
        nodes[i]->num = i;
        nodes[i]->lChild = nodes[i]->rChild = NULL;
    }
    nodes[0]->lChild = nodes[1];
    nodes[0]->rChild = nodes[2];
    nodes[1]->lChild = nodes[3];
    nodes[1]->rChild = nodes[4];
    nodes[2]->rChild = nodes[5];
    //广度优先遍历
    BFS(nodes[0]);
    return 0;
}
 
void BFS(_Node *node){
    if(node == NULL) return;
    _Node *head;
    queue<_Node*> q;
    q.push(node);
    while (!q.empty()){
        //弹出表头节点
        head = q.front();
        q.pop();
        //访问当前节点
        printf("Search: %d\n",head->num);
        //插入下一层的节点
        if(head->lChild != NULL) q.push(head->lChild);
        if(head->rChild != NULL) q.push(head->rChild);
    }
}

#define G 10000
int map[5][5] = {
        {0,G,3,G,1},
        {G,0,1,G,3},
        {3,1,0,2,G},
        {G,G,2,0,3},
        {1,3,G,3,0}
};

#include <iostream>
#include <queue>
#define G 10000
using namespace std;
 
int map[5][5] = {
        {0,G,3,G,1},
        {G,0,1,G,3},
        {3,1,0,2,G},
        {G,G,2,0,3},
        {1,3,G,3,0}
};
int d[5];
bool mark[5] = {false,false,false,false,false};
void Dijikstra();
 
int main(){
    memcpy(d,map[0],sizeof d);
    Dijikstra();
    for(int i=0;i<5;i++){
            cout << d[i] << endl;
    }
    return 0;
}
 
void Dijikstra(){
    for(int i=0;i<5;i++){
        d[i] = map[0][i];//初始化d数组
    }
    for(int i=1;i<=5;i++){
        int min = G;//距离原点最近点距离
        int index = 0;//距离原点最近点下标
        for(int j=0;j<5;j++){
            if(!mark[j] && min > d[j]){
                min = d[j];
                index = j;
            }
        }
        mark[index] = true;//标记
        for(int j=1;j<5;j++){
            if(map[index][j] != G){
                if(d[index] + map[index][j] < d[j]){
                    d[j] = d[index] + map[index][j];
                }
            }
        }
    }
}