added A*

Author: TamimEhsan

README.md

@@ -20,13 +20,14 @@ So far there are 6 segments
 - Recursion Tree
 - Turing Machine
 
-I have implemented a total of `23 algorithms` so far. And will try to add more later.  
+I have implemented a total of `24 algorithms` so far. And will try to add more later.  
 
 ## Algorithms implemented 
 
 - DFS
 - BFS
 - Dijkstra
+- A star
 - Recursive Maze Creation
 - Bubble sort
 - Selection sort

src/algorithms/15puzzle.js

@@ -0,0 +1,127 @@
+/*
+let flag;
+const inf = 1010
+let dir = "LRUD";
+let dx = [0,0,-1,1];
+let dy = [-1,1,0,0];
+let len = [0,0,0,0];
+let str = new Array(60);
+let ar = new Array(4);
+let idx = new Array(4);
+let transpose = new Array(4);
+
+for (let i = 0; i < 4; i++) {
+    ar[i] = new Array(4);
+    idx[i] = new Array(4);
+    transpose[i] = new Array(4);
+}
+
+
+export function isSolvable(){
+
+}
+
+function row_conflict(rc){
+    let i, j, k, x, y, res = 0;
+
+    for (i = 0; i < 4; i++){
+        x = (ar[rc][i] >> 2);
+        if (ar[rc][i] != 16) idx[x][len[x]++] = ar[rc][i];
+    }
+
+    for (i = 0; i < 4; i++){
+        if (len[i] > 1){
+            for (j = 0; j < len[i]; j++){
+                for (k = j + 1; k < len[i]; k++){
+                    if (idx[i][j] > idx[i][k]) res += 2;
+                }
+            }
+        }
+        len[i] = 0;
+    }
+    return res;
+}
+
+function column_conflict(rc){
+    let i, j, k, x, y, res = 0;
+
+    for (i = 0; i < 4; i++){
+        x = (ar[i][rc] & 3);
+        if (ar[i][rc] != 16) idx[x][len[x]++] = ar[i][rc];
+    }
+
+    for (i = 0; i < 4; i++){
+        if (len[i] > 1){
+            for (j = 0; j < len[i]; j++){
+                for (k = j + 1; k < len[i]; k++){
+                    if (idx[i][j] > idx[i][k]) res += 2;
+                }
+            }
+        }
+        len[i] = 0;
+    }
+    return res;
+}
+
+let heuristic(bx, by){
+    let i, j, k, l, res, linear_conflict = 0, manhattan_distance = 0;
+
+    for (i = 0; i < 4; i++){
+        for (j = 0; j < 4; j++){
+            transpose[j][i] = ar[i][j];
+            if (ar[i][j] != 16){
+                manhattan_distance += F(i, j);
+            }
+        }
+        linear_conflict += row_conflict(i);
+        linear_conflict += column_conflict(i);
+    }
+
+    res = manhattan_distance + linear_conflict;
+    return res;
+}
+
+function ida(bx, by, lx, ly, g, lim, d, h){
+    if (flag) return 0;
+
+    if (!h){
+        if (!flag){
+            flag = true;
+            str[d] = 0;
+            //puts(str);
+            console.log(str);
+        }
+        return g;
+    }
+
+    let f = g + h;
+    if (f > lim) return f;
+
+    let i, k, l, nh, r, res = inf;
+    for (i = 0; i < 4; i++){
+        k = bx + dx[i], l = by + dy[i];
+        if (k >= 0 && k < 4 && l >= 0 && l < 4 && !(k === lx && l === ly)){
+            nh = h;
+            nh -= F(k, l);
+            if (bx !== k) nh -= row_conflict(bx), nh -= row_conflict(k);
+            if (by !== l) nh -= column_conflict(by), nh -= column_conflict(l);
+            swap(ar[bx][by], ar[k][l]);
+            let sw ;
+
+            nh += F(bx, by);
+            if (bx != k) nh += row_conflict(bx), nh += row_conflict(k);
+            if (by != l) nh += column_conflict(by), nh += column_conflict(l);
+
+            str[d] = dir[i];
+            r = ida(k, l, bx, by, g + 1, lim, d + 1, nh);
+            swap(ar[bx][by], ar[k][l]);
+            if (r < res) res = r;
+            if (r <= lim) return r;
+        }
+    }
+
+    return res;
+}
+
+
+ */

src/algorithms/Astar.js

@@ -0,0 +1,67 @@
+// Performs Dijkstra's algorithm; returns *all* nodes in the order
+// in which they were visited. Also makes nodes point back to their
+// previous node, effectively allowing us to compute the shortest path
+// by backtracking from the finish node.
+export function aStar(grid, startNode, finishNode) {
+  const visitedNodesInOrder = [];
+  startNode.distance = 0;
+  const unvisitedNodes = getAllNodes(grid);
+  while (!!unvisitedNodes.length) {
+    sortNodesByDistance(unvisitedNodes,finishNode);
+    const closestNode = unvisitedNodes.shift();
+    // If we encounter a wall, we skip it.
+    if (closestNode.isWall) continue;
+    // If the closest node is at a distance of infinity,
+    // we must be trapped and should therefore stop.
+    if (closestNode.distance === Infinity) return visitedNodesInOrder;
+    closestNode.isVisited = true;
+    visitedNodesInOrder.push(closestNode);
+    if (closestNode === finishNode) return visitedNodesInOrder;
+    updateUnvisitedNeighbors(closestNode, grid);
+  }
+}
+
+function sortNodesByDistance(unvisitedNodes,finishNode) {
+  unvisitedNodes.sort((nodeA, nodeB) => (nodeA.distance+Math.abs(finishNode.row-nodeA.row)+Math.abs(finishNode.col-nodeA.col))
+                                        - (nodeB.distance+Math.abs(finishNode.row-nodeB.row)+Math.abs(finishNode.col-nodeB.col)));
+}
+
+function updateUnvisitedNeighbors(node, grid) {
+  const unvisitedNeighbors = getUnvisitedNeighbors(node, grid);
+  for (const neighbor of unvisitedNeighbors) {
+    neighbor.distance = node.distance + 1;
+    neighbor.previousNode = node;
+  }
+}
+
+function getUnvisitedNeighbors(node, grid) {
+  const neighbors = [];
+  const {col, row} = node;
+  if (row > 0) neighbors.push(grid[row - 1][col]);
+  if (row < grid.length - 1) neighbors.push(grid[row + 1][col]);
+  if (col > 0) neighbors.push(grid[row][col - 1]);
+  if (col < grid[0].length - 1) neighbors.push(grid[row][col + 1]);
+  return neighbors.filter(neighbor => !neighbor.isVisited);
+}
+
+function getAllNodes(grid) {
+  const nodes = [];
+  for (const row of grid) {
+    for (const node of row) {
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+
+// Backtracks from the finishNode to find the shortest path.
+// Only works when called *after* the dijkstra method above.
+export function getNodesInShortestPathOrder(finishNode) {
+  const nodesInShortestPathOrder = [];
+  let currentNode = finishNode;
+  while (currentNode !== null) {
+    nodesInShortestPathOrder.unshift(currentNode);
+    currentNode = currentNode.previousNode;
+  }
+  return nodesInShortestPathOrder;
+}

src/pathfinderComponents/pathfinder.jsx

@@ -6,6 +6,7 @@ import {dijkstra,getNodesInShortestPathOrder} from "../algorithms/dijkstra";
 import {getMaze} from "../algorithms/recursiveMaze";
 import {bfsdfs} from "../algorithms/bfs";
 import {randomMaze} from "../algorithms/randomMaze";
+import {aStar} from "../algorithms/Astar";
 
 class Pathfinder extends Component {
     constructor() {
@@ -14,7 +15,7 @@ class Pathfinder extends Component {
             grid:[],
             mouseIsPressed:false,
             algorithms:[
-                "Dijsktra","BFS","DFS"
+                "Dijsktra","A star","BFS","DFS"
             ],
             algo:0,
             mazes:[
@@ -160,6 +161,9 @@ class Pathfinder extends Component {
                 visitedNodesInOrder = dijkstra(grid, startNode, finishNode);
                 break;
             case 1:
+                visitedNodesInOrder = aStar(grid, startNode, finishNode);
+                break;
+            case 2:
                 visitedNodesInOrder = bfsdfs(grid, startNode, finishNode,"bfs");
                 break;
             default: