FIND the location of insertion before you can insert the element.

That is because head points to the first element of the list...

So you do NOT need to find the insert location :-)

Creating variables is reserve some unused memory for storage

New list elements can be created (new memory reserved) and then linked into an existing list

new TYPE;

• The new operator operates on a type.

• The new operator will reserves an amount of memory space (i.e., "create one variable") to store a variable of the type type

• The new operator returns the (first) address of the reserved memory

NOTE: Don't be surprised that an operator returns an address.

In fact, you have seen such an operator before:

&(variable) returns the address of variable

NOTE: since new TYPE returns an address of type TYPE, we must store the return value in a variable of the reference type:

TYPE *ptr;

class ListElem { int value; ListElem *next; }; ListElem *p; // p will receive the address p = new ListElem; p->value = 1234; p->next = ...;

ListElem head = NULL;

Assume: head = start of linked list (or NULL for empty list) (1) Make a new list element: ListElem *elem; elem = new ListElem; (2) Fill the information portion of the list element: elem->value = 1500; (3) Link new element at start of list: elem.next = head; // Make new list element points // to the start of "old list" head = elem; // Make "head" points to // the **new** starting object

1. This is the initial situation - the list is empty

2. The new operation creates a new list variable :

   • The statement p->value = 1500 stores the value 1500 in the "value" field.

3. Then the two linking statements links the new list variable before the first element in the list:

1. This is the initial situation - it is the list after the first insertion (redrawn a little):

2. The new operation creates another list variable :

   • The new value is assigned by p->value = 1234

3. Then the two linking statements links the new list variable before the first element in the list:

First list element = 1234 Second list element = 1500 End of list (NULL)

class ListElem { public: int value; // Integer ListElem *next; // Pointer used to make link }; int main(int argc, char *argv[]) { ListElem *head, *elem; // Empty list head = NULL; // Insert first element elem = new ListElem; elem->value = 1500; elem->next = head; head = elem; // Insert second element elem = new ListElem; elem->value = 1234; elem->next = head; head = elem; }

• Prog file: click here

Well, insert a new list element at head is a well-defined task

The start (head) of the list The new list element

NOTE: we assume that the value in the list element has already been initialized (that is NOT part of the insert algorithm !)

The start (head) the new list

NOTE: there are 2 ways to return the head value:

Return the new head as the function value Return the new head using a variable (that must be passed by-reference

class ListElem { public: int value; ListElem *next; }; ListElem * InsertAtHead(ListElem * head, ListElem * elem) { elem->next = head; // Make new list element points // to the start of "old list" return(elem); // Return the new head }

int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; head = InsertAtHead(head, p); // <--- record the new head in "head" }

• Prog file: click here

class ListElem { public: int value; ListElem *next; }; // The "head" variable is BOTH input and output variable ! void InsertAtHead(ListElem * & head, ListElem * elem) { elem->next = head; // Make new list element points // to the start of "old list" head = elem; // Make link AND return NEW head value }

NOTE: The head parameter MUST be passed by-reference

(Otherwise, the function CANNOT change the variable head in main's scope !!!)

int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; InsertAtHead(head, p); // <--- pass "head" by reference }

• Prog file: click here