Return to Question

I am trying to implement A* search on a grid in MATLAB. I am currently using a priority queue class I found here, but it's a bit slow. I tried to write this simple priority queue class in MATLAB:

The above code is at least 3 times faster than the one I've mentioned above. I'm getting exactly the same output from these 2 classes but I'm not 100% sure if it is right. How can I check it? Is there any other way I could implement the same idea and get a faster result?

Edit: My question is on hold right now, the reason being: "Questions containing broken code or asking for advice about code not yet written are off-topic...". My question contains a working not-broken code. Please remove the hold!

I am trying to implement A* search on a grid in MATLAB. I am currently using a priority queue class I found here, but it's a bit slow. I tried to write this simple priority queue class in MATLAB:

The above code is at least 3 times faster than the one I've mentioned above. I'm getting exactly the same output from these 2 classes, and therefore I believe that the code is correct, but I'm not 100% certain. How can I check it? Is there any other way I could implement the same idea and get a faster result?

classdef PQ < handle
 
 properties
 nElements
 indx;
 priorityList;
 valueList;
 end
 
 methods
 function thePQueue = PQ()
 thePQueue.nElements = 0;
 thePQueue.priorityList{500} = [];
 thePQueue.valueList{500} = [];
  Index = cellfun('isempty', thePQueue.priorityList);
 thePQueue.priorityList(Index) = {NaN};
 thePQueue.valueList(Index) = {NaN};
 thePQueue.indx = 1;
 thePQueue.nElements = 0;
 end
 
 function push(thePQueue, value, priority)
 thePQueue.priorityList{thePQueue.indx} = priority;
 thePQueue.valueList{thePQueue.indx} = value;
 thePQueue.indx = thePQueue.indx + 1;
 thePQueue.nElements = thePQueue.nElements + 1;
 end
 
 
 function minPriorityElement = pop(thePQueue)
 if ~thePQueue.isEmpty
 thePQueue.nElements = thePQueue.nElements - 1;
 [~, minPriorityIndx] = min(cell2mat(thePQueue.priorityList));
 minPriorityElement = thePQueue.valueList{minPriorityIndx};
 thePQueue.priorityList(minPriorityIndx) = {NaN};
 thePQueue.valueList(minPriorityIndx) = {NaN};
 else
 disp('Queue is empty');
 end
 end
 
 function flagIsEmpty = isEmpty(thePQueue)
 flagIsEmpty = (thePQueue.nElements == 0);
 end
 end
end

classdef PQ2 < handle
 
 properties
 nElements
 indx;
 priorityList;
 valueList;
 end
 
 methods
 function thePQueue = PQ2()
 thePQueue.nElements = 0;
 thePQueue.priorityList = NaN*ones(500,1);
 thePQueue.valueList{500} = [];

 thePQueue.indx = 1;
 thePQueue.nElements = 0;
 end
 
 function push(thePQueue, value, priority)
 thePQueue.priorityList(thePQueue.indx) = priority;
 thePQueue.valueList{thePQueue.indx} = value;
 thePQueue.indx = thePQueue.indx + 1;
 thePQueue.nElements = thePQueue.nElements + 1;
 end
 
 
 function minPriorityElement = pop(thePQueue)
 if ~thePQueue.isEmpty
 thePQueue.nElements = thePQueue.nElements - 1;
 [~, minPriorityIndx] = min(thePQueue.priorityList);
 minPriorityElement = thePQueue.valueList{minPriorityIndx};
 thePQueue.priorityList(minPriorityIndx) = NaN;
 else
 disp('Queue is empty');
 end
 end
 
 function flagIsEmpty = isEmpty(thePQueue)
 flagIsEmpty = (thePQueue.nElements == 0);
 end
 end
end

But It's giving me different results compared to the priority queue I mentioned above. I'm not even sure which one is the right one. I won't have more than 500 nodes on my grid. That's why I'm using constant length cells. This priority queue is almost 10 times faster than the one I'm using but I'm not 100% sure if it is right. How can I check it? Is there any other way I could implement the same idea and get a faster result?

Edit: My question is on hold right now, the reason being: "Questions containing broken code or asking for advice about code not yet written are off-topic...". My question contains a working not-broken code. Please remove the hold!

Edit2: I found a silly bug and now the algorithm is working much better but it wold be great if I could improve the performance.

The above code is at least 3 times faster than the one I've mentioned above. I'm getting exactly the same output from these 2 classes but I'm not 100% sure if it is right. How can I check it? Is there any other way I could implement the same idea and get a faster result?

Edit: My question is on hold right now, the reason being: "Questions containing broken code or asking for advice about code not yet written are off-topic...". My question contains a working not-broken code. Please remove the hold!