/*****

Here is a complete tree to determine spacing:

1234567890123456789012345678901234567890   (column count)
                       x
                 /           \
           x                       x
        /     \                 /     \
     x           x           x           x
   /   \       /   \       /   \       /   \
  x     x     x     x     x     x     x     x
 / \   / \   / \   / \   / \   / \   / \   / \
x   x x   x x   x x   x x   x x   x x   x x   x

****/


void binaryTree :: treeDisplay () const
{
   nodeType * ptr;              // local pointer through tree
   queue<nodeType *> treeq;	// next set of parents
   vector<nodeType *> levelList;// current list of nodes
   int levelNodes = 1;          // number of nodes at current level
   int branchSpaceInner = 11;	// changes to 5, then 3, then 1 -> / 2 if even, add 1
   int branchSpaceOuter = 34;	// changes to 17, then 7, then 3 -> / 2 if 17, then result - 1
   int indent = 23;   		// changes to 17, then 11, then 8, then 5, then 3, then 2, then 1, then 0
   int spacing = 47;		// spacing between data
   bool valid;			// determines if complete
   int i, j;			// loop vars

   // put root into initial tree
   ptr = root;
   if (ptr) {
      treeq.push (ptr);
      valid = true;
   }

   while (!treeq.empty() && valid) {
      // go through the number of nodes at that level;
      // go through the list *twice* to display data and then left/right links
      cout << setw (indent) << " ";
      indent = setIndent (indent);
      levelList.clear();

      // display data for one level
      for (i = 0; i < levelNodes; i++) {
         ptr = treeq.front();
         treeq.pop();
         if (ptr) {
            cout << ptr->data;
            cout << setw (spacing) << " ";
         }
         else
            cout << setw (spacing+1) << " ";
         levelList.push_back (ptr);
      }
      cout << endl;

      // go through the parents' pointers to display left/right links
      valid = false;
      cout << setw (indent) << " ";
      indent = setIndent (indent);
      for (i = 0; i < levelNodes; i++) {
         ptr = levelList [i];
         if (ptr) {
            if (ptr->left) {
               cout << "/";
               treeq.push (ptr->left);
               valid = true;
            } else {
               cout << " ";
               treeq.push (NULL);
            }
            cout << setw (branchSpaceInner) << "";

            if (ptr->right) {
               cout << "\\";
               treeq.push (ptr->right);
               valid = true;
            }
            else {
               cout << " ";
               treeq.push (NULL);
            }
         } else { 			// this parent has no children 
            treeq.push (NULL);
            treeq.push (NULL);
            cout << " " << setw (branchSpaceInner) << " " << " ";
         }
         cout << setw (branchSpaceOuter) << " ";
      }  // for levelNodes
      cout << endl;

      // reset spacing; rather complicated, but follows spacing of sample tree at top
      branchSpaceInner = branchSpaceInner / 2;
      if (!(branchSpaceInner % 2)) branchSpaceInner++;
      branchSpaceOuter = branchSpaceOuter / 2;
      if (branchSpaceOuter == 8) branchSpaceOuter--;
      levelNodes *= 2;
      spacing /= 2;
   }  // while treeq()
}


/*********************************************************************/


int binaryTree :: setIndent (int indent) const
// helper method to determine indentation for next level
{
   switch (indent) {
      case 23 : return 17;
      case 17 : return 11;
      case 11 : return 8;
      case  8 : return 5;
      case  5 : return 3;
      case  3 : return 2;
      case  2 : return 1;
      case  1 : return 0;
   }
}


/*********************************************************************/