Ggtcf

So basically I got this code from my professor but I've never seen anyone write a for loop like this. I dont even know how to start reading it? Can someone tell me how you would read this in English first and then what's the best way to use this in a for loop?
also dont think this info was is needed but just incase, we're working on linkedlists in java.

Thanks in advance

 public void delete(Object el) // find and remove el; 
 if (head != null) // if non-empty list;
 if (el.equals(head.info)) // if head needs to be removed;
 head = head.next;
 else 
 SLLNode pred = head, tmp = head.next;
 for ( ; tmp != null && !(tmp.info.equals(el));
 pred = pred.next, tmp = tmp.next);
 if (tmp != null) // if found
 pred.next = tmp.next;
 

for(x;y;z) ...; 

is equivalent to

x;
while(y) 
 ...;
 z;

So

 for ( ; tmp != null && !(tmp.info.equals(el));
 pred = pred.next, tmp = tmp.next);

is equivalent to:

while(tmp != null && !(tmp.info.equals(el))) 
 pred = pred.next, tmp = tmp.next;

In English, it would be something like

Until we find the element we're looking for, or the end of the list: update the predecessor and current element to their respective next elements

The Java for loop has the form:

for (initialization; termination; increment) 
 statement(s);

Your sample code is:

for ( ; tmp != null && !(tmp.info.equals(el));
 pred = pred.next, tmp = tmp.next);

If we break it down, you can see there:

• is no initialization step


• two parts to the termination
  


• two (comma separated) statements in the increment step

In rough English:

• keep looping until tmp is null or tmp matches the element to be deleted, ie. iterate through the list until we reach the end or find a match


• each time through the loop, increment pred and tmp by pointing them to the next item

A for loop is made up of four parts: the initialization expression, the termination expression, the increment expression, and the body.

(There's also a for-each style loop which has different syntax, but that's not what we're talking about here.)

So to parse this apart:

• The initialization expression is empty (nothing before the first ;)


• The termination expression is tmp != null && !(tmp.info.equals(el)
  


• The increment expression is pred = pred.next, tmp = tmp.next
  


• The body is also empty (after the closing ) of the for expression, the next statement is just ;
  

In plain English:

As long as tmp is not null, but tmp.info is not our desired element el, continue moving pred and tmp to point to the successor elements in the linked list.

The termination condition of this loop is that either tmp is null (if el was not an element of the list at all), or pred points to the node before the node that had el as a value, and tmp points to the node that has el as a value.

Note that this code is written in a very terse style. This kind of style was common for low-level code 20+ years ago; nowadays when I see code like this it makes me think it was written by an old-timer.

I would probably write the same method like this instead:

public void delete(Object item) 
 if (head == null) 
 // The list is empty; we have no work to do.
 return;
 
 if (head.info.equals(item)) 
 // We're deleting the head of the list; just update our head reference.
 head = head.next;
 return;
 
 SLLNode previous = head;
 SLLNode current = head.next;
 while (current != null) 
 if (current.info.equals(item)) 
 // Update the list to skip the current node, then we're done.
 previous.next = current.next;
 return;
 
 // Move to the next node in the list.
 previous = current;
 current = current.next;
 
 // If we reached this point, the item was not found in this list.
 // There's nothing to do, so we're done anyway.