1. Chapter 5 Linked List by www.asyrani.com

2. Before you learn Linked List 3 rd level of Data Structures Intermediate Level of Understanding for C++ Please make sure to properly and slowly digesting the topics. We are going to take a deep breath now

3. List Definition List – A sequence of elements in certain linear order [English] List is where you put what to do one by one in sequence

4. Basic Operations TraversingSearching/retrievingInserting Removing/deleting an element given its position

5. Basic Operations [English] Traversing – Where you navigate your shopping list one by one Searching/Retrieving – Where you starting to find out specific items that you want to buy in your shopping list Inserting – Insert new stuff to buy in your shopping list Removing/Deleting – Where you strike out the things that you have bought

6. Types of common lists Stacks and queues, where insertions and deletions can be done only at the head or the tail of the sequence. That is the rules!!! HeadTail

7. POINTER

8. Let’s Learn First, how do you declare an integer? int nombor;

9. Let’s Learn First, how do you declare an integer?

10. Let’s Learn Output

11. Next Step Ok, that is how you declared an integer. But now I want to declare one more integer but I put * at the beginning of the variable name int *getdata;

12. Next Step Now, let say that I want to put that *getdata a value. So what the output??? int *getdata; *getdata = 100;

13. Let’s Learn Coding

14. Let’s Learn Output

15. Let’s Learn Output How come that you get an address???

16. Let’s Learn Back to coding

17. Let’s Learn So, actually, I do not put * at the beginning of variable getdata. So, let’s change

18. Let’s Learn New Output

19. Let’s Learn So, it looks like an integer but why we want to use *?

20. Explaination *getdata variable is a pointer based integer It points to an address. So, actually, it is not the value of getdata that change, it is another address.

21. Explaination Address0xFF30xFF40xFF5 Variable Name nomborNULL Inside This Address NULL Our First Implementation

22. Explaination Address0xFF30xFF40xFF5 Variable Name nomborNULL Inside This Address 900NULL We put an input “cin >> nombor” Let say we put 900 as an input

23. Explaination Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 9000xFF5NULL Then, we declared a pointer based integer type

24. Explaination Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 9000xFF5NULL If you guys see, getdata actually store an address instead of value. If we try to print out it, we will get an address

25. Explaination Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 9000xFF5NULL Then, if we try to set *getdata to some value. It actually set up the 0xFF5 with a value. Let say *getdata = 100

26. Explaination Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 9000xFF5100 Then, if we try to set *getdata to some value. It actually set up the 0xFF5 with a value. Let say *getdata = 100

27. So, what is happening? Declare *getdata will only store address forever and not a value. You cannot declare “getdata = 100” = ERROR You guys can only declare “*getdata = 100” You guys can also assign nombor to *getdata value (which is an address) using ampersand symbol

28. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 9000xFF5100 getdata = &nombor

29. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 900 0xFF3 100 getdata = &nombor

30. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 900 0xFF3 100 *getdata = &nombor ERROR!!!

31. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 900 0xFF3 100 int *getdata = &nombor RIGHT!!!

32. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 900 0xFF3 100 WHAT IF nombor = *getdata

33. Explanation Address0xFF30xFF40xFF5 Variable Name nomborgetdataNULL Inside This Address 900 0xFF3 100 “nombor” still display 900 as “getdata” point to the variable “nombor”

34. Conclusion *getdata display a value of variable address & (ampersand) is used to set getdata to get an address Pointers is used to parse a value from a function to another function

35. LINKED LIST

36. What is Linked List? A linked list is a series of nodes Node 0Node 4Node 1

37. What is Linked List? Each node holds an item of data and a pointer(s) to the next node in the list Node 0Node 4Node 1 Point to Node 1 Point to Node 3 Node 2Node 3

38. What is Linked List? The last node's pointer is set to null NULL means end of node/no more nodes Node 0Node 4Node 1 NULL

39. What is Linked List? In order to hold on to a list, a program holds a pointer to the first node of the list. Node 0Node 4Node 1 PROGRAM Point to

40. Advantages Contain data of any type, including objects of other classes. Dynamic, so the length of a list can increase or decrease as necessary Full only when the system has insufficient memory Can be maintained in sorted order by inserting each new element at the proper point in the list linked list allows efficient insertion operations anywhere in the list

41. Comparison Array The size of a “conventional” C++ array however cannot be altered because the array size is fixed at compile time. Cannot contain objects and classes Arrays can become full as it depends on our defined array Time consuming Existing elements need to be moved Linked List Linked lists are dynamic, so the length of a list can increase or decrease as necessary. Can contain objects and classes Never becoming full unless computer does not have enough memory Faster than array Linked lists can be maintained in sorted order by inserting each new element at the proper point in the list

42. SINGLE LINKED LIST

43. Singly Linked List Singly linked list is one of the most primitive data structures Each node that makes up a singly linked list consists of a value/data and a reference to the next node (if any) in the list

44. SINGLY LINKED LIST OPERATIONS Insertion Searching Deletion Traversing

45. Let us declare two Classes

46. We only have int data; no need others - Also declare an object of this class called Next (object pointer type)

47. Let us declare two Classes Functions where int Data() return data (an integer) and Node* Next() return next (which is also a data but in pointer type)

48. Let us declare two Classes Also call Node class by accessing through *head -Inside public:, we set up constructor of head = NULL (since it always NULL at first) -Along with function to delete, insert (append) and print the output

49. INSERTION

50. Insertion Adding a node to the tail/end of the list Node 0Node 4Node 1 Head Tail Node 2Node 3

51. Insertion Adding a node to a singly linked list has only two cases: – Head =  in which case the node we are adding is now both the head and tail of the list – We simply need to append our node onto the end of the list updating the tail reference appropriately

52. Insertion (Case) Case 1 : Empty List Case When list is empty, which is indicated by (head == NULL)condition, the insertion is quite simple. Algorithm sets both head and tail to point to the new node.

53. Insertion (Case) Case 2 : Add First In this case, new node is inserted right before the current head node.

54. Insertion (Case) Case 2 : Add First 1 st Step : Update the next link of a new node, to point to the current head node.

55. Insertion (Case) Case 2 : Add First 2 nd Step :Update head link to point to the new node.

56. Insertion (Case) Case 3 : Add Last In this case, new node is inserted right after the current tail node.

57. Insertion (Case) Case 3 : Add Last 1 st Step :Update the next link of the current tail node, to point to the new node.

58. Insertion (Case) Case 3 : Add Last 2 nd Step :Update tail link to point to the new node.

59. Insertion (Case) Case 4 : General Case In general case, new node is always inserted between two nodes, which are already in the list. Head and tail links are not updated in this case.

60. Insertion (Case) Case 4 : General Case 1 st Step :Update link of the "previous" node, to point to the new node.

61. Insertion (Case) Case 4 : General Case 2 nd Step :Update link of the new node, to point to the "next" node.

62. Singly Linked List: Insertion Algorithm

63. Here, we having an insertion algorithm for our linked list function - We parsed our data (inserted integer)

64. Singly Linked List: Insertion Algorithm Since we have declared Class Node, we create an newNode which is an object pointer. - Example, if we want to insert new data, we create new node or we can say it in easy word “create a new integer since we only have int data inside it.

65. Singly Linked List: Insertion Algorithm Ok, we assigned our newly added data to SetData function.

66. Singly Linked List: Insertion Algorithm SetNext is always set to NULL.

67. Example Output cin >>getinput; list.Append(getinput);

68. Example Output Node* newNode = new Node(); - We will create a newNode to access all the variables and functions in Class Node Node 0 Head

69. Example Output Node 0 Head 100 newNode->SetData(100);

70. Example Output Node 0 Head NULL100 newNode->SetNext(NULL);

71. Singly Linked List: Insertion Algorithm Declare on more object pointer of tmp = head; Where head is from a List Class.

72. Singly Linked List: Insertion Algorithm Check if tmp != NULL -If the first node is filled, we will move tmp to the Next Node. -So, Next Node is empty and we will create new node using tmp- >SetNext(newNode)

73. Singly Linked List: Insertion Algorithm First Input Inserted: - Jump to “First Node” statement as tmp == NULL

74. Singly Linked List: Insertion Algorithm Head = newNode

75. Singly Linked List: Insertion Algorithm Second Input Inserted - Jump to “SetNext(newNode)” statement as tmp- >Next is still equal to NULL

76. Singly Linked List: Insertion Algorithm Since tmp is no longer equal to NULL, set the tmp to next node to create new node

77. Singly Linked List: Insertion Algorithm Third Input Inserted -Right now, tmp- >Next is not equal to NULL since we have two input already. -So we move current point to new Next Node. And then we can set tmp- >SetNext(newNode)

78. Singly Linked List: Insertion Algorithm Since tmp-Next (current one) is no longer equal to NULL, set the tmp to point to a new Next newNode and then create newNode

79. Example Output newNode->SetData(100);

80. Example Output Second Input tmp->SetNext(newNode); Where it is a new data

81. Example Output Second Input tmp->SetNext(newNode); Where it is a new data

82. Example Output

83. DELETION

84. Deletion

85. Singly Linked List: Deletion Deleting a node from a linked list is also straightforward but there are a few cases we need to account for: – The list is empty; or – The node to remove is the only node in the linked- list; or – We are removing the head node; or – We are removing the tail node; or – The node to remove is somewhere in between the head and tail; or – The item to remove doesn’t exist in the linked-list

86. Singly Linked List: Deletion Algorithm The algorithm whose cases we have described will remove a node from anywhere within a list irrespective of whether the node is the head, etc.

87. Singly Linked List: Deletion Algorithm

88. SEARCHING

89. Singly Linked List: Searching Searching a linked-list is straightforward Traverse the list, checking the desired value/data with the value of each node in the linked-list

90. Singly Linked List: Searching Algorithm

91. TRAVERSING

92. Singly Linked List: Traversing the list Same as traversing a doubly linked list Start at the head and continue until come across a node that is . The two cases are as follows: – Node = , we have exhausted all nodes in the linked-list – Must update the node reference to be node.Next

93. Singly Linked List: Traversing Algorithm

94. REVERSE TRAVERSING

95. Singly Linked List: Traversing the list in reverse order Need to acquire a reference to the predecessor of a node (for singly linked list, this is an expensive operation) For each node, finding its predecessor is an O(n) operation. Over the course of traversing the whole list backwards the cost becomes O(n 2 )

96. Singly Linked List: Reverse Traversal Algorithm

97. Singly Linked List: Reverse Traversal The following figure depicts the previous reverse traversal algorithm being applied to a linked list with integers 5, 10, 1, and 40

99. Linked List: Reverse Traversal The algorithm is only of real interest when we are using singly linked list Actually double linked list make reverse list traversal simple and efficient

100. DOUBLE LINKED LIST

101. Doubly Linked List Is similar to singly linked list. The only difference is that each node has a reference to both the next and previous nodes in the list

102. Doubly Linked List The following algorithms for the doubly linked-list are exactly similar as those listed previously for singly linked-list: – Searching – Traversal

103. Doubly Linked-list: Insertion The only major difference with previous algorithm for singly linked-list is that we need to remember to bind the previous pointer of n to the previous tail node if n was not the first node to be inserted in the list

104. Doubly Linked-list: Insertion Algorithm

105. Example: adding the following sequence integers to a list: 1,45, 60 and 12 will result as follows:

106. Doubly Linked-list: Deletion It is exactly the same as those algorithm defined in previous for singly linked-list. Like insertion, we have the added task of binding an additional reference (previous) to the correct value

107. Doubly Linked-list: Deletion Algorithm

108. Doubly Linked-list: Reverse Traversal Singly linked-list have a forward design, which is why the reverse traversal algorithm defined previously required some creative invention Doubly linked-list make reverse traversal as simple as forward traversal, except that we start at the tail node and update the pointers in the opposite direction

109. Doubly Linked-list: Reverse Traversal Algorithm

110. The end Ref 1.http://www.algolist.net/Data_structures/Singly-linked_list/