武夷学院实验报告格式(数计学院)

table->close.next = NULL;
table->open.city_node.parent = -1;
table->open.city_node.city = -1;
table->close.city_node.parent = -1;
table->close.city_node.city = -1;
node city_node;
} nodelist, *nodeptr;
nodeptr _add_to_open(int);
nodeptr _find_least_f();
void _print_path(nodeptr ptr);
void _move_to_close(nodeptr ptr);
nodeptr _remove_from_open(nodeptr ptr);
if (b_path[i])
count++;
}
if (count == num + 1) { //all city in best path,A in twice:First And Last.
break;
} if (count == num) { //left one,which ? Last A.Because we have never changed the value of b_path[num].
（1）状态图的搜索方式主要有树式搜索和线式搜索，其基本的搜索策略是盲目搜索
和启发式搜索；
（2）启发式搜索就是利用启发性信息进行制导的搜索，A*算法属于典型的启发式
搜索算法；
（3）两种常用的方法可用来搜索图：即深度优先搜索和广度优先搜索。它们最终都
会到达所有连通的顶点。深度优先搜索通过栈来实现，而广度优先搜索通过队列来
p->city_node.city = i;
p->city_node.level = 0;
p->city_node.f = 0;
p->city_node.g = 0;
p->city_node.h = 0;
p->next = table->_this->open.next;
p->pre = &table->_this->open;
if (table->_this->open.next) {
table->_this->open.next->pre = p;
}
table->_this->open.next = p;
return p;
}
void _add_to_close(nodeptr ptr) { //添加到close表
ptr->next = table->_this->close.next;
ptr->pre = &table->_this->close;
if (table->_this->close.next) {
table->_this->close.next->pre = ptr;
}
table->_this->close.next = ptr;
}
nodeptr _remove_from_open(nodeptr ptr) { //从OPEN表中移除，不删除
nodeptr p = NULL;
p = (nodeptr) malloc(sizeof(nodelist));
memset(p, 0, sizeof(nodelist));
if (p == NULL) {
return p;
}
p->next = NULL;
p->parent = NULL;
p->city_node.parent = -1;
p = table->_this->open.next;
q = p;
while (p) {
if (p->city_node.f < least) {
q = p;
least = p->city_node.f;
}
p = p->next;
}
return q;
}
void _move_to_close(nodeptr ptr) { //从OPEN移到CLOSE
table->move_to_close(ptr_p); //move to close table and save it;
if (l_ptr && l_ptr != ptr_p) { //更新最好路径
while (l_ptr != NULL) {
b_path[l_ptr->city_node.city] = 0;
void _add_to_close(nodeptr ptr);
typedef struct _ttable {
struct _ttable *_this; //this指针
nodelist open; //open表,
nodelist close; //close表,(仓库)
nodeptr(*add_to_open) (int);
nodeptr(*find_least_f) (void);
void (*move_to_close) (nodeptr ptr);
void (*print_path) (nodeptr ptr);
} ttable;
int map[100][100];
int b_path[100]; //best_path;
return table;
}
void *table_destructor(ttable * table) { //析构一个类
if (table != NULL) {
nodeptr p = table->_this->open.next;
nodeptr q = NULL;
while (p) {
q = p->next;
printf("\
请输入节点之间的距离矩阵：\n");
for (i = 0; i < num; i++) {
for (j = 0; j < num; j++) {
scanf("%d", &map[i][j]);
if (i != j && min > map[i][j]) {
min = map[i][j];
旅行商问题。
3、实验步骤：
源代码：
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <memory.h>
#define MAX_INT 99999999
typedef struct _node {
int f; //f值
int g; //g值
}
int main() {
int num, min = MAX_INT;
int i, j, k, count;
int tmpf, tmph, tmpg;
ttable *table = (ttable *) table_constructor(); //构造
nodeptr ptr = NULL, ptr_p = NULL, ptr_c = NULL;
nodeptr l_ptr = NULL; //the pointer of last best path;
//input city
do {
printf("请输入城市节点个数：2=<节点个数<99\n");
scanf("%d", &num);
} while (num >= 99 || num <= 1);
ptr_c = table->add_to_open(num); //把它添加进开启列表中
ptr_c->city_node.parent = ptr_p->city_node.city; //把当前作为这的父节点
ptr_c->city_node.level = ptr_p->city_node.level + 1; //他是父节点的下一层。
int h; //h值
int level; //第几次走到这个点(important)
int parent; //父城市;
int city; //city num;
} node;
typedef struct _list {
struct _list *next;
struct _list *pre;
struct _list *parent; //父城市节点指针
实现。
2、实验过程记录：
1、实验目的及要求
（1）掌握图搜索技术的基本原理和常用法的应用；
（3）掌握图搜索问题求解中的问题表示、节点表示、close表和open表的构造；
2、实验原理:
利用图搜索技术求解状态图中任意两点的路径和最短路径，并利用这种方法解决
l_ptr = l_ptr->parent;
}
l_ptr = ptr_p;
while (l_ptr != NULL) {
b_path[l_ptr->city_node.city] = 1;
l_ptr = l_ptr->parent;
}