写一个A*算法的代码

A*算法是一种常用的启发式搜索算法，用于在图形或网络中找到最短路径。下面是一个简单的A*算法的代码示例：

function path = Astar(start, goal, graph)
    % 初始化open列表和closed列表
    openList = start;
    closedList = [];
    
    % 初始化起始节点的代价和启发函数值
    start.g = 0;
    start.h = heuristic(start, goal);
    start.f = start.g + start.h;
    
    while ~isempty(openList)
        % 选择open列表中f值最小的节点作为当前节点
        [~, idx] = min([openList.f]);
        current = openList(idx);
        
        % 如果当前节点是目标节点，则返回路径
        if isequal(current, goal)
            path = reconstructPath(current);
            return;
        end
        
        % 将当前节点从open列表中移除，并加入closed列表
        openList(idx) = [];
        closedList(end+1) = current;
        
        % 遍历当前节点的邻居节点
        neighbors = getNeighbors(current, graph);
        for i = 1:length(neighbors)
            neighbor = neighbors(i);
            
            % 如果邻居节点已经在closed列表中，则跳过
            if ismember(neighbor, closedList)
                continue;
            end
            
            % 计算邻居节点的代价和启发函数值
            gScore = current.g + distance(current, neighbor);
            hScore = heuristic(neighbor, goal);
            fScore = gScore + hScore;
            
            % 如果邻居节点不在open列表中，则加入open列表
            if ~ismember(neighbor, openList)
                neighbor.g = gScore;
                neighbor.h = hScore;
                neighbor.f = fScore;
                neighbor.parent = current;
                openList(end+1) = neighbor;
            else
                % 如果邻居节点已经在open列表中，并且新的f值更小，则更新节点信息
                idx = find(ismember(openList, neighbor));
                if fScore < openList(idx).f
                    openList(idx).g = gScore;
                    openList(idx).h = hScore;
                    openList(idx).f = fScore;
                    openList(idx).parent = current;
                end
            end
        end
    end
    
    % 如果open列表为空，表示无法找到路径
    error('No path found.');
end

function distance = distance(node1, node2)
    % 计算两个节点之间的距离（可以根据实际情况修改）
    distance = sqrt((node1.x - node2.x)^2 + (node1.y - node2.y)^2);
end

function heuristicValue = heuristic(node, goal)
    % 计算启发函数值（可以根据实际情况修改）
    heuristicValue = sqrt((node.x - goal.x)^2 + (node.y - goal.y)^2);
end

function path = reconstructPath(node)
    % 从目标节点开始，逆向构建路径
    path = [];
    while ~isempty(node.parent)
        path = [node, path];
        node = node.parent;
    end
end

function neighbors = getNeighbors(node, graph)
    % 获取当前节点的邻居节点（可以根据实际情况修改）
    neighbors = graph(node);
end

请注意，上述代码中的`start`和`goal`是起始节点和目标节点，`graph`是一个包含节点邻接关系的图形或网络。你可以根据实际情况修改`distance`和`heuristic`函数来计算节点之间的距离和启发函数值，以及`getNeighbors`函数来获取节点的邻居节点。

希望以上代码能够帮助你理解和实现A*算法。如果你有任何问题，请随时提问。