MY_TEST

Then sa place to work ah brother but more appropriate place

Big Brother over ten

Asan song

1. '''''
2. • A linked list is similar to an array, it holds values. However, links in a linked list do not have indexes.
3. • This is an example of a double ended, doubly linked list.
4. • Each link references the next link and the previous one.
5. • A Doubly Linked List (DLL) contains an extra pointer, typically called previous pointer, together with next pointer and data which are there in singly linked list.
6. • Advantages over SLL - IT can be traversed in both forward and backward direction.,Delete operation is more efficent'''
9. class LinkedList: #making main class named linked list

10.  **def**  \_\_init\_\_(self):

11.     self.head = None

12.     self.tail = None

14.  **def**  insertHead(self, x):

15.     newLink = Link(x)                            #Create a new link with a value attached to it

16.      **if** (self.isEmpty() == True):                  #Set the first element added to be the tail

17.         self.tail = newLink

18.      **else** :

19.         self.head.previous = newLink             # newLink \<-- currenthead(head)

20.     newLink.next = self.head                     # newLink \<--\> currenthead(head)

21.     self.head = newLink                          # newLink(head) \<--\> oldhead

23.  **def**  deleteHead(self):

24.     temp = self.head

25.     self.head = self.head.next                   # oldHead \<--\> 2ndElement(head)

26.     self.head.previous = None                    # oldHead --\> 2ndElement(head) nothing pointing at it so the old head will be removed

27.      **if** (self.head  **is**  None):

28.         self.tail = None                         #if empty linked list

29.      **return**  temp

31.  **def**  insertTail(self, x):

32.     newLink = Link(x)

33.     newLink.next = None                         # currentTail(tail)    newLink --\>

34.     self.tail.next = newLink                    # currentTail(tail) --\> newLink --\>

35.     newLink.previous = self.tail                #currentTail(tail) \<--\> newLink --\>

36.     self.tail = newLink                         # oldTail \<--\> newLink(tail) --\>

38.  **def**  deleteTail(self):

39.     temp = self.tail

40.     self.tail = self.tail.previous              # 2ndLast(tail) \<--\> oldTail --\> None

41.     self.tail.next = None                       # 2ndlast(tail) --\> None

42.      **return**  temp

44.  **def**  delete(self, x):

45.     current = self.head

47.      **while** (current.value != x):                  # Find the position to delete

48.         current = current.next

50.      **if** (current == self.head):

51.         self.deleteHead()

53.      **elif** (current == self.tail):

54.         self.deleteTail()

56.      **else** : #Before: 1 \<--\> 2(current) \<--\> 3

57.         current.previous.next = current.next # 1 --\> 3

58.         current.next.previous = current.previous # 1 \<--\> 3

60.  **def**  isEmpty(self):                               #Will return True if the list is empty

61.      **return** (self.head  **is**  None)

63.  **def**  display(self):                                #Prints contents of the list

64.     current = self.head

65.      **while** (current != None):

66.         current.displayLink()

67.         current = current.next

68.      **print** ()

70. class Link:

71. next = None                                       #This points to the link in front of the new link

72. previous = None                                   #This points to the link behind the new link

73.  **def**  \_\_init\_\_(self, x):

74.     self.value = x

75.  **def**  displayLink(self):

76.      **print** ("{}".format(self.value), end=" ")