[C] Tworzenie BST - usprawnienie procedury?

Moje pytanie jest raczej banalne. Procedura tworzenia zwykłego BST, którą poniżej przedstawiam, raczej działa. Chodzi mi tylko o pytanie czysto techniczne - czy da się to jakoś usprawnić, żeby nie było zagnieżdżonych pętli while? Tzn. uprościć tak, by zachować funkcjonalność.

binTreeNode *createBST(int *arr, int arrSize) {
  int i;
  binTreeNode *root = NULL, *curr, *newItem;
  for (i = 0; i < arrSize; i++) {
    newItem = allocBinTreeNode();
    newItem -> value = arr[i];
    newItem -> left = newItem -> right = NULL;
    if (root == NULL)                             /* root of BST */
      root = newItem;    
                                        
    else {                                        /* seeking */
      curr = root;
            
      while (curr != newItem) {                   /* until the new item is inserted */
        while ((curr != newItem) && (newItem -> value <= curr -> value)) { /* check left child */
          if (curr -> left == NULL)               /* if no node in the left child */
            curr -> left = newItem;               /* insert */
          curr = curr -> left;                    /* turn left */
        }
        while ((curr != newItem) && (newItem -> value > curr -> value)) {  /* check right child */
          if (curr -> right == NULL)              /* if no node in the right child */
            curr -> right = newItem;              /* insert */
          curr = curr -> right;                   /* turn right */
        }
      }
    }    
  }
  return root;
}

Załączam także definicję struktury i funkcji używanej do alokacji pamięci:

typedef struct binTreeNode {
  int value;
  struct binTreeNode *left;
  struct binTreeNode *right;
} binTreeNode;

binTreeNode *allocBinTreeNode(void) {        /* memory allocation for Node of list */
  return (binTreeNode *) malloc (sizeof(binTreeNode));
}

mowiac ogolnie, ten algorytm zaklada, ze podana tablica nie jest posortowana i budujac drzewo przy okazji zosrtuje te tablice. stad wlasnie wynika miedzy innymi konstrukcja tych petli i notoryczne wyszukiwanie miejsca dla elementu. jesli wejsciowa tablica bylaby juz posortowana, mozna zbudowac drzewo szybciej - bez ciaglego szukania miejsca - chyba nawet liniowo. wydaje mi sie jednak, ze wstepne sortowanie nie jest tutaj oplacalne.. sortowanie (nlong) kontra Twoje budowanie drzewa (tez wyglada na n * logn)

ten kod co masz, IMHO, jest juz zapisany kompaktowo i przejrzyscie. usprawnic sie tego nie da, co najwyzej mozna lekko go poprzestawiac zeby dla kogos innego bylo czytelniejsze. zagniezdzenie petli nie wnosi tutaj nic szkodliwego