Merge pull request #188 from cebial/master

Rewrite of the linked-list problem.

Author: kytrinyx

linked-list.md

@@ -1,29 +1,34 @@
-Deques have four fundamental operations (using Array terminology):
+Like an array, a linked list is a simple linear data structure. Several 
+common data types can be implemented using linked lists, like queues, 
+stacks, and associative arrays.
 
-* push (insert value at back)
-* unshift (insert value at front)
-* pop (remove value at back)
-* shift (remove value at front)
+A linked list is a collection of data elements called *nodes*. In a 
+*singly linked list* each node holds a value and a link to the next node. 
+In a *doubly linked list* each node also holds a link to the previous 
+node.
 
-The difference between deque and Array performance is that a deque
-implements all of these operations in constant time. Even clever
-implementations of Array will often have to copy the entire Array in
-order to unshift.
+You will write an implementation of a doubly linked list. Implement a 
+Node to hold a value and pointers to the next and previous nodes. Then 
+implement a List which holds references to the first and last node and 
+offers an array-like interface for adding and removing items:
 
-Under the hood we'll use an Element class with two fields, `next` and
-`prev`, that are both writable.
+* `push` (*insert value at back*);
+* `pop` (*remove value at back*);
+* `shift` (*remove value at front*).
+* `unshift` (*insert value at front*);
 
-To make the API usable, you'll use a Deque class as a proxy for this
-list. There two good ways to implement Deque: maintain separate
-references to the first and last Element, or maintain a reference to one
-of them and ensure that the list is circular.
+To keep your implementation simple, the tests will not cover error 
+conditions. Specifically: `pop` or `shift` will never be called on an 
+empty list.
 
-To keep your implementation simple, the tests will not cover error
-conditions. Specifically: pop or shift will never be called on an empty
-Deque.
+If you want to know more about linked lists, check [Wikipedia](https://en.wikipedia.org/wiki/Linked_list).
+
+---
 
 In languages that do not have good support for mutability (such as
-Elixir or Erlang), you may choose to implement a functional Deque where
+Elixir or Erlang), you may choose to implement a functional list where
 shift and pop have amortized O(1) time. The simplest data structure for
 this will have a pair of linked lists for the front and back, where
 iteration order is front ++ reverse back.
+
+

linked-list.yml

@@ -1,4 +1,3 @@
 ---
-blurb: "Write a Singly-Linked List implementation that uses the Proxy pattern"
-source: "Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists."
-source_url: "http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000"
+blurb: "Implement a doubly linked list"
+source: "Classic computer science topic"