LLN * LLN::mildsort () :

This method is in the LLN class.

It has access to:  next and data.

It does not have access to:  head

The node has a "this", of course.  It needs to "mildsort" that portion of the list from "this" on down in REVERSE alphabetical order.  (It doesn't worry about anything PRECEDING "this" in the list.)

Mildsort:  works under the assumption that the list is already close to sorted.  The ONLY things that might be off are swapped adjacent pairs.

-->E-->F-->C-->D-->A-->B   The list might look this because there are swapped pairs and nothing worse.

-->E-->F-->D-->A-->B-->C   The list won't look like this.  C and A are a swapped pair, but they're not adjacent.

-->E-->F-->D-->B-->A-->C   The list won't look list this.  I COULD swap C and A and then swap C and B, but right now, C is two positions out of place, and mildsort() will never be given anything that involves moving a node two positions.

So, your method should mildsort a list that has already been guaranteed to be a list on which mildsort should work.  You are not allowed to create or destroy nodes or to change data.  You must change pointers only.

Recursion works like always.  Have a base case.  Have next mildsort everything from next on down.  Then decide what to do with this.

***************

void LLN::split (LLN **arr, int len, int wh):

This is part of the LLN class

We have access to:  data and next

We do not have access:  head

You are given an array of Linked List node pointers.

LLN*    *arr:   arr[7], the 7th. linked list pointer in the array.

Legal:  arr[i]->getdata();
Not Legal:  arr->getdata();  (arr is NOT a linked list pointer.  It's an ARRAY of linked list pointers.)

What split does:

REMEMBER:  Don't create or modify nodes.  Don't change data fields.  Only change pointers.

It moves the "this" node into the HEAD of the list stored at arr[wh].  (You're adding to the front of the list stored in that array.)
It then uses recursion to move all the other nodes in the list to the array.

(The first node goes into list 0.  The next node goes into list 1.  The next node goes into list 2., etc.  The array has a length of len, so you will have to wrap around to 0 when you reach the end of the array.

*********

LLN * rejoin (LLN **arr, int len, int wh, LLN *l)

rejoin is NOT in the LL class.  It is NOT in the LLN class.

You do not have access to:  next or data

You do not have access to:  head

You do not have access to:  this

The rejoin method is not part of any class or object.

The rejoin moves the FIRST node (the node at the front) of the list stored in arr[wh] to the head of linked list l  (Remove from the front of arr[wh], add to the front of l.)

Use recursion to move all the other nodes into list l, and then return l, the completely reformed list.

If my node from arr[wh], the next node I place into l comes from arr[wh-1].  Remember to wrap back to the end when you get to position 0 in the array.

*************

REMEMBER:

You must have a base case.  A situation in which no recursion occurs.

Remember to let recursion to the work.  You should only be manually dealing with one node (this) while recursion handles next on down.

If your method returns something, there should be no path through the method that allows you to exit the method without returning that thing.

If you call a method (recursively or otherwise), and that method returns something, use the thing that is being returned in some way or other.