启发式搜索解决八数码问题

#include 
#include 
#include 

typedef struct Node
{//节点结构体
    int data[9];
	double fg;
	struct Node * parent;
}Node*Lnode;

typedef struct Stack
{//OPEN CLOSED 表结构体
	Node * npoint;
	struct Stack * next;
}Stack* Lstack;

Node * Minf（Lstack * Open）
{//选取OPEN表上f值最小的节点，返回该节点地址
	Lstack temp = （*Open）->nextmin = （*Open）->nextminp = （*Open）;
	Node * minx;
    while（temp->next != NULL）
	{
		if（（temp->next ->npoint->f） < （min->npoint->f））
		{
			min = temp->next;
			minp = temp;
		}
		temp = temp->next;
	}
	minx = min->npoint;
	temp = minp->next;
	minp->next = minp->next->next;
	free（temp）;
	return minx;
}

int Canslove（Node * suc Node * goal）
{//判断是否可解
	int a = 0b = 0ij;
	for（i = 1; i< 9;i++）
		for（j = 0;j < i;j++）
		{
			if（（suc->data[i] > suc->data[j]） && suc->data[j] != 0）a++;
			if（（goal->data[i] > goal->data[j]） && goal->data[j] != 0）b++;
		}
	if（a%2 == b%2）return 1;
	else return 0;
}

int Equal（Node * sucNode * goal）
{//判断节点是否相等 ，1相等，0不相等
	for（int i = 0; i < 9; i ++ ）
		if（suc->data[i] != goal->data[i]）return 0;
    return 1;
}

Node * Belong（Node * sucLstack * list）
{//判断节点是否属于OPEN表 或 CLOSED表，是则返回节点地址，否则返回空地址
	Lstack temp = （*list） -> next ;
	if（temp == NULL）return NULL;
	while（temp != NULL）
	{
		if（Equal（suctemp->npoint））return temp -> npoint;
		temp = temp->next;
	}
	return NULL;
}

void Putinto（Node * sucLstack * list）
{//把节点放入OPEN 或CLOSED 表中
    Stack * temp;
	temp =（Stack *） malloc（sizeof（Stack））;
	temp->npoint = suc;
	temp->next = （*list）->next;
	（*list）->next = temp;
}

///////////////计算f值部分-开始//////////////////////////////
double Fvalue（Node suc Node goal float speed）
{//计算f值
	double Distance（NodeNodeint）;
	double h = 0;
	for（int i = 1; i <= 8; i++）
		h = h + Distance（suc goal i）;
	return h*speed + suc.g; //f = h + g;（speed值增加时搜索过程以找到目标为优先因此可能不会返回最优解）                                       
}

double Distance（Node suc Node goal int i）
{//计算方格的错位距离
	int kh1h2;
	for（k = 0; k < 9; k++）
	{
		if（suc.data[k] == i）h1 = k;
		if（goal.data[k] == i）h2 = k;
	}
	return double（fabs（h1/3 - h2/3） + fabs（h1%3 - h2%3））;
}
///////////////计算f值部分-结束//////////////////////////////

///////////////////////扩展后继节点部分的函数-开始/////////////////
int BelongProgram（Lnode * suc Lstack * Open Lstack * Closed Node goal float speed）
{//判断子节点是否属于OPEN或CLOSED表 并作出相应的处理
	Node * temp = NULL;
	int flag = 0;
	if（（Belong（*sucOpen） != NULL） || （Belong（*sucClosed） != NULL））
	{
		if（Belong（*sucOpen） != NULL） temp = Belong（*sucOpen）;
		else temp = Belong（*sucClosed）;
		if（（（*suc）->g） < （temp->g））
		{
			temp->parent = （*suc）->parent;
			temp->g = （*suc）->g;
			temp->f = （*suc）->f;
		    flag = 1;
		}
	}
	else
	{
		Putinto（* suc Open）;
		（*suc）->f = Fvalue（**suc goal speed）;
	}
	return flag; 
}

int Canspread（Node suc int n）
{//判断空格可否向该方向移动1，2，3，4表示空格向上向下向左向右移
	int iflag = 0;
	for（i = 0;i < 9;i++）