Linked lists are one very common and handy data structure that can be used in many cases of the practical programming. In this post we’ll assume that we’re talking about singly linked list. This means that each item is pointed by it’s previous item and it points to it’s next item. In this scenario the first item of the list, its head, doesn’t have an ancestor and the last item doesn’t have a successor.

Sometimes, due to bugs or bad architecture or complexity of the applications we can have problems with lists. One very typical problem is having a loop, which in breve means that some of the items of the list is pointed twice, as shown on the image below.

So in first place we need to be sure that there is a loop and then: how can we break it!

There are several algorithms on finding a loop, but here’s one very basic. It’s known as the Floyd’s algorithm or the algorithm of the tortoise and hare.

Overview

The Floyd’s algorithm relies on one very simple idea. Initially we set two pointers to the head of the list.

On each step we increment both pointers, but the hare is incremented by two elements, while the tortoise walks on every single item – as shown on the images bellow.

The tortoise, as it’s clear from the image bellow, is much slower.

As a result if we don’t have a loop in the list the hare will hit the end of the list, but if we do have a loop the hare will catch-up the tortoise inside the loop.

Code

Assuming a typical representation of a singly linked list here’s a sample code in PHP.

The Item Class

class Item
{
    protected $_name = '';
    protected $_key = '';
    protected $_next = null;
    
    public function __construct($key, $name)
    {
        $this->_key = $key;
        $this->_name = $name;
    }
    
    public function setNext(&$next) { $this->_next = $next; }
    public function &getNext() { return $this->_next; }
    
    public function setKey($key) { $this->_key = $key; }
    public function getKey() { return $this->_key; }
    
    public function setName($name) { $this->_name = $name; }
    public function getName() { return $this->_name; }
    
    public function __toString()
    {
        return $this->_key . ' ' . $this->_name . "\n";
    }
}

The List Class

class Linked_List 
{
    protected $_head = null;
    
    public function insert($item)
    {
        if ($this->_head == null) {
            $this->_head = $item;
            return;
        }
        
        $current = $this->_head;
        while ($current->getNext()) {
            $current = $current->getNext();
        }
        
        $current->setNext($item);
    }
    
    public function detectLoop()
    {
        $tortoise = $hare = $this->_head;
        
        if ($hare->getNext() != null) {
            $hare = $hare->getNext()->getNext();
        } else {
            return FALSE;
        }
        
        while ($hare) {
            if ($hare == $tortoise) {
                return $hare;
            }
            
            if ($hare->getNext()) {
                $hare = $hare->getNext()->getNext();
            } else {
                return FALSE;
            }
            
            $tortoise = $tortoise->getNext();
        }
        
        return FALSE;
    }
    
    protected function _isReachable($a, $b) 
    {
        $current = $b;
        while ($current->getNext() != $b) {
            if ($current->getNext() == $a) {
                return $current;
            }
            $current = $current->getNext();
        }
        
        return FALSE;
    }
    
    public function breakLoop()
    {
        if (FALSE === ($loop = $this->detectLoop())) {
            return;
        }
        
        $startOfTheLoop = $this->_head;
        
        while (FALSE === ($lastLoopItem = $this->_isReachable($startOfTheLoop, $loop))) {
            $startOfTheLoop = $startOfTheLoop->getNext();
        }
        
        $pseudoNext = null;
        $lastLoopItem->setNext($pseudoNext);
    }
    
    public function __toString()
    {
        $current = $this->_head;
        $output = '';
        
        while ($current) {
            $output .= $current->getKey() . ' ' . $current->getName() . "\n";
            $current = $current->getNext();
        }
        
        return $output;
    }
}

Initialization

$items = array();
$ll = new Linked_List();

for ($i = 0; $i < 100; $i++) {
    $items[$i] = new Item($i, 'Item #' . $i);
    $ll->insert($items[$i]);
}

// 0 Item #0
// 1 Item #1
// ...
// 99 Item #99
echo $ll;

Breaking the Loop

In order to break the loop we need first to check whether an item is reachable from within the loop. Once we know that we should return the last loop item in order to improve the performance of the next method – breakLoop. This is made with the following method:

    protected function _isReachable($a, $b) 
    {
        $current = $b;
        while ($current->getNext() != $b) {
            if ($current->getNext() == $a) {
                return $current;
            }
            $current = $current->getNext();
        }
        
        return FALSE;
    }

Now we can break the loop by removing the double link to the first item of the loop.

    // member of Linked_List
    public function breakLoop()
    {
        if (FALSE === ($loop = $this->detectLoop())) {
            return;
        }
        
        $startOfTheLoop = $this->_head;
        
        while (FALSE === ($lastLoopItem = $this->_isReachable($startOfTheLoop, $loop))) {
            $startOfTheLoop = $startOfTheLoop->getNext();
        }
        
        $pseudoNext = null;
        $lastLoopItem->setNext($pseudoNext);
    }

Complexity

Assuming that the list length is N and the loop length is M, we’ll break the loop in O((N-M)*M) time complexity only after we’ve found the loop. The question is how fast we can find the loop with the algorithm above? Well the hare is pretty fast and can pass through some of the items of the loop several times, but the tortoise walks sequentially over all the items. The question is will the hare catch-up the tortoise before the last one gets to the end of the loop? The answer is yes and we can think of a single linked list without loops where there are two pointers starting from the beginning of the list. The same question can be translated to: will the faster pointer reach the end before the slower one gets to the middle of the list – well yes.

Finally the answer is O(N) for answering whether there’s a loop and O(M*(N-M)) to break it.

However the good news is that when we work with linked lists we often work only with pointers (which is our case in this post) and thus we don’t need additional memory which makes them very useful. Actually we will see the same advantage in the next algorithm – reversing a linked list, which is more effective than reversing an array.

The linked list is a data structure in which the items are ordered in a linear way. Although modern programming languages support very flexible and rich libraries that works with arrays, which use arrays to represent lists, the principles of building a linked list remain very important. The way linked lists are implemented is a ground level in order to build more complex data structures such as trees.

It’s true that almost every operation we can perform on a linked list can be done with an array. It’s also true that some operations can be faster on arrays compared to linked lists.

However understanding how to implement the basic operations of a linked list such as INSERT, DELETE, INSERT_AFTER, PRINT and so on is crucial in order to implement data structures as rooted trees, B-trees, red-black trees, etc.

Overview

Unlike arrays where we don’t have pointers to the next and the previous item, the linked list is designed to support such pointers. In some implementations there is only one pointer pointing to the successor of the item. This kind of data structures are called singly linked lists. In this case the the last element doesn’t have a successor, so the pointer to its next element usualy is NULL. However the most implemented version of a linked list supports two pointers. These are the so called doubly linked lists.

Let’s take a look at some examples. Here’s an array:

A[2, 'hello', 'world', 13, 31]

We know that A[0] contains the number 2, while A[1] contains the word (string) “hello”. This is the very basic array representation where the indices are consecutive and start from 0.

In that case we know that if we’re looking at the item with index i, its next element has an index i+1, while his predecessor’s index is i-1. Thus we can easily iterate over items. However if we have an array with only 5 elements A[5] doesn’t exists, and in most of the cases is NULL. In other words array items are defined by their indices, and can be accessed directly with their index.

In the other hand most of the programming languages support associative arrays also called hash maps.

An associative array in PHP can be something like this.

$a = array(
	'hello' => 'world',
	31	=> 12,
	'b7'	=> 144,
);

Now because the indices are not consecutive integers we don’t know the successor and the predecessor of the current item. Yes, there is some internal pointer that can give us the link to the previous and the next item, but explicitly we can’t refer them.

Of course some libraries may have functions that can point us to the next item, such a function is next() in PHP.

As we see arrays can replace the typical pointer-like representation of a linked list, but as I said already this data structure is crucial in order to understand more complex data structures.

Typically the linked list is implemented with two classes. The first one describing the item and the other one containing the main operations of the list such as search, insert, delete, etc.

The first class, typically called Item is a normal class containing various info about an item. In terms of persons, for instance, this class can contain the first and last names of the person, his address, phone etc. However it’s very important that this class contains pointers to its previous and its next objects.

In our terms each object of class Person will contain a pointer to a next object of the same class Person.

class Person
{
	public $next = null;
	public $prev = null;
	
	protected $_firstName = '';
	protected $_lastName = '';
	protected $_phone = '';
	
	
	public function __construct($firstName, $lastName, $phone)
	{
		$this->_firstName = $firstName;
		$this->_lastName = $lastName;
		$this->_phone = $phone;
	}
	
	public function __toString()
	{
		return 'First name: ' . $this->_firstName 
			 . ', Last name: ' . $this->_lastName 
			 . ', Phone: ' . $this->_phone;
	}
}

So we must first design the structure of an item.

The following thing to do is to define a linked list as an abstraction over a real world list, just like the stack and the queue. We can implement various operations for a linked list like insert, delete, insertBefore, insertAfter, sort, search, insertSorted etc. It’s up to the developer to decide which operations he wants to use. And of course this depends on the application.

Implementation

Operations

We can perform and define as much operations as we need. For instance we can code a linked list only with the basic insert, delete and print, but we can also go for insertBefore, insertAfter, deleteBefore, deleteAfter, insertSorted, which are described on the diagrams below.

Insert

Inserting in the front of a list seems much like inserting into a queue. In this case the new item becomes the head of the list and its successor is the previous head of the list.

class LList
{
	public $head;
	public $tail;
	
	public function insert($item) 
	{
		$item->next = $this->head;
		
		if ($this->head != null) {
			$this->head->prev = $item;
		}
		
		$this->head = $item;
	}

	public function __toString()
	{
		$cur = $this->head;
		
		$output = '';
		while ($cur) {
			$output .= $cur . ' ';
			
			$cur = $cur->next;
		}
		
		return $output . "\n";
	}
}

$ll = new LList();

$a = new Person('John', 'Smith', '555 9401');
$b = new Person('James', 'Johnes', '555 2454');

$ll->insert($a);
$ll->insert($b);

// James Johnes 555 2454
// John Smith 555 9401
echo $ll;

Delete

Delete the head of the list is much like deleting an item from a queue. However we can implement also deleting a custom element that’s inside the list.

class LList
{
	public $head;
	public $tail;
	
	public function insert($item) 
	{
		$item->next = $this->head;
		
		if ($this->head != null) {
			$this->head->prev = $item;
		}
		
		$this->head = $item;
	}
	
	public function delete($item) 
	{
		$cur = $this->head;
		
		while ($cur) {
			
			if ($cur == $item) {
				$prev = $cur->prev;
				$next = $cur->next;
				
				if ($prev != null) {
					$prev->next = $next;
				} else {
					// because head points to the first item
					$this->head = $next;
				}
				
				if ($next != null) {
					$next->prev = $prev;
				}
				
				return $cur;
			}
		
			$cur = $cur->next;
		}
	}

	public function __toString()
	{
		$cur = $this->head;
		
		$output = '';
		while ($cur) {
			$output .= $cur . ' ';
			
			$cur = $cur->next;
		}
		
		return $output . "\n";
	}
}

$ll = new LList();

$a = new Person('John', 'Smith', '555 9401');
$b = new Person('James', 'Johnes', '555 2454');
$c = new Person('Jeanne', 'Francois', '333 2323');

$ll->insert($a);
$ll->insert($b);
$ll->insert($c);

// prints objects $c, $b, $a:
// Jeanne Francois 333 2323
// James Johnes 555 2454
// John Smith 555 9401
echo $ll;

$ll->delete($b);

// prints objects $c, $a:
// Jeanne Francois 333 2323
// John Smith 555 9401
echo $ll;

Insert before & insert after

Inserting before and after needs a reference to an already existing list item. After that the new object is inserted into it right place, as shown on the images below.

class LList
{
	public $head;
	public $tail;
	
	public function insert($item) 
	{
		$item->next = $this->head;
		
		if ($this->head != null) {
			$this->head->prev = $item;
		}
		
		$this->head = $item;
	}
	
	public function insertAfter($newItem, $item) 
	{
		$cur = $this->head;
		while ($cur) {
			if ($cur == $item) {
				$next = $cur->next;
				
				$cur->next = $newItem;
				$newItem->prev = $cur;
				
				if ($next != null) {
					$newItem->next = $next;
					$next->prev = $newItem;
				}
				return;
			}
			$cur = $cur->next;
		}
		
		$this->head = $this->tail = $item;
	}

	public function __toString()
	{
		$cur = $this->head;
		
		$output = '';
		while ($cur) {
			$output .= $cur . ' ';
			
			$cur = $cur->next;
		}
		
		return $output . "\n";
	}
}

$ll = new LList();

$a = new Person('John', 'Smith', '555 9401');
$b = new Person('James', 'Johnes', '555 2454');
$c = new Person('Jeanne', 'Francois', '333 2323');

$ll->insert($a);
$ll->insert($c);

// inserts $b after $a
$ll->insertAfter($b, $c);

// Jeanne Francois 333 2323
// James Johnes 555 2454
// John Smith 555 9401
echo $ll;

Insert a new object before an item is the same as insert after, but instead of splitting the list after the given item, we split it before it.

Search

Searching into a list can be modified depending on the application needs. Here we just compare the searched object with a list item.

class LList
{
	public $head;
	public $tail;
	
	public function insert($item) 
	{
		$item->next = $this->head;
		
		if ($this->head != null) {
			$this->head->prev = $item;
		}
		
		$this->head = $item;
	}
	
	public function insertAfter($item, $key) 
	{
		$cur = $this->head;
		while ($cur) {
			if ($cur->data == $key) {
				$next = $cur->next;
				
				$cur->next = $item;
				$item->prev = $cur;
				
				if ($next != null) {
					$item->next = $next;
					$next->prev = $item;
				}
				return;
			}
			$cur = $cur->next;
		}
		
		$this->head = $this->tail = $item;
	}

	public function search($item)
	{
		$cur = $this->head;
		
		while ($cur) {
			if ($cur == $item) {
				return 1;
			}
			
			$cur = $cur->next;
		}
		
		return 0;
	}
	
	public function __toString()
	{
		$cur = $this->head;
		
		$output = '';
		while ($cur) {
			$output .= $cur . ' ';
			
			$cur = $cur->next;
		}
		
		return $output . "\n";
	}
}

$ll = new LList();

$a = new Person('John', 'Smith', '555 9401');
$b = new Person('James', 'Johnes', '555 2454');
$c = new Person('Jeanne', 'Francois', '333 2323');

$ll->insert($a);
$ll->insert($b);

// 1, because $b is in the list
echo $ll->search($b);

// 0, cause $c isn't in the list
echo $ll->search($c);

The operations here are only one sub-set of all possible operations you can implement on a linked list. It all depends on our needs. However the principles are important, so we can implement more complex data structures.

Application

It’s true that linked list are a very basic data structure. Someone may wonder why we should code and implement linked list since we can do the same (with almost every modern programming language/library) with arrays. The answer is that data structures as trees are difficult to implement with arrays, so it’s easy to code them using pointers. Thus linked lists is a ground level for understanding them. Indeed each linked list is a tree with only one branch as shown on the image below.

I’ve posted about Zend_Http_Client. Simply there you can ‘make’ your own http client and you can request a remote file. Just to check what’s going on with this file.

// new HTTP request to a file
$httpClient = new Zend_Http_Client('http://www.example.com/myfile.mp4');

// get the HEAD of the response and match agains the
// Content-Length. That's because using the Content-Type is slower
$response = $httpClient->request(Zend_Http_Client::HEAD);

// if the Content-Length is 0 the file doesn't exists
if (0 === (int)$response->getHeader('Content-Length')) {
	echo 'the file doesn\'t exits';
}

However is there any other way to answer the same question?

fopen()

Yes and no? Perhaps yes, but you should be careful. I’m still not sure it can be used in any case. However here’s the snippet.

if (FALSE === @fopen('http://www.example.com/myfile.mp4', 'r')) {
	echo 'the file doesn\'t exists';
}

fopen() will return FALSE whenever the file doesn’t exists.

In both cases I request a remote file – an MPEG-4 file. Note that fopen()’s first parameter can be a HTTP resource.

This is a common task. You’d like to know whether the image on the remote server exists. Zend Framework gives the answer of this question and in particular this can be completed with Zend_Http_Client.

Content-Type and Content-Length

The little problem is that checking for content-type is not always correct, because it will return an image content type even when the image does not exists, so it’s better to check for content-length.

Code

The simple way to check this is like that:

$client = new Zend_Http_Client('http://remote-machine/image.jpg');
$response = $client->request('head');
if ( NULL == $response->getHeader('Content-Length') )
    // do whatever if the image does not exists.

In fact here, in this example I don’t check for GET request, because is way to slow than the HEAD method, but you should be aware of incorrect responses when using HEAD. In fact if you request the HEAD of a FLV video it will be returned text content-type, while using GET everything’s working fine but slow though.