C＃内存分配和链接列表实现

Question

I have some questions about how exactly C# implement the linked list class first question:

public class Node {  
    int data;  
    Node next;   
} 

it looks like the rather than a linked list, it is a Big object with recursive same class inside

my second question is more specific, for a simple reverse linked list algorithm like below:

 public void ReverseList(ref ListNode head){
    if(head ==null || head.next == null) return head;
    ListNode cur = head;
    ListNode prev = null;
    ListNode next = head.next;
    while (cur != null){
        ListNode nextNode = head.next;
        cur.next= prev;
        prev=cur;
        cur=nextNode;
    }
    head = prev ;
} 

isn't cur = head means the "cur" copy ALL linked list elements? And it is much harder to think what was going on in the algorithm.

Answer 1

it looks like the rather than a linked list, it is a Big object with recursive same class inside

Node is a class , which means that the field Node next; is a reference (broadly interchangeable with a pointer, in terms of terminology). So no: it is definitely a linked list. Node doesn't contain a Node . It contains a field which is a reference (think: pointer) to another Node .

isn't cur = head means the "cur" copy ALL linked list elements?

It isn't copying any elements. It is changing the reference field (think: pointer) on some existing objects, and that's it . No copying. It is, however, visiting all the elements and changing the pointers on them all - so if you count "copying the references (think: pointers) on all elements": sure, it is doing that. There aren't any allocations involved, etc.

Answer 2

Linked list uses references to create the list structure.

The key point is to understand the distinction between value and reference types in C#. Value types like int , bool or struct are really values that are stored in stack and when you assign them, you are actually copying the data from one location to another. Reference types are classes in C# and the distinction is that they are just pointers to data in memory heap. By default, they are null and you first must allocate memory for them on the heap so that they actually point somewhere using new .

In this case you have a field of type Node as a property of the Node class, which is fine, because this is either just null or it points to another location in memory heap where the next node is stored. If you changed the class to struct , this would not compile, as this would cause the "recursive" problem you are mentioning. But with classes it is just a reference and the default value is null , so it doesn't have to point to an instance and instantiating a Node creates just one Node instance in memory, with next == null .

This should help you understand the second question as well - setting next = head means you are just making next point to the same place head is pointing in memory. You are not moving any data, you are just setting the reference.

I find it helpful to use images when building linked list algorithms. you can imagine each next field just as an arrow that points somewhere. And when the value is null it just points "nowhere". Finally, when you assign something to next you just change where the arrow points.