Python 八数码问题，可以直接运行

Python 八数码问题，如果使用Spyder，可以直接运行，其他需要导入相应包

# -*- coding: utf-8 -*-
“““
Created on Fri Apr 19 16:25:45 2019

@author: Yuming
“““
from Node import Node
import copy

def showMap（node）:
    print（“代价:“node.g）
    print（“启发性信息:“node.h）
    print（“估价函数:“node.g+node.h）
    for x in range（0 3）:
        for y in range（0 3）:
            print（node.array2d[x][y] end=‘‘）
        print（“ “）
    print（“--------“）
    return;

def move（array2d srcX srcY drcX drcY）:
    temp = array2d[srcX][srcY]
    array2d[srcX][srcY] = array2d[drcX][drcY]
    array2d[drcX][drcY] = temp
    return array2d;

class Astar:
    
    def __init__（self startNode endNode）:
        “““ 
        startNode:  寻路起点 
        endNode:    寻路终点 
        “““  
        #开放列列表
        self.openList = []
        #封闭列表  
        self.closeList = []
        #起点  
        self.startNode = startNode
        #终点
        self.endNode = endNode 
        #当前处理的节点
        self.currentNode = startNode
        #最后生成的路径
        self.pathlist = []
        #step步
        self.step = 0
        
    def getMinFNode（self）:
        “““ 
        获得openlist中f（x）最小的节点
        “““  
        nodeTemp = self.openList[0]  
        for node in self.openList:  
            if node.g + node.h < nodeTemp.g + nodeTemp.h:  
                nodeTemp = node  
        return nodeTemp

    def nodeInOpenlist（selfnode）:
        “““
        判断结点是否在开放列表
        “““
        for nodeTmp in self.openList:  
            if nodeTmp.array2d == node.array2d:  
                return True  
        return False

    def nodeInCloselist（selfnode）:
        “““
        判断结点是否在封闭列表
        “““
        for nodeTmp in self.closeList:  
            if nodeTmp.array2d == node.array2d:  
                return True  
        return False

    def endNodeInOpenList（self）:  
        “““
        目标状态是否在开放列表中
        “““
        for nodeTmp in self.openList:  
            if nodeTmp.array2d == self.endNode.array2d:  
                return True  
        return False

    def getNodeFromOpenList（selfnode）:  
        “““
        返回输入状态在开放列表的代价，启发性信息
        “““
        for nodeTmp in self.openList:  
            if nodeTmp.array2d == node.array2d:  
                return nodeTmp  
        return None

    def searchOneNode（selfnode）:
        “““ 
        将移动后的状态放入开放列表
        “““  
        #忽略封闭列表
        if self.nodeInCloselist（node）:  
            return  
        #G值计算 
        gTemp = self.step

        #如果不在openList中，就加入openlist  
        if self.nodeInOpenlist（node） == False:
            node.setG（gTemp）
            #H值计算 
            node.setH（self.endNode）;
            self.openList.append（node）
            node.father = self.currentNode
        #如果在openList中，判断currentNode到移动后结点的G是否更小
        #如果更小，就重新计算g值，并且改变父结点 
        else:
            nodeTmp = self.getNodeFromOpenList（node）
            if self.currentNode.g + gTemp < nodeTmp.g:
                nodeTmp.

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件        1513  2019-04-21 14:26  Node.py
     文件        1031  2019-04-21 16:48  main.py
     文件        6048  2019-04-21 16:46  Algorithm.py