O(n) 和 O(n logn) 之间的比较

Question

Which is best algo for a normal search in array where array length is not known

O(n) (A simple for loop)

Or

O(n log n) (sorted(array)) in python

Correct me if the Time Complexity is wrong and also add any useful additional information.

Thanks in advance

Answer 1

It depends on how often you'll be doing the search.

• Looking for a specific item in an unsorted list takes O(n) time.
• Looking for a specific item in a sorted list takes O(lg n) time.
• Turning an unsorted list into a sorted list takes O(n lg n) time.

---

Doing a single linear search in an unsorted list is faster than sorting the list in order to do a single binary search.

But doing multiple linear searches in an unsorted list can be much slower than sorting the list once and doing multiple binary searches in the sorted list.

---

When will it be faster overall to spend the time sorting the list to speed up future searches compared to just biting the bullet and doing linear searches? You can only answer that by carefully consider the size of the list, and trying to anticipate your likely workload.

Consider k searches. Sorting comes out on top if (using some very handwavy math) O(n lg n) + kO(lg n) is less than kO(n). That's true somewhere around the time k starts to exceed lg n . Given how slowly lg n grows, it typically does not take long for the initial investment in sorting to pay off.

Answer 2

yes you are correct: for a single for loop of n integers the time complexity is O(n)

for(int i=0 ;i<n ; i++0)

if we have two for loops one inside another the it was o(n^2) best example is bubble sort

for(int i=0 ;i<n ; i++){
for (int j=0;j<n;j++){
                     .....................}}

if i value decreases into half for every iteration then the complexity will be in terms of log best example is mergsort,binary search

for(int i=0 ;i<n ; i=i/2){}

searching for a item in a sorted list takes O(log n) time it was the best method. best application is binary search

converting an unsorted list into a sorted list takes O(n*logn) time ie merge sort,heap sort.