- New list elements were previous
"created" (memory reserved)
using the
new
memory allocation operator
- When list elements are
deleted
from the list (i.e., they are
no longer needed ),
it is
important
that we "unreserve"
the memory space used to store the variable.
- NOTE:
- If you
do NOT free up (un-reserve)
the memory space,
your program
may exhause all available memory
(Whether or not your program will exhause the available memory depends on how much memory your program will allocate throughout its execution.
Long running programs and keeps allocating memory has a very high probability of exhausting the memory)
- If all available memory are allocated , then a subsequent new operation will fail; causing your program to crash
- If you
do NOT free up (un-reserve)
the memory space,
your program
may exhause all available memory
- The delete
operator is used to
un-reserve (return)
the reserved memory space
(that was previously reserved by
new)
- Syntax of the delete operator:
Syntax: delete PointerVariable;
Example: ListElem *p; p = new ListElem; // Allocate memory space ... delete p; // Deallocate memory space
- When deleting from a linked list ,
you must first
find the following 2 elements :
- The element that you want to
delete
( p2 )
- The predecessor (preceeding element) of the element that you want to delete ( p1 )
The predecessor is needed to make the neccesary linkage !
- The element that you want to
delete
( p2 )
- To
delete
the element
p2
from the list, you make
p1
point to the
successor of
p2 :
p1->next = p2->next; - Result:
- Do NOT forget to de-allocate memory space
after you unlink the element from the list:
delete p2;
- The following diagram depicts the elements
p1
and
p2
when
deleting the first element:
p2 points to the first element in the list
Although there is no element before p2 , we can look at head as the element p1 - because it points to p2
- How to remove the
FIRST element from a list:
- Algorithm: delete first element from list
ListElem *p2; if (head != NULL ) // Make sure list is not empty { p2 = head; // p2 points to element to delete head = p2->next; // Make p1 (head) point to p2's successor delete p2; // De-allocate memory !! }
- Again, it is good software engineering practice
to
write a function
to
perform a well-defined task
The delete element at head is a well-defined task
- Input parameters: What information
does the function need to do the job
- The start (head) of the list
- Output parameters: What information
does the function return
- The start (head) the new list (without the first element)
NOTE: again, 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
- Algorithm:
ListElem * DeleteAtHead(ListElem * head) { ListElem *p2; if (head == NULL ) // If list is empty, return(NULL) return(NULL); p2 = head; // Delete p2 head = p2->next; delete p2; // Return memory !! return(head); // Return new head }
- How to use this function:
int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; head = DeleteAtHead(head); // <--- record the new head in "head" }
- Example Program:
(Demo above code)
- Prog file: click here
- Algorithm:
void DeleteAtHead(ListElem * & head) { ListElem *p2; if (head == NULL ) // If list is empty, return(NULL) return; p2 = head; // Delete p2 head = p2->next; // Unlink AND return new head delete p2; // Return memory !! }
- How to use this function:
int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; DeleteAtHead(head); // <--- record the new head in "head" }
- Example Program:
(Demo above code)
- Prog file: click here
- The following diagram depicts the elements
p1
and
p2
when
deleting the first element:
p2 points to the last element in the list
p1 points to the last-but-one element in the list
- Just like inserting in a list, before you can
delete
an element from the list,
you must first
find that element
In the delete operation , you must also find the element before the one you want to delete
-
Finding the last and last-but-one elements
p1 = head; // First element in list p2 = head->next; // Second element in list while ( p2->next != NULL ) { p1 = p2; p2 = p2->next; }Pictorially:
-
Initial step:
When while loop ends:
-
Delete (unlink) the last element
p1->next = NULL; delete p2; // De-allocate memory
Pictorially:
- As in insertion, we must also
determine
and
process
exception cases
in deletion...
- If you look at the deletion:
You will notice that head is not changed by the deletion
- There is a special case
in deleting when
head
must be changed:
the list has only one element in it...
After deletion of the (only) element, the list becomes empty:
- Delete at tail algorithm:
ListElem *p2; ListElem *p1; if ( head != NULL ) // Delete only from non-empty list { if ( head->next == NULL ) { // Handle special case: List has 1 element p2 = head; // Delete this element head = NULL; delete p2; // Deallocate space } else { // The general case // Find the last-but-one "p1" and last "p2" elements p1 = head; p2 = head->next; while ( p2->next != NULL ) { p1 = p2; p2 = p2->next; } // Delete element following the "p1" element p1->next = NULL; delete p2; // Deallocate space } }
- First, determine the input parameters: What information
does the function need to do the job
- The start (head) of the list
- Then, determine the output parameters: What information
does the function return
- The start (head) the new list (without the first element)
NOTE: again, 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
- Algorithm:
ListElem * DeleteAtTail(ListElem * head) { ListElem *p2; ListElem *p1; if ( head == NULL ) // Delete only from non-empty list { return; } else { if ( head->next == NULL ) { // Handle special case: List has 1 element delete head; // Deallocate space return(NULL); } else { // The general case // Find the last-but-one "p1" and last "p2" elements p1 = head; p2 = head->next; while ( p2->next != NULL ) { p1 = p2; p2 = p2->next; } p1->next = NULL; // Delete element following list delete p2; // Deallocate space return(head); } } }
- How to use this function:
int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; head = DeleteAtTail(head); // <--- record the new head in "head" }
- Example Program:
(Demo above code)
- Prog file: click here
- Algorithm:
void DeleteAtTail(ListElem * & head) { ListElem *p2; ListElem *p1; if ( head == NULL ) // Delete only from non-empty list { return; } else { if ( head->next == NULL ) { // Handle special case: List has 1 element delete head; // Deallocate space head = NULL; // Return new head in "head" } else { // The general case // Find the last-but-one "p1" and last "p2" elements p1 = head; p2 = head->next; while ( p2->next != NULL ) { p1 = p2; p2 = p2->next; } // Delete element following the "p1" element p1->next = NULL; delete p2; // Deallocate space // head = head; <---- head is unchanged... } } }
- How to use this function:
int main(int argc, char *argv[]) { ListElem *head, *p; head = NULL; // Empty list p = new ListElem; p->value = 1500; DeleteAtTail(head); // <--- record the new head in "head" }
- Example Program:
(Demo above code)
- Prog file: click here
- Sometimes, you may want to delete a
specific element
from a list
- Example:
Delete the first element that has a negative value
- Set p1 and p2
(in the general case):
p1 = head; p2 = head->next; while ( p2->value >= 0 ) { p1 = p2; p2 = p2->next; }
- To
delete
the element
p2
from the list, you make
p1
point to the
successor of
p2 :
p1->next = p2->next; delete p2;
- The general case
does NOT change head
- The
exception case
is:
deleting the first element
- How to detect the special case:
if ( head->value < 0 )
- How to handle the special case:
p2 = head; head = head->next; delete p2; // Deallocate space
- FIRST VERSION: Delete the first negative value algorithm:
ListElem *p1, *p2; if ( head == NULL ) { head = NULL; } else { // Special case: delete the first element if ( head->value < 0 ) { p2 = head; head = head->next; delete p2; // Deallocate space } else // General case { p1 = head; p2 = head->next; // Find an element with neg. value while ( p2->value >= 0 ) { p1 = p2; p2 = p2->next; } p1.next = p2->next; delete p2; // Deallocate space } }
- Example Program:
(Demo above code)
- Prog file: click here
- Problem....
- When you run this program, you will get a core dump...
List ==> List ==> 1500 List ==> -2500 1500 List ==> 3500 -2500 1500 List ==> 4500 3500 -2500 1500 List ==> -5500 4500 3500 -2500 1500 List ==> 4500 3500 -2500 1500 List ==> 4500 3500 1500 Segmentation Fault(coredump)
Deletion failed when there are no negative elements !!
- Use the debugger to find the problem:
- CC -g -o delete3a delete3a.C
- dbx delete3a
- dbx>> run
signal SEGV (no mapping at the fault address) in DeleteNeg at line 50 in file "delete3a.C" 50 while ( p2->value >= 0 ) (dbx) print p2 p2 = (nil)
- The variable
p2
became NULL
This happens when it p2 reach the end of the list
- When you run this program, you will get a core dump...
- SECOND VERSION: Delete the first negative value algorithm:
ListElem *p1, *p2; if ( head == NULL ) { head = NULL; } else { // Special case: delete the first element if ( head->value < 0 ){ p2 = head; head = head->next; delete p2; // Deallocate space } else // General case { p1 = head; p2 = head->next; // Find an element with neg. value while ( p2 != NULL && p2->value >= 0 ) { p1 = p2; p2 = p2->next; } p1.next = p2->next; delete p2; // Deallocate space } }
- Example Program:
(Demo above code)
- Prog file: click here
- Problem....
- When you run this program, you will get a core dump...
List ==> List ==> 1500 List ==> -2500 1500 List ==> 3500 -2500 1500 List ==> 4500 3500 -2500 1500 List ==> -5500 4500 3500 -2500 1500 List ==> 4500 3500 -2500 1500 List ==> 4500 3500 1500 Segmentation Fault(coredump)
Deletion failed AGAIN when there are no negative elements !!
Hmm... what did we miss ???
- Use the debugger to find the problem:
- CC -g -o delete3b delete3b.C
- dbx delete3b
- dbx>> run
signal SEGV (no mapping at the fault address) in DeleteNeg at line 50 in file "delete3a.C" 56 p1->next = p2->next; (dbx) print p1 p1 = 0x28c00 (dbx) print p2 p2 = (nil)
- The variable
p2
is NULL
(so p2->next
is illegal)
We must not perform delete when there is no negative element
- When you run this program, you will get a core dump...
- THIRD VERSION: Delete the first negative value algorithm:
ListElem *p1, *p2; if ( head == NULL ) { head = NULL; } else { // Special case: delete the first element if ( head->value < 0 ){ p2 = head; head = head->next; delete p2; // Deallocate space } else // General case { p1 = head; p2 = head->next; // Find an element with neg. value while ( p2 != NULL && p2->value >= 0 ) { p1 = p2; p2 = p2->next; } if ( p2 != NULL) { p1.next = p2->next; delete p2; // Deallocate space } } }
- Example Program:
(Demo above code)
- Prog file: click here
It finally works :-)