Tracing through Linked List code

Here is a linked list where pList points to the node containing the value 3

pList
  |
  3       7       6       1       2       8       4      5    ->     NULL

Given the following code, redraw the list showing the changes to the list after the following code is executed.

pCur = pList;
while(pCur->next->next != NULL)
   pCur = pCur->next;
pCur->next->next = pList;
pList = pCur -> next;
pCur -> next = NULL;
pCur = NULL;

Here is my interpretation of what is happening: pCur = pList (pCur = pList) | 3 7 6 1 2 8 4 5 -> NULL

pList    pCur  (pCur = pCur->next)
  |       |
  3       7       6       1       2       8       4      5    ->     NULL

         pCur           PList (pCur->next->next = pList)
          |               |
  3       7       6       1       2       8       4      5    ->     NULL

         pCur   pList       (pList = pCur->next)
          |       |
  3       7       6       1       2       8       4      5    ->     NULL


                     (pCur->next = NULL)
 开发者_运维技巧 3       7       6       1       2       8    -> NULL

I don't believe this is correct. What am I doing wrong?

---

What it actually does is this:

We start with the following:

pCur = pList (pCur = pList)
  |
  3       7       6       1       2       8       4      5    ->     NULL

We then move pCur one forward while pCur->next->next != NULL, so we end up with

pList                                           pCur
  |                                               |
  3       7       6       1       2       8       4      5    ->     NULL

Then we attach the head of the list to the tail

pList                                           pCur          pList (again)
  |                                               |             |
  3       7       6       1       2       8       4      5      3      7 ....

This gives us an infinitely circular list.

We then move pList to point to pCur->next

                                                pCur   pList      
                                                  |      |       
  3       7       6       1       2       8       4      5      3      7 ....

If we move this over so that pList is first (which we can do, as it's infinitely circular):

pList                                                   pCur   pList (again)
  |                                                       |      | 
  5       3       7       6       1       2       8       4      5      3      7 ....

We finally say that what follows pCur is NULL, giving us:

pList                                                   pCur   
  |                                                       |      
  5       3       7       6       1       2       8       4    ->     NULL

As you can see, what this does is move the last element of the list up to the front.

---

You're omitting the links, so you can't show the effect of pCur->next = NULL. Also, pCur->next->next = pList sets pCur, not pList.

It's pretty easy to make these drawing programmatically:

void print_list(Link const *pCur, Link const *pList)
{
    Link const *p;

    printf("pCur -> ");
    for (p = pCur; p != NULL && p != pList; p = p->next)
        printf("%d -> ", p->data);
    puts(p == NULL ? "NULL" : "pList");

    printf("pList -> ");
    for (p = pList; p != NULL && p != pCur; p = p->next)
        printf("%d -> ", p->data);
    puts(p == NULL ? "NULL" : "pCur");
}