Well, it has been a while since my last article. I have been holidaying away from regular Internet access. I had hoped to cover multiple indirection for advanced pointer use, but my advanced topic kept crashing my computer. I was looking for a more straightforward way of completing the task, but I decided to just give you a quick look at recursive functions.

"What is a recursive function?" I hear you ask. Well, 'recursion' is a term that is used to mean that a function will call itself until it finally reaches a conclusion and unwinds itself all the way back through its calls. I do not think that words are going to describe this as well as examples.

int RecursiveFunction (int i);
int RecursiveFunction (int i)
{
  printf("%d\n", i);
  if (i) RecursiveFunction(i-1);
  printf("%d\n", i);
  return i;
}

This is a reasonable example of simple recursion. The first line is the prototype of the function, and this must be placed up the top of your code. Effectively, all of your prototypes should be up the top of your code or in your header files. The output of a call to this function if called "RecursiveFunction(5);" would be "5,4,3,2,1,0,0,1,2,3,4,5" where the numbers are on alternating lines. Recursive functions can be used for finding out if a sentence is a palindrome or in our case for sorting a Linked List. Here is a look at a palindrome checker.

int IsPalindrome (char str[80]);
int IsPalindrome (char str[80])
{
  // Return true if this is the last letter
  if (strlen(str) == 1) return -1;

  printf("%c with %c\n", str[0], str[strlen(str)-1]);

  char buf[80];
  // Return false if the alternate letters are not the same
  if (str[0] != str[strlen(str)-1]) return (0);

  // Sending the substring
  strcpy(buf, &str[1]);
  buf[strlen(buf)-1] = NULL;

  // Return the result of the Recursive call
  return IsPalindrome(buf);
}

Obviously this function needs "string.h" to be included with it, but you can get the idea. This function recursively calls itself back to the return statement. This is so that the true (-1) or false (0) value that is sent back makes its way to the calling function so that we can determine if the sentence is a palindrome or not. For example, if we fed the sentence "SATAN OSCILLATE MY METALLIC SONATAS" without the spaces into our function like this:

if (IsPalindrome("SATANOSCILLATEMYMETALLICSONATAS"))
  printf("Is a Palindrome");

Then you get the output telling you that it is a Palindrome. There is a printing function in the IsPalindrome function so that you may track the progress of the recursions. Hopefully after studying this for a little while you will get the hang of recursive functions.

Now, I did promise to rewrite the sorting function to be recursive. I actually wrote two versions that are recursive. The original function was long and at times very difficult to understand. Before I give you what I promised, here is the structure that we are dealing with, a doubly linked list:

typedef struct strAddress *AddressPtr_t;
typedef struct strAddress
{
  char Name[31];
  char Address[181];
  char PhoneNo[13];
  AddressPtr_t Next,Prev;
} Address_t;

The first rewrite of the original function was longer, but it was broken into three functions that were all required to do the original work. It was only slightly more readable:

AddressPtr_t SortByNameInit(AddressPtr_t Cur)
{
  //Get to the beginning again
  while (Cur && Cur->Prev)
    Cur = Cur->Prev;
  return Cur;
}

AddressPtr_t SortByNameRecursion(AddressPtr_t Cur)
{
  // The middle loop iteration pointer
  AddressPtr_t Iter = Cur;

  // A boolean value for remembering whether the list was modified or not
  bool Changed = false;

  // Start the Sort
  // If there exists an element, Iter is the next element
  if (Iter) Iter->Next;
  // Reset the Modified switch for this iteration
  while (Iter)
  {
    // If it belongs before Cur, put it there
    if (strcmp(Cur->Name,Iter->Name) > 0)
    {
      // Remove Iter from its location
      if (Iter->Next) Iter->Next->Prev = Iter->Prev;
      Iter->Prev->Next = Iter->Next;
      
      // Insert Iter before Cur
      Iter->Prev = Cur->Prev;
      if (Iter->Prev) Iter->Prev->Next = Iter;
      Iter->Next = Cur;
      Cur->Prev = Iter;
      
      // Set modified flag
      Changed = true;
    }
    // Next iteration
    Iter = Iter->Next;
  }
  if (!Cur || !Changed)
  {
    // Basically keeps iterating until there are no changes and Cur = NULL
    return SortByNameInit(Cur);
  } else if (Changed)
  {
    Cur = SortByNameInit(Cur);          
    return SortByNameRecursion(Cur);
  } else
  {
    // Go to the next value
    if (Cur) return SortByNameRecursion(Cur->Next);
  }
  return SortByNameInit(Cur);
}

AddressPtr_t SortByName(AddressPtr_t Cur)
{
  Cur = SortByNameInit(Cur);
  Cur = SortByNameRecursion(Cur);
  return Cur;
}

SortByName() is called just the same is it was before, but the execution of it is slightly different. The highlighted lines above show where the recursive functions are. I tend to call a function recursively mostly on or after a return operator. The second rewrite of the sort function is broken up into four different functions. It is the most easily read of the group. It does not require deep tabbing to keep code blocks apart:

AddressPtr_t Shuffle(AddressPtr_t Cur)
{
  // This is the reverse of what was happening in SortByNameRec
  // because we are now sorting backwards
  AddressPtr_t Iter, Last = Cur;
  Iter = Last->Prev;

  // Search backwards down the list for the spot to put Cur
  while (Iter && (strcmp(Iter->Name, Cur->Name) > 0))
  {
    // Keep hurtling backwards down the list
    Iter = Last->Prev;
    if (Iter) Last = Iter;
  }

  // If we aren't at the beginning of the list
  if (Iter)
  {
    // Instert Cur this far back down the list
    if (Cur->Prev) Cur->Prev->Next = Cur->Next;
    if (Cur->Next) Cur->Next->Prev = Cur->Prev;
    if (Iter->Next) Iter->Next->Prev = Cur;
    Iter->Next = Cur;
    Cur->Next = Iter->Next;
    Cur->Prev = Iter;
  } else if (Last)
  {
    // If this is the beginning of the list,
    // insert Cur at the beginning
    if (Cur->Prev) Cur->Prev->Next = Cur->Next;
    if (Cur->Next) Cur->Next->Prev = Cur->Prev;
    
    Last->Prev = Cur;
    Cur->Next = Last;
    Cur->Prev = NULL;
  }
  return Cur;
}


AddressPtr_t SortByNameRec(AddressPtr_t Cur)
{
  AddressPtr_t Iter = NULL;
  // Ensure that we actually have a Cur before defining an Iter
  if (Cur) Iter = Cur->Next;
  
  // Ensure that we have an Iter before attempting a comparison
  if (Iter)
    // See if there needs to be a swap
    if (Iter && (strcmp(Cur->Name, Iter->Name) > 0))
    {
      // Shuffle moves Iter down the list
      Shuffle(Iter);
      // Start sorting list from here onwards
      return SortByNameRec(Cur);
    } else
      // Sort from Next Item onwards
      return SortByNameRec(Cur->Next);
  return Cur;
}

AddressPtr_t SortByNameInit(AddressPtr_t Cur)
{
  // return to the head of the list
  while (Cur && Cur->Prev)
    Cur = Cur->Prev;

  return Cur;
}

AddressPtr_t SortByName(AddressPtr_t Cur)
{
  // Reorder the list to its head
  Cur = SortByNameInit(Cur);

  // Do the recursion sort
  Cur = SortByNameRec(Cur);

  // Reorder the list to its head
  Cur = SortByNameInit(Cur);
  return (Cur);
}

This is longer than the original, but I think you will agree with me that it is MUCH easier to read. I have decided to include the original function to underline my point. The original function is located at the end of this file before my conclusion. Anyway, the functionality of the above code is slightly different from the original. It is more efficient. Instead of just moving Iter behind Cur if they need to be swapped, the Shuffle function basically drops Iter down the list as far as it will go and therefore keeping the list behind Cur sorted. It also makes for pleasant reading. It is much healthier on the eyes.

int SortByName(AddressPtr_t Cur)
{
  // The middle loop iteration pointer
  AddressPtr_t Iter = Cur;

  // A boolean value for remembering whether the list was modified or not
  bool Changed;

  //Get to the beginning again
  while (Cur && Cur->Prev)
    Cur = Cur->Prev;

  // Start the Sort
  // If there exists an element, Iter is the next element
  if (Iter) Iter->Next;

  // Basically keeps iterating until there are no changes and Cur = NULL
  while (Changed || Cur)
  {
    // Reset the Modified switch for this iteration
    Changed = false;
    while (Iter)
    {
      // If it belongs before Cur, put it there
      if (strcmp(Cur->Name,Iter->Name) > 0)
      {
        // Remove Iter from its location
        if (Iter->Next) Iter->Next->Prev = Iter->Prev;
        Iter->Prev->Next = Iter->Next;

        // Insert Iter before Cur
        Iter->Prev = Cur->Prev;
        if (Iter->Prev) Iter->Prev->Next = Iter;
        Iter->Next = Cur;
        Cur->Prev = Iter;

        // Set modified flag
        Changed = true;
      }
      // Next iteration
      Iter = Iter->Next;
    }
    if (Changed)
    {
      // Start sorting from the beginning again
      //Get to the beginning again
      while (Cur && Cur->Prev)
        Cur = Cur->Prev;
      // If an element exists, Iter is the next element
      if (Cur) Iter = Cur->Next;
    } else
    {
      // Go to the next value
      if (Cur) Cur = Cur->Next;
      if (Cur) Iter = Cur->Next;
    }
  }
  return 0;
}

I hope that has helped you grasp this wonderful topic of recursion. It really does have a lot of fun possibilities and can be quite useful. I don't think that I have particularly demonstrated to you the more useful implementations, but I will leave it for you to play with. Now is the part where I try and coax you into joining me in my next article on Member Functions. I am sure that you don't need this by now, because you are so desperately dependent on my articles that it is for your own good to read them... Look forward to addicting you more

Cheers, Chris Bennett (a.k.a. Dwarfsoft)

Author: Chris Bennett aka Dwarfsoft
Contact: dwarfsoft@hotmail.com
April 11, 2001
(C) Copyright Chris Bennett , 2001