The complexity of list operations depends on traversal. For a linked list of n nodes, the isEmpty() method is O(1), as it only compares the first node to see if it is an empty environment. Similarly, the sizeLinkList() method requires O(n) operations to determine the length of a linked list, as the linked list has to traverse through all the nodes for length determination.

The deletion and searching for an item in the linked list in worst case will take O(n) operations, as the pointer may have to scan through all the nodes before it finds the item for deletion. On the other hand, the addElement() method will take O(1) time as it is directly adding a new element to the head of the linked list. Insertion based on position will take O(p) time, as the linked list has to traverse through p nodes before performing an insertion. For example, say we want to insert 11 at the third position in the list <1, 2, 5, 4>. The current insertion operation will require the pointer to move from the head to the third position. In the worst case, where insertion needs to be done after the last node, it would require O(n) computational effort.

In an array list, moving to any position requires O(1) operations, as the elements can be accessed directly. The insert and delete operations are quite straightforward in array list implementation, and require O(1) computational effort if performed at the tail of the list, as no data needs to be moved in the array list. However, if an element is deleted from or inserted in between items in a list, then all the elements need to be moved one position towards the head or tail respectively. For example, insertion of an element in the example shown in the next image requires all the other elements to move towards the tail. So, if an element is inserted at the p^th location, it will require n-p elements to be moved to the tail as shown in Figure 3.14, thus requiring O(n) computational effort.

Figure 3.21: Insertion in an array list

To summarize, array lists are very efficient in accessing a dataset with O(1) computational effort, whereas linked lists are just average in accessing a dataset with O(n) computational effort. However, insertion and deletion require O(n) computations in array lists and O(1) computations in linked lists, making linked lists more efficient in handling insertion and deletion if the pointer is at the location of insertion or deletion.