Bidirectional iterative deepening pathfinding algorithm in Java

Question

Introduction

I have this iterative deepening search algorithm. The main "research" attempt was to find out a bidirectional version of that search, and it turned out to be superior compared to two other ID algorithms. The code I would like to get reviewed is as follows:

package net.coderodde.libid.support;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.coderodde.libid.NodeExpander;

public final class BidirectionalIterativeDeepeningDepthFirstSearch<N> {

    private final N source;
    private final Deque<N> backwardSearchStack;
    private final Set<N> frontier;
    private final NodeExpander<N> forwardExpander;
    private final NodeExpander<N> backwardExpander;

    public BidirectionalIterativeDeepeningDepthFirstSearch() {
        this.source              = null;
        this.backwardSearchStack = null;
        this.frontier            = null;
        this.forwardExpander     = null;
        this.backwardExpander    = null;
    }

    private BidirectionalIterativeDeepeningDepthFirstSearch(
        N source,
        NodeExpander<N> forwardExpander,
        NodeExpander<N> backwardExpander) {
        this.source              = source;
        this.backwardSearchStack = new ArrayDeque<>();
        this.frontier            = new HashSet<>();
        this.forwardExpander     = forwardExpander;
        this.backwardExpander    = backwardExpander;
    }

    public List<N> search(N source, 
                          N target, 
                          NodeExpander<N> forwardExpander,
                          NodeExpander<N> backwardExpander) {
        // Handle the easy case. We need this in order to terminate the 
        // recursion in buildPath.
        if (source.equals(target)) {
            return new ArrayList<>(Arrays.asList(source));
        }

        BidirectionalIterativeDeepeningDepthFirstSearch<N> state = 
                new BidirectionalIterativeDeepeningDepthFirstSearch<>(
                        source,
                        forwardExpander,
                        backwardExpander);

        for (int depth = 0;; ++depth) {
            // Do a depth limited search in forward direction. Put all nodes at 
            // depth == 0 to the frontier.
            state.depthLimitedSearchForward(source, depth);

            // Perform a reversed search starting from the target node and 
            // recurring to the depth 'depth'.
            N meetingNode = state.depthLimitedSearchBackward(target, depth);

            if (meetingNode != null) {
                return state.buildPath(meetingNode);
            }

            state.backwardSearchStack.clear();

            // Perform a reversed search once again with depth = 'depth + 1'.
            // We need this in case the shortest path has odd number of arcs.
            meetingNode = state.depthLimitedSearchBackward(target, depth + 1);

            if (meetingNode != null) {
                return state.buildPath(meetingNode);
            }

            state.backwardSearchStack.clear();
            // Wipe out the frontier.
            state.frontier.clear();
        }
    }

    private void depthLimitedSearchForward(N node, int depth) {
        if (depth == 0) {
            frontier.add(node);
            return;
        }

        for (N child : forwardExpander.expand(node)) {
            depthLimitedSearchForward(child, depth - 1);
        }
    }

    private N depthLimitedSearchBackward(N node, int depth) {
        backwardSearchStack.addFirst(node);

        if (depth == 0) {
            if (frontier.contains(node)) {
                return node;
            }

            backwardSearchStack.removeFirst();
            return null;
        }

        for (N parent : backwardExpander.expand(node)) {
            N meetingNode = depthLimitedSearchBackward(parent, depth - 1);

            if (meetingNode != null) {
                return meetingNode;
            } 
        }

        backwardSearchStack.removeFirst();
        return null;
    }

    private List<N> buildPath(N meetingNode) {
        List<N> path = new ArrayList<>();
        List<N> prefixPath = 
                new BidirectionalIterativeDeepeningDepthFirstSearch<N>()
                        .search(source, 
                                meetingNode, 
                                forwardExpander, 
                                backwardExpander);
        path.addAll(prefixPath);
        path.remove(path.size() - 1);
        path.addAll(backwardSearchStack);
        return path;
    }
}

Performance figures You can see something like this:

*** 8-puzzle graph benchmark ***
Seed = 1542379748450
BreadthFirstSearch in 7 milliseconds. Path length: 14
IterativeDeepeningDepthFirstSearch in 162 milliseconds. Path length: 14
BidirectionalIterativeDeepeningDepthFirstSearch in 1 milliseconds. Path length: 14
IterativeDeepeningAStar in 1 milliseconds. Path length: 14
Algorithms agree: true

*** General graph benchmark ***
Seed = 1542379748655
Warming up...
Warming up done!
BidirectionalIterativeDeepeningDepthFirstSearch in 0 milliseconds. Path length: 4
IterativeDeepeningDepthFirstSearch in 26 milliseconds. Path length: 4
BreadthFirstSearch in 4484 milliseconds. Path length: 4

The entire project lives here.