Linked list code and README file added

Author: me-shaon

Data Structure/Linked List/README.md

@@ -0,0 +1,39 @@
+# Linked List
+
+A **linked list** is a linear data structure where each element is a separate object.
+Each element (known as *node*) of a list is comprising of two items - the data and a reference to the next node. The last node has a reference to null. The entry point into a linked list is called the head of the list. It should be noted that head is not a separate node, but the reference to the first node. If the list is empty then the head is a null reference.
+
+![Linked List](linked-list.png)
+
+A linked list is a dynamic data structure. The number of nodes in a list is not fixed and can grow and shrink on demand. Any application which has to deal with an unknown number of objects can use a linked list.
+
+
+**Basic Operations:**
+
+Following are the basic operations supported by a list.
+
+* **Insertion** − Adds an element at the beginning of the list.
+
+* **Deletion** − Deletes an element at the beginning of the list.
+
+* **Display** − Displays the complete list.
+
+* **Search** − Searches an element using the given key.
+
+* **Delete** − Deletes an element using the given key.
+
+
+#### Complexity Analysis
+- Search - O(n)
+- Insertion - O(1)
+- Deletion - O(1) (Deletion from beginning)
+- Deletion in middle - Searching O(n) and deleting O(1)
+- Space - O(n)
+
+#### Array vs Linked List
+http://www.geeksforgeeks.org/linked-list-vs-array/
+
+### More on this topic
+- https://en.wikipedia.org/wiki/Linked_list
+- https://www.hackerearth.com/practice/data-structures/linked-list/singly-linked-list/tutorial/
+- https://www.tutorialspoint.com/data_structures_algorithms/linked_list_algorithms.htm

Data Structure/Linked List/linked-list.png

@@ -0,0 +1,59 @@
+class Node:
+    def __init__(self, item, next):
+        self.item = item
+        self.next = next
+
+class LinkedList:
+    def __init__(self):
+        self.head = None
+
+    # Add an item to the head of the linked list
+    def add(self, item):
+        self.head = Node(item, self.head)
+
+    # Delete the first item of the linked list
+    def remove(self):
+        if self.is_empty():
+            return None
+        else:
+            item = self.head.item
+            self.head = self.head.next
+            return item
+
+    # Find and delete an given item
+    def delete(self, item):
+        if not self.is_empty() and self.head.item == item:
+            self.remove()
+            return True
+        else:
+            current = self.head
+            prev = None
+            while current != None:
+                if current.item == item:
+                    prev.next = current.next
+                    return True
+                prev = current
+                current = current.next
+        return False
+
+    # Check if the linked list is empty
+    def is_empty(self):
+        return self.head == None
+
+    # Search for an item in the list
+    def find(self, item):
+        node = self.head
+        while node != None:
+            if node.item == item:
+                return True
+            node = node.next
+
+        return False
+
+    # Print all the items in the list
+    def show_all_items(self):
+        print("Items in the list:")
+        node = self.head
+        while node != None:
+            print(node.item)
+            node = node.next

Data Structure/Linked List/linked_list.py

@@ -0,0 +1,18 @@
+from linked_list import LinkedList
+
+new_list = LinkedList()
+
+new_list.add(10)
+new_list.show_all_items()
+new_list.add(15)
+new_list.show_all_items()
+new_list.add(5)
+new_list.show_all_items()
+new_list.remove()
+new_list.show_all_items()
+new_list.add(2)
+new_list.show_all_items()
+print(new_list.find(50)) # Testing find with a invalid item
+print(new_list.find(10)) # Testing find with a valid item
+print(new_list.delete(15)) # Testing delete with a valid item
+print(new_list.delete(100)) # Testing delete with a invalid item