递归复制链接列表

Question

After Googling around for a while I've come to the conclusion that I'm stumped.

The Problem:

Recursively copy a linked list (as well as copy in reverse, but I'll cross that bridge later.)

I have the following code:

// In list.h
struct node {
    int data;
    node * next;
}

// In list.cpp
// Recursive copy wrapper
int list::copy() {                              
    if(!head) {                                 
        return 0;                               
    }                                           
    node *new_node = NULL;
    return copy(new_node, head);                                          
}                                               

// Recursive copy function
int list::copy(node *& dest, node * src) {      
    if(!src) {                                  
        dest = NULL;                            
        return 0;                               
    }                                           

    dest = new node();                          
    dest->data = src->data;
    // *dest->next = src->next;* // Not sure what to do here?

    return copy(dest->next, src->next) + 1; // count number of nodes copied  
}

Note : this is not a homework assignment but rather a question for a preparatory technical interview exam.

At this point, I'm fairly certain I won't be able to achieve this on my own so any help with it would be appreciated. Thanks in advance!

Answer 1

To my understanding, the list needs to be recursively copied first and the reference of the new head needs to point to the head of the copy; this can be done as follows.

int list::copy(node *& dest, node * src)
{      
    if(!src)
    {                                  
        dest = NULL;                            
        return 0;                               
    }                                           

    dest = new node();                          
    dest->data = src->data;

    node* TailCopy = null; // reference to copy of remaining list

    int TotalNumOfNodes = 1 + copy(Tail, src->next) + 1;

    dest->next = TailCopy; // let copy of head refer to copy of tail

    return TotalNumOfNodes;
}

Answer 2

Well, the int list::copy(node *& dest, node * src) is perfectly correct and successfully copies a list tail up to another list tail. The problem lies in the int list() one which is plain non sense: you successfully copies all the nodes of current list in a new chain, and irremediably leak all that memory when done!

If you want to build something that makes sense, you could use your recursive copy in a copy constructor:

list(const list& other) {
    copy(head, other.head);
}

This does not use the return value of the copy (could be static) method, by I can confirm that it is the expected value.