Merge pull request ZoranPandovski#48 from dcariotti/patch-3

Order data structures (and linkedlist)

data_structures/linked_list/README.md

@@ -0,0 +1,18 @@
+In computer science, a linked list is a linear collection of data elements, in which linear order is not given by their physical placement in memory. Each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represent a sequence. Under the simplest form, each node is composed of data and a reference (in other words, a link) to the next node in the sequence. This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration. More complex variants add additional links, allowing efficient insertion or removal from arbitrary element references.
+
+## Single linked list
+Singly linked lists contain nodes which have a data field as well as a 'next' field, which points to the next node in line of nodes. Operations that can be performed on singly linked lists include insertion, deletion and traversal.
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+## Double linked list
+In a 'doubly linked list', each node contains, besides the next-node link, a second link field pointing to the 'previous' node in the sequence. The two links may be called 'forward('s') and 'backwards', or 'next' and 'prev'('previous').
+
+![](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg)
+
+## Circular linked list
+In the last node of a list, the link field often contains a null reference, a special value used to indicate the lack of further nodes. A less common convention is to make it point to the first node of the list; in that case the list is said to be 'circular' or 'circularly linked'; otherwise it is said to be 'open' or 'linear'.
+
+![](https://upload.wikimedia.org/wikipedia/commons/d/df/Circularly-linked-list.svg)
+
+[Credits](https://en.wikipedia.org/wiki/Linked_list)

data_structures/linked_list/go/Linkedlist.go

@@ -0,0 +1,102 @@
+package main
+
+import "fmt"
+
+/* v is the value of node; next is the pointer to next node */
+type node struct {
+	v int
+	next *node
+}
+
+/* first node, called head. It points from first node to last node */
+var head *node = nil
+
+func (l *node) pushFront(val int) *node {
+	/* if there's no nodes, head points to l (first node) */
+	if head == nil {
+		l.v = val
+		l.next = nil
+		head = l
+		return l
+	} else {
+		/* create a new node equals to head */
+		nnode := new(node)
+		nnode = head
+		/* create a second node with new value and `next -> nnode`
+		*  is this way, nnode2 is before nnode
+		*/
+		nnode2 := &node {
+			v: val,
+			next: nnode,
+		}
+		/* now head is equals nnode2 */
+		head = nnode2
+		return head
+	}
+}
+
+func (l *node) pushBack(val int) *node {
+	/* if there's no nodes, head points to l (first node) */
+	if head == nil {
+		l.v = val
+		l.next = nil
+		head = l
+		return l
+	} else {
+		/* read all list to last node */
+		for l.next != nil {
+			l = l.next
+		}
+		/* allocate a new portion of memory */
+		l.next = new(node)
+		l.next.v = val
+		l.next.next = nil
+		return l
+	}
+}
+
+func (l *node) popFront() *node {
+	if head == nil {
+		return head
+	}
+	/* create a new node equals to first node pointed by head */
+	cpnode := new(node)
+	cpnode = head.next
+
+	/* now head is equals cpnode (second node) */
+	head = cpnode
+
+	return head
+}
+
+func (l *node) popBack() *node {
+	if head == nil {
+		return head
+	}
+	/* create a new node equals to head */
+	cpnode := new(node)
+	cpnode = head
+
+	/* read list to the penultimate node */
+	for cpnode.next.next != nil {
+		cpnode = cpnode.next
+	}
+	/* the penultimate node points to null. In this way the last node is deleted */
+	cpnode.next = nil
+	return head
+}
+
+func main() {
+	lista := new(node)
+	lista.pushBack(25).pushBack(24).pushBack(32) /* lista: 25 24 32 */
+	lista.pushBack(56) /* lista: 25 24 32 56 */
+	lista.pushFront(36) /* lista: 36 25 24 32 56 */
+	lista.popFront() /* lista: 25 24 32 56 */
+	lista.popBack() /* lista: 25 24 32 */
+
+	/* read the list until head is not nil */
+	for head != nil {
+		fmt.Printf("%d ",head.v)
+		head = head.next /*head points to next node */
+	}
+}