Which would be faster when using a LinkedList? I haven't studied sorting and searching yet. I was thinking adding them directly in a sorted manner would be faster, as manipulating the nodes and pointers afterward intuitively seems to be very expensive. Thanks.

CodePudding user response：

In general, using a linked list has many difficulties and is very expensive .

i)In the usual case, if you want to add values to the sorted linked list, you must go through the following steps:

1. If Linked list is empty then make the node as head and return it.
2. If the value of the node to be inserted is smaller than the value of the head node, then insert the node at the start and make it head.
3. In a loop, find the appropriate node after which the input node is to be inserted. To find the appropriate node start from the head, keep moving until you reach a node GN who's value is greater than the input node. The node just before GN is the appropriate node .
4. Insert the node after the appropriate node found in step 3. the Time Complexity in this case is O(n). ( for each element ) but don't forget to sort the linked list before adding other elements in a sorted manner ; This means you have to pay extra cost to sort the linked list.

ii ) but if you want to add elements to the end of the linked list and then sort them the situation depends on the way of sorting ! for example you can use merge sort that has O(n*log n) time complexity ! and even you can use insertion sort with O(n^2) time complexity . note : How to sort is a separate issue .

As you have already noticed! It is not easy to talk about which method is faster and it depends on the conditions of the problem, such as the number of elements of the link list and the elements needed to be added, or whether the cost of initial sorting is considered or not!

CodePudding user response：

You have presented two options:

1. Keep the linked list sorted by inserting each new node at its sorted location.

2. Insert each new node at the end (or start) of the linked list and when all nodes have been added, sort the linked list

The worst case time complexity for the first option occurs when the list has each time to be traversed completely to find the position where a new node is to be inserted. In that case the time complexity is O(1 2 3 ... n) = O(n²)

The worst time complexity for the second option is O(n) for inserting n elements and then O(nlogn) for sorting the linked list with a good sorting algorithm. So in total the sorting algorithm determines the overall worst time complexity, i.e. O(nlogn).

So the second option has the better time complexity.

Merge sort has a complexity of O(nlogn) and is suitable for linked list.

If your data has a limited range, you can use radix sort and achieve O(kn) complexity, where k is log(range size).

In practice it is better to insert elements in a vector (dynamic array), then sort the array, and finally turn the array into a list. This will almost certainly give better running times.