Трассировка по коду связанного списка

Question

Вот связанный список, где pList указывает на узел, содержащий значение 3

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

Учитывая следующий код, перерисовать список, показывающий изменения в списке после выполнения следующего кода.

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

Вот моя интерпретация происходящего: 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

Я не верю, что это правильно. Что я делаю не так?

Answer 1

Что он на самом деле делает, так это:

Мы начинаем со следующего:

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

Затем мы перемещаем pCur на один шаг вперед, а pCur-> next-> next! = NULL, поэтомув итоге мы получим

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

Затем мы прикрепим заголовок списка к хвосту

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

Это даст нам бесконечно круговой список.

Затем мы переместимсяpList указывает на pCur-> next

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

Если мы переместим это так, что pList будет первым (что мы можем сделать, поскольку он бесконечно круговой):

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

Мы наконецскажем, что то, что следует за pCur, равно NULL, что дает нам:

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

Как вы можете видеть, для этого нужно переместить последний элемент списка вперед.

Answer 2

Вы пропускаете ссылки, поэтому вы не можете показать эффект pCur->next = NULL. Также pCur->next->next = pList устанавливает pCur, а не pList.

Программировать рисование довольно просто:

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");
}