Java

import java.util.*;

// Data structure to store graph edges
class Edge {
    int source, dest, weight;

    public Edge(int source, int dest, int weight) {
        this.source = source;
        this.dest = dest;
        this.weight = weight;
    }
};

// Data structure to store heap nodes
class Node {
    int vertex, weight;

    public Node(int vertex, int weight) {
        this.vertex = vertex;
        this.weight = weight;
    }
}

// class to represent a graph object
class Graph {
    // A List of Lists to represent an adjacency list
    List<List<Edge>> adjList = null;

    // Constructor
    Graph(List<Edge> edges, int N) {
        adjList = new ArrayList<>(N);

        for (int i = 0; i < N; i++) {
            adjList.add(i, new ArrayList<>());
        }

        // add edges to the undirected graph
        for (Edge edge : edges) {
            adjList.get(edge.source).add(edge);
        }
    }
}

class Dijkstra {

    public static ArrayList<Integer> bestRoute = new ArrayList<>();

    private static void calculateRoute(int prev[], int i) {
        if (i < 0)
            return;
        calculateRoute(prev, prev[i]);
        bestRoute.add(i);
        //  System.out.print(i + " ");
    }

    // Run Dijkstra's algorithm on given graph
    public static ArrayList<Integer> shortestPath(Graph graph, int start, int finish, int N) {
        // create min heap and push start node having distance 0
        PriorityQueue<Node> minHeap = new PriorityQueue<>(
                (lhs, rhs) -> lhs.weight - rhs.weight);

        minHeap.add(new Node(start, 0));

        // set infinite distance from start to v initially
        List<Integer> dist = new ArrayList<>(
                Collections.nCopies(N, Integer.MAX_VALUE));

        // distance from start to itself is zero
        dist.set(start, 0);

        // boolean array to track vertices for which minimum
        // cost is already found
        boolean[] done = new boolean[N];
        done[start] = true;

        // stores predecessor of a vertex (to print path)
        int prev[] = new int[N];
        prev[start] = -1;

        // run till minHeap is not empty
        while (!minHeap.isEmpty()) {
            // Remove and return best vertex
            Node node = minHeap.poll();

            // get vertex number
            int u = node.vertex;

            // do for each neighbor v of u
            for (Edge edge : graph.adjList.get(u)) {
                int v = edge.dest;
                int weight = edge.weight;

                // Relaxation step
                if (!done[v] && (dist.get(u) + weight) < dist.get(v)) {
                    dist.set(v, dist.get(u) + weight);
                    prev[v] = u;
                    minHeap.add(new Node(v, dist.get(v)));
                }
            }

            // marked vertex u as done so it will not get picked up again
            done[u] = true;
        }


        // dist.get(finish)
        calculateRoute(prev, finish);
        return bestRoute;
    }

    public static void main(String[] args) {
        // initialize edges as per above diagram
        // (u, v, w) triplet represent undirected edge from
        // vertex u to vertex v having weight w
        List<Edge> edges = Arrays.asList(
                new Edge(0, 1, 43), new Edge(0, 5, 30),
                new Edge(1, 0, 43), new Edge(1, 2, 126), new Edge(1, 6, 30),
                new Edge(2, 1, 126), new Edge(2, 3, 43), new Edge(2, 7, 30),
                new Edge(3, 2, 43), new Edge(3, 9, 90), new Edge(3, 4, 43),
                new Edge(4, 3, 43), new Edge(4, 10, 90),
                new Edge(5, 0, 30), new Edge(5, 6, 43), new Edge(5, 8, 60),
                new Edge(6, 1, 30), new Edge(6, 5, 43), new Edge(6, 7, 126),
                new Edge(7, 6, 126), new Edge(7, 2, 30),
                new Edge(8, 5, 60), new Edge(8, 9, 210), new Edge(8, 13, 60),
                new Edge(9, 3, 90), new Edge(9, 10, 43), new Edge(9, 12, 30), new Edge(9, 8, 210),
                new Edge(10, 4, 90), new Edge(10, 9, 43), new Edge(10, 15, 60),
                new Edge(11, 14, 30), new Edge(11, 12, 170),
                new Edge(12, 9, 30), new Edge(12, 11, 170),
                new Edge(13, 8, 60), new Edge(13, 14, 43),
                new Edge(14, 13, 43), new Edge(14, 11, 30), new Edge(14, 15, 210),
                new Edge(15, 14, 210), new Edge(15, 10, 60)
        );

        // Set number of vertices in the graph
        final int N = 16;

        // construct graph
        Graph graph = new Graph(edges, N);
        ArrayList<Integer> integers = shortestPath(graph, 13, 5, N);

        System.out.println(integers);
    }
}