油克小学期（三）图搜索（3）九宫格路径求解及基于递归的求解

已于 2023-04-27 16:46:57 修改
阅读量415 收藏 1
点赞数 1
分类专栏： 数据结构小学期（中油克） 文章标签： 图搜索算法 算法
于 2023-04-27 16:38:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63699880/article/details/130409806
版权

 代码实现：

（1）九宫格路径求解：

```c
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAXSIZE 3
#define ZERO 0
typedef int NODETYPE[MAXSIZE][MAXSIZE];
typedef struct  //用启发式搜索的结构，方便复用 
{
	NODETYPE node;
	//float evaluate;//不符的方格数,记录未来开销
	//float step;//直到当前节点为止搜索过的步数
}NODE;
typedef struct NEIGHBORNODE
{
	NODE node;
	struct NEIGHBORNODE* next;
}*NEIGHBOR, * PATH;
typedef struct ANODE
{
	NODE node;
	NEIGHBOR adjacents;
}ANYNODE;
typedef struct GRAPHNODE
{
	ANYNODE node;
	struct GRAPHNODE* next;
}*GRAPH;
typedef struct Paths
{
	PATH path;
	struct Paths* next;
}*PATHS, * STACK;



void setvalue(NODE* node1, NODE* node2)/**/
{
	int i, j;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			node1->node[i][j] = node2->node[i][j];
		}
	}
	//node1->evaluate = node2->evaluate;
	//node1->step = node2->step;
}
int equal(NODE* node1, NODE* node2)/**/
{
	int i, j;
	int flag = 1;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			if (node1->node[i][j] != node2->node[i][j])
			{
				flag = 0;
				break;
			}
		}
		if (flag == 0) break;
	}
	return flag;
}
void priNode(NODE* node)/**/
{
	int i, j;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			printf("   %d", node->node[i][j]);
		}
		printf("\n");
	}
	printf("===================\n");
}


int Locate(NODE* node, int* hori, int* vert, int zero)/**/
{
	int i, j;
	int flag = 0;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
			if (node->node[i][j] == zero)
			{
				*hori = i;
				*vert = j;
				flag = 1;
				break;
			}
		if (flag) break;
	}
	return flag;
}
void Exchange(NODE* node, int hori1, int vert1, int hori2, int vert2)/**/
{
	int tempnode;
	tempnode = node->node[hori1][vert1];
	node->node[hori1][vert1] = node->node[hori2][vert2];
	node->node[hori2][vert2] = tempnode;
}



int isInPath(NODE node, PATH path)
{
	PATH p = path;
	int flag = 0;
	while (p)
	{
		if (equal(&node, &p->node) == 1)
		{
			flag = 1;
			break;
		}
		else
		{
			p = p->next;
		}
	}
	return flag;
}
NEIGHBOR deleteNodeInPath(NEIGHBOR adjacents, PATH path)
{
	NEIGHBOR n1 = adjacents, n2 = NULL;
	int flag = 0;
	while (n1)
	{
		flag = isInPath(n1->node, path);
		if (flag == 1)
		{
			if (n1 == adjacents)
			{
				adjacents = n1->next;
				free(n1);
				n1 = adjacents;
			}
			else
			{
				n2->next = n1->next;
				free(n1);
				n1 = n2->next;
			}
		}
		else
		{
			n2 = n1;
			n1 = n1->next;
		}
	}
	return adjacents;
}



NEIGHBOR addANEIGHBOR(NEIGHBOR br, NODE* node) //给兄弟节点群加节点   
{
	NEIGHBOR b, pb;
	b = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
	setvalue(&(b->node), node);//Set(b->node,node,SetValue);//node赋值给b 
	b->next = NULL;
	if (br == NULL) //无兄弟节点 
		br = b;
	else
	{
		pb = br;
		while (pb->next)pb = pb->next;
		pb->next = b;
	}
	return br;
}
NEIGHBOR clearNeighbors(NEIGHBOR br)
{
	NEIGHBOR br1 = NULL;
	while (br)
	{
		br1 = br;
		br = br->next;
		free(br1);
	}
	return br;
}



NEIGHBOR copyNEIGHBORs(NEIGHBOR children)    //复制子节点集
{
	NEIGHBOR copynode, lastnode = NULL, head = NULL;
	while (children)
	{
		copynode = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
		setvalue(&(copynode->node), &(children->node));//Set(copynode->node,children->node,SetValue);
		copynode->next = NULL;
		if (head == NULL)
			head = copynode;
		else
			lastnode->next = copynode;
		lastnode = copynode;
		children = children->next;
	}
	return head;
}
NEIGHBOR ExpandNodes(NODE* node, int zero) /**/
{
	NEIGHBOR adjacents = NULL;
	int r = 0, c = 0;
	NODE* tp = (NODE*)malloc(sizeof(NODE));
	if (!Locate(node, &r, &c, zero))
	{
		return adjacents;
	}
	if (r == 0 && c == 0)
	{
		setvalue(tp, node);							//对九宫格赋值
		Exchange(tp, r, c, r + 1, c);			    //交换位置
		adjacents = addANEIGHBOR(adjacents, tp);	//收集新的节点

		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 0 && c == 1)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r + 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 0 && c == 2)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r + 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 1 && c == 0)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r + 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 1 && c == 1)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r + 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 1 && c == 2)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);


		setvalue(tp, node);
		Exchange(tp, r, c, r + 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 2 && c == 0)
	{


		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);
		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 2 && c == 1)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c + 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	else if (r == 2 && c == 2)
	{
		setvalue(tp, node);
		Exchange(tp, r, c, r - 1, c);
		adjacents = addANEIGHBOR(adjacents, tp);

		setvalue(tp, node);
		Exchange(tp, r, c, r, c - 1);
		adjacents = addANEIGHBOR(adjacents, tp);
	}
	return adjacents;
}


PATH addANodeToPath(NODE* node, PATH path)
{
	PATH p;
	p = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
	setvalue(&(p->node), node);
	if (path == NULL)//路径上的第一个节点
		p->next = NULL;
	else
		p->next = path;
	path = p;//倒序加入
	return path;
}
PATH copyPath(PATH path)//复制路径   
{
	PATH tempath;
	tempath = (PATH)copyNEIGHBORs((NEIGHBOR)path);
	return tempath;
}
struct Paths* copyPaths(struct Paths* Paths)//复制路径集合  
{
	struct Paths* copynode, * lastnode = NULL, * head = NULL;
	while (Paths)
	{
		copynode = (struct Paths*)malloc(sizeof(struct Paths));
		copynode->path = copyPath(Paths->path);
		copynode->next = NULL;
		if (head == NULL)
		{
			head = copynode;
		}
		else
		{
			lastnode->next = copynode;
		}
		lastnode = copynode;
		Paths = Paths->next;
	}
	return head;
}

void RevPath(PATH path)
{
	int num = 0, j = 0;
	NODE* nodes;
	PATH p = path;
	while (p)
	{
		p = p->next;
		num++;   //计数器 
	}
	nodes = (NODE*)malloc(num * sizeof(NODE));//存路径
	for (j = 0, p = path; p; p = p->next, j++)
	{
		setvalue(&(nodes[j]), &(p->node));
	}
	for (j = num - 1, p = path; p; p = p->next, j--)
	{
		setvalue(&(p->node), &(nodes[j]));//倒序存入 

	}
	free(nodes);
}
void priNEIGHBORs(NEIGHBOR NEIGHBORs)
{
	NEIGHBOR p = NEIGHBORs;
	if (p == NULL)
		printf("NULL");
	while (p)
	{
		priNode(&(p->node));
		p = p->next;
	}
}


struct Paths* addAPathToPaths(PATH path, struct Paths* Paths)
{
	PATH copypath;
	struct Paths* ps = NULL, * p;
	if (path == NULL) return Paths;
	copypath = copyPath(path);
	ps = (struct Paths*)malloc(sizeof(struct Paths));
	ps->path = copypath;
	ps->next = NULL;
	if (Paths == NULL) Paths = ps;
	else
	{
		p = Paths;
		while (p->next) p = p->next;
		p->next = ps;
	}
	return Paths;

}
struct Paths* formPathsFromNodes(NEIGHBOR adjacents, PATH path, struct Paths* Paths)
{
	PATH tempath;
	adjacents = deleteNodeInPath(adjacents, path);
	while (adjacents)
	{
		tempath = copyPath(path);
		tempath = addANodeToPath(&(adjacents->node), tempath);
		Paths = addAPathToPaths(tempath, Paths);
		adjacents = adjacents->next;
	}
	return Paths;
}
PATH clearPath(PATH path)
{
	path = (PATH)clearNeighbors((NEIGHBOR)path);
	return path;
}
struct Paths* clearPaths(struct Paths* Paths)
{
	struct Paths* Paths1 = Paths;
	while (Paths)
	{
		Paths1 = Paths;
		clearPath(Paths1->path);
		Paths = Paths->next;
		free(Paths1);
	}
	return Paths;
}
STACK pushAPath(STACK stack, PATH path)
{
	PATH tempath;
	STACK st;
	tempath = copyPath(path);
	st = (struct Paths*)malloc(sizeof(struct Paths));
	st->path = tempath;
	if (stack == NULL) st->next = NULL;
	else
		st->next = stack;
	stack = st;
	return stack;
}
STACK pushPaths(STACK stack, struct Paths* Paths)
{
	struct Paths* p, * head;
	head = copyPaths(Paths);
	p = head;
	if (p != NULL) //每个栈链一起 
	{
		while (p->next) p = p->next;
		p->next = stack;
		stack = head;
	}
	return stack;
}

STACK PopANode_DepthfirstSearch_Sudoku(STACK stack, NODE* node, PATH* path)/**/
{
	STACK p = stack;
	PATH tempath;
	if (p != NULL)
	{
		tempath = p->path;
		setvalue(node, &(tempath->node));
		*path = copyPath(tempath);
		stack = p->next;
		free(p);
	}
	return stack;
}

STACK clearStack(STACK stack)
{
	stack = clearPaths((struct Paths*)stack);
	return stack;
}

int SearchPath(NODE* start, NODE* end, PATH* path, int zero)
{
	NODE node;
	NEIGHBOR adjacents;
	STACK stack = NULL;
	int flag = 0;
	PATH tempath = NULL;
	struct Paths* paths = NULL;
	tempath = addANodeToPath(start, tempath);
	stack = pushAPath(stack, tempath);
	while (stack)
	{
		tempath = clearPath(tempath);
		stack = PopANode_DepthfirstSearch_Sudoku(stack, &node, &tempath);//弹出
		if (equal(end, &node) == 1)
		{
			flag = 1;
			*path = copyPath(tempath);
			break;
		}
		adjacents = ExpandNodes(&node, zero);
		paths = formPathsFromNodes(adjacents, tempath, paths);
		stack = pushPaths(stack, paths);
		paths = clearPaths(paths);
	}
	clearStack(stack);
	return flag;
}
int LengthOfPath(PATH path)
{
	int count = 0;
	PATH p = path;
	while (p)
	{
		count++;
		p = p->next;
	}
	return count;
}

int main(void) {
	int count;
	STACK stack = NULL;
	PATH path = NULL;
	int flag;
	NODE start = { {{1,2,3},{8,4,0},{7,6,5}} };
	NODE end = { {{1,2,3},{8,0,4},{7,6,5}} };
	printf("开始:\n");
	priNode(&start);
	printf("结束:\n");
	priNode(&end);
	flag = SearchPath(&start, &end, &path, ZERO);
	printf("路径:\n");
	RevPath(path);
	priNEIGHBORs(path);
	printf("\n总步数= %d ,查找结果= %d\n", LengthOfPath(path), flag);
	printf("======================\n");
	clearPath(path);
}

 

（2）基于递归的九宫格路径求解

```c
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAXSIZE 3
#define ZERO 0
typedef int NODETYPE[MAXSIZE][MAXSIZE];
typedef struct  //用启发式搜索的结构，方便复用 
{
	NODETYPE node;
	float evaluate;//不符的方格数,记录未来开销
	double step;//直到当前节点为止搜索过的步数
}NODE;
typedef struct NEIGHBORNODE
{
	NODE node;
	struct NEIGHBORNODE* next;
}*NEIGHBOR, * PATH;
typedef struct ANODE
{
	NODE node;
	NEIGHBOR adjacents;
}ANYNODE;
typedef struct GRAPHNODE
{
	ANYNODE node;
	struct GRAPHNODE* next;
}*GRAPH;




void setvalue(NODE* node1, NODE* node2)/**/
{
	int i, j;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			node1->node[i][j] = node2->node[i][j];
		}
	}
	node1->evaluate = node2->evaluate;
	node1->step = node2->step;
}
int equal(NODE* node1, NODE* node2)/**/
{
	int i, j;
	int flag = 1;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			if (node1->node[i][j] != node2->node[i][j])
			{
				flag = 0;
				break;
			}
		}
		if (flag == 0) break;
	}
	return flag;
}
void priNode(NODE* node)/**/
{
	int i, j;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
		{
			printf("   %d", node->node[i][j]);
		}
		printf("\n");
	}
	//printf("难度=%f\n", node->evaluate);
	//printf("步数=%f\n", node->step);
	printf("===================\n");
}


int Locate(NODE* node, int* hori, int* vert, int zero)/**/
{
	int i, j;
	int flag = 0;
	for (i = 0; i < MAXSIZE; i++)
	{
		for (j = 0; j < MAXSIZE; j++)
			if (node->node[i][j] == zero)
			{
				*hori = i;
				*vert = j;
				flag = 1;
				break;
			}
		if (flag) break;
	}
	return flag;
}
void Exchange(NODE* node, int hori1, int vert1, int hori2, int vert2)/**/
{
	int tempnode;
	tempnode = node->node[hori1][vert1];
	node->node[hori1][vert1] = node->node[hori2][vert2];
	node->node[hori2][vert2] = tempnode;
}



float Evaluate(NODE* node1, NODE* node2)  //计算难度   /**/
{
	int i, j;
	float res = 0;
	for (i = 0; i < MAXSIZE; i++)
		for (j = 0; j < MAXSIZE; j++)
			if (node1->node[i][j] != node2->node[i][j])
				res++;
	return res;
}
void EvaluateAdjacents(NEIGHBOR adjacents, NODE* node, NODE* end)//获取难度与已走步数   /**/
{
	NEIGHBOR br = adjacents;
	while (br)
	{
		br->node.evaluate = Evaluate(&(br->node), end);
		br->node.step = node->step + 1;
		br = br->next;
	}
}


int isInPath(NODE node, PATH path)
{
	PATH p = path;
	int flag = 0;
	while (p)
	{
		if (equal(&node, &p->node) == 1)
		{
			flag = 1;
			break;
		}
		else
		{
			p = p->next;
		}
	}
	return flag;
}
NEIGHBOR deleteNodeInPath(NEIGHBOR adjacents, PATH path)
{
	NEIGHBOR n1 = adjacents, n2 = NULL;
	int flag = 0;
	while (n1)
	{
		flag = isInPath(n1->node, path);
		if (flag == 1)
		{
			if (n1 == adjacents)
			{
				adjacents = n1->next;
				free(n1);
				n1 = adjacents;
			}
			else
			{
				n2->next = n1->next;
				free(n1);
				n1 = n2->next;
			}
		}
		else
		{
			n2 = n1;
			n1 = n1->next;
		}
	}
	return adjacents;
}



NEIGHBOR addANEIGHBOR(NEIGHBOR br, NODE* node) //给兄弟节点群加节点   
{
	NEIGHBOR b, pb;
	b = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
	setvalue(&(b->node), node);//Set(b->node,node,SetValue);//node赋值给b 
	b->next = NULL;
	if (br == NULL) //无兄弟节点 
		br = b;
	else
	{
		pb = br;
		while (pb->next)pb = pb->next;
		pb->next = b;
	}
	return br;
}
NEIGHBOR clearNeighbors(NEIGHBOR br)
{
	NEIGHBOR br1 = NULL;
	while (br)
	{
		br1 = br;
		br = br->next;
		free(br1);
	}
	return br;
}



NEIGHBOR copyNEIGHBORs(NEIGHBOR children)    //复制子节点集
{
	NEIGHBOR copynode, lastnode = NULL, head = NULL;
	while (children)
	{
		copynode = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
		setvalue(&(copynode->node), &(children->node));//Set(copynode->node,children->node,SetValue);
		copynode->next = NULL;
		if (head == NULL)
			head = copynode;
		else
			lastnode->next = copynode;
		lastnode = copynode;
		children = children->next;
	}
	return head;
}
NEIGHBOR ExpandNodes(NODE *node, int zero) /**/ 
{
    NEIGHBOR adjacents = NULL;
    int h, v;
    NODE *tempnode = (NODE*)malloc(sizeof(NODE));
    if(!Locate(node, &h, &v, zero))
        return adjacents;
    
    if(h == 0 && v == 0)    
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 0 && v == 1)  
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 0 && v == 2)    
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 1 && v == 0) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 1 && v == 1) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents =addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 1 && v == 2) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h + 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 2 && v == 0) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 2 && v == 1) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v + 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    } else if(h == 2 && v == 2) 
	{
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h - 1, v);
        adjacents = addANEIGHBOR(adjacents, tempnode);
        
        setvalue(tempnode, node);
        Exchange(tempnode, h, v, h, v - 1);
        adjacents = addANEIGHBOR(adjacents, tempnode);
    }

    return adjacents;
}

PATH addANodeToPath(NODE* node, PATH path)
{
	PATH p;
	p = (NEIGHBOR)malloc(sizeof(struct NEIGHBORNODE));
	setvalue(&(p->node), node);
	if (path == NULL)//路径上的第一个节点
		p->next = NULL;
	else
		p->next = path;
	path = p;//倒序加入
	return path;
}
PATH copyPath(PATH path)//复制路径   
{
	PATH tempath;
	tempath = (PATH)copyNEIGHBORs((NEIGHBOR)path);
	return tempath;
}
 
void priNEIGHBORs(NEIGHBOR NEIGHBORs)
{
	NEIGHBOR p = NEIGHBORs;
	if (p == NULL)
		printf("NULL");
	while (p)
	{
		priNode(&(p->node));
		p = p->next;
	}
}




PATH clearPath(PATH path)
{
	path = (PATH)clearNeighbors((NEIGHBOR)path);
	return path;
}



int SearchSubGraph(NODE *current, NODE *end, PATH* path, PATH* searchpath, int zero) {
	NEIGHBOR adjacents;
	int flag = 0;
	if (isInPath(*current, *searchpath) == 1) {
		return flag;
	}
	if (equal(current,end) == 1)
		flag = 1;
	else {
		*searchpath = addANodeToPath(current, *searchpath);
		adjacents = ExpandNodes(current, zero);
		while (adjacents) {
			if (isInPath(adjacents->node, *searchpath) == 0) {
				flag = SearchSubGraph(&adjacents->node, end, path, searchpath, zero);
				if (flag == 1) {
					*path = addANodeToPath(&adjacents->node, *path);
					break;
				}
			}
			adjacents = adjacents->next;
		}
	}
	return flag;
}
int SearchPath(NODE *start,NODE *end,PATH *path,int zero)
{
	int flag;
	PATH searchpath=NULL;
	flag=SearchSubGraph(start,end,path,&searchpath,zero);
	if(flag==1) *path=addANodeToPath(start,*path);
	clearPath(searchpath);
	return flag;
}



int LengthOfPath(PATH path)
{
	int count = 0;
	PATH p = path;
	while (p)
	{
		count++;
		p = p->next;
	}
	return count;
}

int main(void) 
{
	PATH path = NULL;
	int flag;
	NODE start = { {{1,2,3},{8,4,0},{7,6,5}},0,0 };
	NODE end = { {{1,2,3},{0,8,4},{7,6,5}} };
	printf("开始:\n");
	priNode(&start);
	printf("结束:\n");
	priNode(&end);
	flag = SearchPath(&start, &end, &path, ZERO);
	printf("路径:\n");
	//RevPath(path);
	priNEIGHBORs(path);
	printf("总结:\n\n总步数= %d ,查找结果= %d\n", LengthOfPath(path), flag);  //为什么path->node.step显示不出来，flag也跟着显示不出来??? 
	printf("======================\n");                                       //肯定是指针的问题,可明明传了path的地址去操作了啊??? 
	clearPath(path);
}

 

北城学神
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
易语言九宫格游戏
07-23
易语言九宫格游戏的求解算法通常基于回溯法或递归搜索。当玩家填写数字后，程序会检查该位置的合法性，即检查当前行、列和小宫格内是否有重复数字。若合法，继续检查下一个空位；若不合法，则撤销前一步操作，尝试...
数独（九宫格）求解
07-16
之前芬兰数学家发现了一个传说中“最难”的数独，于是手痒自己编程写了一个求解数独的程序，基本可以秒杀所有数独
油克小学期（四）启发式搜索（1）九宫格启发式搜索路径求解
weixin_63699880的博客
05-05 740
中油克小学期（四）启发式搜索（1）九宫格启发式搜索路径求解
油克小学期（七）规则树搜索
weixin_63699880的博客
05-05 690
中油克小学期（七）规则树搜索
八数码问题
梦想起航的地方
01-11 2122
八数码问题 一.八数码问题 八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题实际上
九宫格 数独 求解 算法 栈实现
Yasin Lee
05-27 2032
/*我花了3个小时解决了这个问题！激动呀！这是我对朋友们的挑战！因为他们说这个问题根本就没办法解决！这是手机上的一个游戏《数字九宫格》英文名字叫“Sudoku”，估计大家都玩过！这个游戏对智力是个很大的挑战！我很想在两分总之内就能把格子全填上，但是我的脑袋却没有那样的智商，只好写个程序让电脑帮帮我了！(*^__^*) 嘻嘻……   程序的思路就是栈，核心算法是最后的
九宫格算法分析步骤
u014364540的专栏
12-11 2311
搭建九宫格的步骤分为： 1、要明确知道每一块要用什么view 2、要明确每个view之间的父子关系 3、先尝试逐个添加格子，然后考虑使用for循环，知道列号决定X的值，行号决定Y的值，可画图分析 4、加载plist文件中的数据，根据数据长度来创建对应个数的格子 5、添加格子内部的子控件 6、给各自内部的子控件装配对应的数据
c语言九宫格的递归算法,九宫格 数独 求解 算法 栈实现
weixin_33700405的博客
05-25 460
/*我花了3个小时解决了这个问题！激动呀！这是我对朋友们的挑战！因为他们说这个问题根本就没办法解决！这是手机上的一个游戏《数字九宫格》英文名字叫“Sudoku”，估计大家都玩过！这个游戏对智力是个很大的挑战！我很想在两分总之内就能把格子全填上，但是我的脑袋却没有那样的智商，只好写个程序让电脑帮帮我了！(*^__^*) 嘻嘻……程序的思路就是栈，核心算法是最后的test函数！本来我想用递归的思路，但...
求解九宫格的Java_使用全排列方法解九宫格问题
weixin_39595271的博客
02-26 68
packagecom.sitinspring;publicclassSquarePuzzle{/***阶数*/privateintn;/***方阵数组*/privateInteger[]arr;/***平均值*/privateintaverage;publicSquarePuzzle(intn){this.n=n;//建立数组并得到平均值arr=newInteger[n*n];averag...
手机智力游戏 数字九宫格 sudoku 求解算法 源码 程序
09-12
手机智力游戏 数字九宫格 sudoku 求解算法 栈算法 非递归 手机 智力 游戏 数字九宫格 sudoku 求解 源码 算法 递归 堆栈 堆 栈 数据结构 (没有写过1000行以上代码者 请绕行，别浪费自己的时间！分不清堆和栈者靠边站...
趣味九宫格.zip易语言项目例子源码下载
03-22
《趣味九宫格.zip易语言项目源码解析与学习指南》 易语言，作为一款以“易”为设计理念的编程语言，旨在降低编程门槛，让更多人能够参与到编程中来。本篇文章将围绕“趣味九宫格.zip”这个易语言项目进行深入解析，...
基于DPLL算法的SAT问题求解器【100012387】
05-24
数独是一种逻辑谜题，要求在9x9的网格中填入数字，使得每行、每列和每个小九宫格内的数字都不重复。通过将数独问题转化为CNF公式，DPLL算法可以寻找有效的解决方案。 文件"an-sat-solver"很可能是实现这一算法的源...
暴力美学之广度搜索求解重排九宫格问题
godgreen的博客
11-04 2904
暴力美学之广度搜索求解重排九宫格问题 系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录暴力美学之广度搜索求解重排九宫格问题系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，
按图搜索新体验：阿里巴巴拍立淘API返回值详解
api77的博客
07-23 1100
阿里巴巴拍立淘API是一项基于图片搜索的商品搜索服务，它允许用户通过上传商品图片，系统自动识别图片中的商品信息，并返回与之相关的搜索结果。
备战秋招60天算法挑战，Day17
最新发布
溜达虎的博客
08-13 248
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
day 9 回溯算法
m0_73924943的博客
08-08 380
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1217
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
写一个九宫格1-9数字可能
03-26
以下是一个简单的九宫格问题求解程序，使用的是回溯法： ```python # 定义一个9x9的矩阵 matrix = [[0 for i in range(9)] for i in range(9)] # 计算九宫格中的数字之和 magic_sum = 15 # 定义一个变量记录已...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北城学神

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值