Binary Space Partitioning - Error in space partitioning logic

So I've been implementing my first BSP Tree, and I think I found a flaw in my logic. I'm pretty lost as to how I could actually refactor this properly to work the way it should.

Here's the constructor (an explanation follows):

BSPTree::BSPTree( const polygonList_t& list )
    : mRoot( nullptr )
{
    polygonList_t front, back;

    auto eol = list.end();
    Polygon* rootSplitter = list[ 0 ];

    vec3 rootSplitPos;
    rootSplitter->GetPosition( rootSplitPos );

    for( auto iPoly = list.begin() + 1; iPoly != eol; ++iPoly )
    {
        vec3 resolvePos;
        ( *iPoly )->GetPosition( resolvePos );

        switch( ResolvePosition( rootSplitPos, resolvePos ) )
        {
            case POSITION_FRONT:
                front.push_back( *iPoly );
                break;

            case POSITION_BACK:
                back.push_back( *iPoly );
                break;

            case POSITION_SPLIT:
            {
                Polygon* toSplit = *iPoly;
                list.erase( iPoly );

                Polygon* outFront = new Polygon;
                Polygon* outBack  = new Polygon;

                SplitPolygon( resolvePos, toSplit, outFront, outBack );

                front.push_back( outFront );
                back.push_back( outBack );

                // finally we kill this one off
                delete toSplit;
                toSplit = nullptr;
            }
                break;
        }
    }

    mRoot = BSP_MakeNode();

    mRoot->splitter = rootSplitter;

    SplitSpace( mRoot, front );
    SplitSpace( mRoot, back );
}

In a nutshell, we receive a typedeffed std::vector< Polygon* > with an arbitrary number of heap-allocated Polygon objects. We then want to separate them into two categories: those in front of a certain center element, and those behind. Naturally, we declare two lists of the same typedef and call them front and back, respectively.

First, we select a Polygon (eventually I'd like to find a polygon which appears to be the best fit for a root partitioning plane), and then we iterate through our original list, checking for one of 3 cases:

(NOTE - for brevity's sake, I'm just going to dub our root partition polygon as root)

POSITION_FRONT: We know our current polygon within the list is in front of root, so we naturally add this polygon to our front list.
POSITION_BACK: Same as position, the only difference being that this polygon is behind root.
POSITION_SPLIT: We can't determine whether or not this polygon is in front of root or behind it, so we split it into two pieces and insert the front and back portions of it into their respective lists.

Finally, once we've divided our polygons into their front and back lists, we further subdivide our space, using the root as a basis for the initial subdividing.

void BSPTree::SplitSpace( bspNode_t* node, polygonList_t& polygons )
{
    if ( polygons.size() == 0 ) return;

    // grab the first polygon within the list,
    // and then subtract it from the list itself.
    Polygon* next = polygons[ 0 ];
    polygons.pop_back();

    vec3 splitPos;
    node->splitter->GetPosition( splitPos );

    vec3 toResolve;
    next->GetPosition( toResolve );

    switch( ResolvePosition( splitPos, toResolve ) )
    {
        case POSITION_FRONT:
            node->front = BSP_MakeNode();
            node->front->splitter = next;
            SplitSpace( node->front, polygons );
            break;

        case POSITION_BACK:
            node->back = BSP_MakeNode();
            node->back->splitter = next;
            SplitSpace( node->back, polygons );
            break;

        case POSITION_SPLIT:
        {
            Polygon* outFront = new Polygon;
            Polygon* outBack  = new Polygon;

            SplitPolygon( toResolve, next, outFront, outBack );

            node->front = BSP_MakeNode();
            node->back  = BSP_MakeNode();

            node->front->splitter = outFront;
            node->back->splitter = outBack;

            SplitSpace( node->front, polygons );
            SplitSpace( node->back, polygons );
        }
            break;
    }
}

Now, we perform a very similar sequence of operations, the key difference being that we are further subdividing an already partitioned space until each polygon has a given position within the node tree, which is either in front of or behind its parent node. Of course, we do this recursively.

The problem I'm currently seeing lies in the POSITION_SPLIT case evaluation within the switch statement above:

        case POSITION_SPLIT:
        {
            Polygon* outFront = new Polygon;
            Polygon* outBack  = new Polygon;

            SplitPolygon( toResolve, next, outFront, outBack );

            node->front = BSP_MakeNode();
            node->back  = BSP_MakeNode();

            node->front->splitter = outFront;
            node->back->splitter = outBack;

            SplitSpace( node->front, polygons ); // here
            SplitSpace( node->back, polygons );  // and here
        }

In conjunction with two other factors:

For every polygon obtained from the given reference parameter polygons, we pop_back() the pointer which holds that polygon within the list after assigning it to a temporary.
Tying in with the aforementioned, every call to SplitSpace(...) yields a check to see if its received list is empty. If so, nothing is done, and the recursive subdivision has been completed for that list.

Because of these two factors, I cannot help but think that, in the POSITION_SPLIT case evaluation, the second call to SplitSpace(...) is useless: the list will be exhausted before the second call (to accomodate for the back portion of the split) is made.

Question

So, what is a solution to this problem that will at least get me headed back on the right track?

Solution

You should refactor the BSPTree constructor as your recursive logic and apply divide-and-conquer.
1. Input is a list of polygons.
2. Pick a splitting plane, this is the current node in the BSP.
3. Subdivide the polygons into front and back.
4. Pass the front list to this same function (recursion), get back a child node.
5. Pass the back list to this same function (recursion), get back a child node.
6. Return the current node.

bspNode_t* BuildBSP( const polygonList_t& list )
{
 polygonList_t front, back;
 Polygon* rootSplitter = list[ 0 ];
 bspNode_t* currentNode = new bspNode_t(rootSplitter);

 vec3 rootSplitPos;
 rootSplitter->GetPosition( rootSplitPos );

 for( auto iPoly = list.begin() + 1; iPoly != eol; ++iPoly )
 {
   vec3 resolvePos;
   ( *iPoly )->GetPosition( resolvePos );

   switch( ResolvePosition( rootSplitPos, resolvePos ) )
   {
     case POSITION_FRONT:
       front.push_back( *iPoly );
       break;

     case POSITION_BACK:
       back.push_back( *iPoly );
       break;

     case POSITION_SPLIT:
     {
       Polygon* toSplit = *iPoly;
       list.erase( iPoly );

       Polygon* outFront = new Polygon;
       Polygon* outBack  = new Polygon;

       SplitPolygon( resolvePos, toSplit, outFront, outBack );

       front.push_back( outFront );
       back.push_back( outBack );

       // finally we kill this one off
       delete toSplit;
       toSplit = nullptr;

       break;
    }
  }
}

currentNode->frontChild = BuildBSP(front);
currentNode->backChild = BuildBSP(back);

return currentNode;

}