"单链表时间"

Question

Given a Singly linked list that contains a pointer to the head, and one to the tail. Which would be the most time consuming?

• Inserting node at beginning

• Inserting node at the end

• Deleting node at the beginning

• Deleting node at the end

I think inserting node at the end because to do this we have to loop through the whole linked list, then insert the data of the node, then link the node correspondingly.

However with the research I've done deleting node at the end also seems to be a valid options, which would you say takes the most amount of time?

Answer 1

最后删除节点：需要遍历所有链表，因为它需要更新倒数第二个节点以将下一个指针更新为NULL。

Answer 2

Let's look at what it takes for each

Inserting node at beginning : Constant time

inserted.next = head
head = inserted

Inserting node at the end : Constant time

tail.next = inserted
tail = inserted

Deleting node at the beginning : Constant time

old_head = head
head = head.next
delete old_head

Deleting node at the end : linear time <-- most expensive

old_tail = tail
new_tail = head
while new_tail.next is not None:
    new_tail = new_tail.next
tail = new_tail
delete old_tail

Answer 3

Analysing the complexity here.

Assuming the list structure is as below

node1-> node2-> node3-> node4-> node5

head--------------------------------------------tail

Inserting node at the end : tail-> next = newNode; O(1)

Deleting node ate the end : Don't have the prev pointer for tail (as it is singly linked list) so have to traverse the entire list to find secondlast node. O(n)

secondlast_node->next = Null;
free(tail);
tail = secondlast_node;

(The answer may change if you managed to construct the list differently)

If you have constructed the linked list as in the below example

node1<-node2<-node3<-node4<-node5

head---------------------------------------------------tail

Deleting node at the beginning becomes the most expensive operation

but in both the cases inserting node at the end is O(1) complexity

Answer 4

取决于你的指针在哪里。如果它在开头，它将在最后一个节点插入和删除。

Answer 5

if you have two pointers which pointing to head and tail 1. inserting : both takes O(1) as just modifying head and tail pointers. 2. Deleting: head side deleting takes O(1) time , however , tail needs previous pointer which requires O(n) time complexity.

Assume: it is Single Linked List. for DLL all takes O(1)

Answer 6

Case study: A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked using pointers as shown in the below image: Each element in the link is called a node which is composed of two parts: a. Data stored by the node b. Link pointed to the next node in the linked list In this assessment 2, you are required to develop a Linked List in visual studio called LinkedList.cpp which uses a Linked List to store the browsing history in the web browser following aspects using C++:

1. Node in the linked list with appropriate data types: each node stores in the URL (web address), its current position (index) in the Linked List and link to the next node in the Linked List.
2. Insertion − Adds a node at the beginning of the lined list: method signature is void insertFirst(String newURL)
3. Deletion − Deletes a node at the beginning of the linked list: method signature is void deleteFirst()