Question

I’m working on compiling a list for the efficiency of operations on different data structures.
So far, I’ve got this:

I’m not so sure of what i’ve got here for the queue as linked list and for the stack as linked list. can anyone lend any insight into this issue?

Answer 1

The only error is that Pop for Queue as Linked List with pointer to front should be O(1).

For completeness, it may be worth it to list complexity for operations such as search for any element, remove any element, get by index, remove by index, etc.

Queue as linked-list (pointer to front):

Push: You need to insert an element at the end, but you only have a pointer to the beginning, so you need to iterate through all elements to get to the end.

current = head
while (current.next != null)
  current = current.next
current.next = newItem

Pop: You need to remove the element in the beginning, so you’d do this by simply reassigning the pointer to the beginning to the second element.

removedItem = head
head = head.next

Queue as linked-list (pointer to front and back):

Push: You need to insert an element at the end, and you have a pointer to the end, so you can just add it in constant time.

tail.next = newItem
tail = newItem

Pop: Same as pop for single linked-list.

removedItem = head
head = head.next

Stack as linked-list:

Push: Insert an item in the beginning, easy to do in constant time.

newItem.next = head
head = newItem

Pop: Remove the first item, easy to do in constant time.

removedItem = head
head = head.next

Stack as array:

Push: Insert item at last index, easy to do in constant time.

last = last+1
array[last] = newItem

Pop: Remove item at last index, easy to do in constant time.

removedItem = array[last]
last = last-1