how last->next = temp works?

Question

This is the code for displaying a linked list from a udemy tutorial here we will take an array and store those values in a linked list. I didn't understand how the code works. in the below code where we are storing the address of the next node how last->next=temp; works where I didn't create a last node like last=new node; I only created the last pointer. I didn't get it can someone explain to me how it's working

#include <iostream>
using namespace std;
 
class Node{
public:
    int data;
    Node* next;
};
 
int main() {
 
    int A[] = {3, 5, 7, 10, 15};
 
    Node* head = new Node;
 
    Node* temp;
    Node* last;
 
    head->data = A[0];
    head->next = nullptr;
    last = head;
 
    // Create a Linked List
    for (int i=1; i<sizeof(A)/sizeof(A[0]); i++){
 
        // Create a temporary Node
        temp = new Node;
 
        // Populate temporary Node
        temp->data = A[i];
        temp->next = nullptr;
 
        // last's next is pointing to temp
        last->next = temp;
        last = temp;
    }
 
    // Display Linked List
    Node* p = head;
 
    while (p != nullptr){
        cout << p->data << " -> " << flush;
        p = p->next;
    }
 
    return 0;
}

Answer 1

The best way to figure out pointers is to draw boxes and arrows with pen(cil) and paper.

Here is a (sad) ASCII rendition of what happens:

head->data = A[0];
head->next = nullptr;
last = head;

head points to a newly created node, and last points to the same place as head:

   head
    |
    v
+------+------+    
| data | next |
|      |(null)|
|      |      |
+------+------+
   ^
   |
  last

Next,

// Create a temporary Node
temp = new Node;

// Populate temporary Node
temp->data = A[i];
temp->next = nullptr;

looks like this:

   head                 temp
    |                    |
    v                    v
+------+------+       +------+------+  
| data | next |       | data | next |
|      |(null)|       |      |(null)|
|      |      |       |      |      |
+------+------+       +------+------+
   ^
   |
  last

Then

last->next = temp;

changes the next member of the node last points to (in the first iteration, this is the same node as head points to):

   head                 temp
    |                    |
    v                    v
+------+------+       +------+------+  
| data | next |       | data | next |
|      |   ---------->|      |(null)|
|      |      |       |      |      |
+------+------+       +------+------+
   ^
   |
  last

And, lastly, you make last point to the most recently created node:

last = temp;

which gives

   head                 temp
    |                    |
    v                    v
+------+------+       +------+------+  
| data | next |       | data | next |
|      |   ---------->|      |(null)|
|      |      |       |      |      |
+------+------+       +------+------+
                         ^
                         |
                        last

and then you repeat the loop from there.

Answer 2

in the below code where we are storing the address of the next node how last->next=temp; works where I didn't create a last node like last=new node; I only created the last pointer.

last is always just a pointer. It starts out equal to head, which is a pointer to the first node. In your loop, you create a new node that temp points to, and then you set the next field of the node to which last currently points to temp, and then you change last so that it now points to that same node, which is the new last node.

Answer 3

You have already initialized the variable last as head using last = head just before the for loop. This is done to ensure the original head does not get modified while adding other nodes to the list. In each iteration, the last node is used to keep track of the last node in the linked list so that every new node gets added to the end of the linked list.