Mid Of Linked List
1. You are given a partially written LinkedList class.Input Format
2. Here is a list of existing functions:
2.1 addLast  adds a new element with given value to the end of Linked List
2.2. display  Prints the elements of linked list from front to end in a single line.
All elements are separated by space
2.3. size  Returns the number of elements in the linked list.
2.4. removeFirst  Removes the first element from Linked List.
2.5. getFirst  Returns the data of first element.
2.6. getLast  Returns the data of last element.
2.7. getAt  Returns the data of element available at the index passed.
2.8. addFirst  adds a new element with given value in front of linked list.
2.9. addAt  adds a new element at a given index.
2.10. removeLast  removes the last element of linked list.
2.11. removeAt  remove an element at a given index
2.12 kthFromLast  return kth node from end of linked list.
3. You are required to complete the body of mid function. The function should be an iterative function and should return the mid of linked list. Also, make sure to not use size data member directly or indirectly (by calculating size via making a traversal). In linked list of odd size, mid is unambigous. In linked list of even size, consider end of first half as mid.
4. Input and Output is managed for you.
Input is managed for youOutput Format
Output is managed for youQuestion Video
1. Size property should not be used directly or indirectlySample Input
2. Constant time, single traversal is expected
3. Iterative solution, (not recursion) is expected.
addLast 10Sample Output
getFirst
addLast 20
addLast 30
getFirst
getLast
getAt 1
addLast 40
mid
getLast
addLast 50
removeFirst
getFirst
removeFirst
removeFirst
mid
removeFirst
removeFirst
getFirst
quit
10
10
30
20
20
40
20
40
List is empty

Editorial
The problem here deals with implementing the mid() function which returns the data present at the middlemost node of the list.
We are given a linked list class which has three data members:
1. Head: It points to the starting node of the linked list.
2. Tail: It points to the last node of the linked list.
3. Size: It stores the current length (or size) of the linked list.
There can be two cases for the problem:
1. Length of List is Even
Input List: 1 > 2 > 3 > 4 > 5 > 6 > 7 > 8
Output: 4
2. Length of List is Odd
Input List: 1 > 2 > 3 > 4 > 5
Output: 3
To solve this problem we would be taking a twopointer approach (In this particular case also known as Hare and Tortoise Approach) wherein we take two pointers a fast and a slow pointer where the fast pointer jumps at double the speed of the slow pointer, the intuition behind this is that if fast and slow have to cover the same length of list say n then if the speed of fast is twice the speed of slow which would imply that when fast reaches the end of the list then slow would be exactly at the middle of the list, hence data at slow pointer would be our result. This approach is also known as Hare and Tortoise approach as here fast pointer acts as a hare and slow pointer acts like a tortoise, hence the name.
Below is the implementation in Java:
public int mid(){ Node f = head; Node s = head; while(f.next != null && f.next.next != null){ f = f.next.next; s = s.next; } return s.data; }
java false
Dry Run Case 1 (Even Length)
Input List: 1 > 2 > 3 > 4 > 5 > 6 > 7 > 8
Output: 4
Initially, slow = 1st Node and fast = 1st Node
1. First Iteration
fast.next = 2nd Node != null&&fast.next.next = 3rd Node != null
fast = fast.next.next = 3rd Node
slow = slow.next = 2nd Node
2. Second Iteration
fast.next = 4thNode != null&&fast.next.next = 5thNode != null
fast = fast.next.next = 5thNode
slow = slow.next = 3rdNode
3. Third Iteration
fast.next = 6thNode != null&&fast.next.next = 7thNode != null
fast = fast.next.next = 7thNode
slow = slow.next = 4thNode
4. Fourth Iteration
fast.next = 8th Node != null&&fast.next.next == null
Loop Breaks
Returnslow.data = 4 (Result)
Dry Run Case 2 (Odd Length)
Input List: 1 > 2 > 3 > 4 > 5
Output: 3
Initially, slow = 1st Node and fast = 1st Node
1. First Iteration
fast.next = 2nd Node != null&&fast.next.next = 3rd Node != null
fast = fast.next.next = 3rd Node
slow = slow.next = 2nd Node
2. Second Iteration
fast.next = 4th Node != null&&fast.next.next = 5th Node != null
fast = fast.next.next = 5th Node
slow = slow.next = 3rd Node
3. Third Iteration
fast.next = 6thNode == null
Loop Breaks
Returnslow.data = 3 (Result)
Time Complexity: O(n)
The time complexity for the function is linear as the traversal of the linked list is involved.
Space Complexity: O(1)
The space complexity for the function is constant as we have only used referenced variables in our algorithm.

Asked in Companies

Related Topics