sort method ascending and descending in MongoDB - Time & Space Complexity

Time Complexity: sort method ascending and descending

O(n log n)

Understanding Time Complexity

When we sort data in MongoDB, the time it takes depends on how much data there is.

We want to understand how sorting time grows as the data size grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// Sort documents by age ascending
db.users.find().sort({ age: 1 })

// Sort documents by age descending
db.users.find().sort({ age: -1 })
    

This code sorts user documents by their age field in ascending or descending order.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Comparing and rearranging documents based on the age field.
• How many times: The sorting algorithm compares many pairs of documents, roughly O(n log n) where n is the number of documents.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
10	About 30 comparisons
100	About 700 comparisons
1000	About 10,000 comparisons

Pattern observation: As the number of documents grows, the number of comparisons grows faster than the number of documents, roughly O(n log n).

Final Time Complexity

Time Complexity: O(n log n)

This means sorting takes more time as data grows, but not as fast as checking every pair; it grows in a balanced way.

Common Mistake

[X] Wrong: "Sorting always takes the same time no matter how many documents there are."

[OK] Correct: Sorting needs to compare and reorder documents, so more documents mean more work and more time.

Interview Connect

Understanding how sorting time grows helps you explain database performance clearly and shows you know how data size affects operations.

Self-Check

"What if we add an index on the age field? How would the time complexity of sorting change?"

Practice

1. What does the sort({ age: 1 }) method do in MongoDB?

easy

A. Deletes documents with age less than 1

B. Sorts documents by age in descending order (largest to smallest)

C. Filters documents where age equals 1

D. Sorts documents by age in ascending order (smallest to largest)

Solution

1. Step 1: Understand the sort method parameter

   The number 1 in sort({ age: 1 }) means ascending order.

2. Step 2: Interpret the sorting effect

   Documents will be arranged from smallest age to largest age.

3. Final Answer:

   Sorts documents by age in ascending order (smallest to largest) -> Option D

4. Quick Check:

   sort({ field: 1 }) = ascending order [OK]

Hint: 1 means ascending order, -1 means descending order [OK]

Common Mistakes:

• Confusing 1 with descending order
• Thinking sort filters data
• Assuming sort deletes documents

2. Which of the following is the correct syntax to sort documents by score in descending order in MongoDB?

easy

A. db.collection.find().sort({ score: -1 })

B. db.collection.find().sort({ score: 1 })

C. db.collection.find().sort(score: -1)

D. db.collection.find().sort({ -1: score })

Solution

1. Step 1: Check the correct object syntax for sort

   The sort method requires an object with field name as key and 1 or -1 as value, inside curly braces.

2. Step 2: Identify descending order syntax

   Descending order is indicated by -1, so { score: -1 } is correct.

3. Final Answer:

   db.collection.find().sort({ score: -1 }) -> Option A

4. Quick Check:

   sort({ field: -1 }) = descending order [OK]

Hint: Use curly braces and colon: sort({ field: -1 }) [OK]

Common Mistakes:

• Missing curly braces around sort argument
• Using parentheses instead of braces
• Putting -1 as key instead of value

3. Given the documents: [{"name": "Anna", "score": 85}, {"name": "Ben", "score": 92}, {"name": "Cara", "score": 78}], what will be the order of names after running db.students.find().sort({ score: 1 })?

medium

A. ["Ben", "Anna", "Cara"]

B. ["Cara", "Ben", "Anna"]

C. ["Cara", "Anna", "Ben"]

D. ["Anna", "Cara", "Ben"]

Solution

1. Step 1: Understand ascending sort by score

   Sorting by score ascending means from smallest to largest score: 78, 85, 92.

2. Step 2: Map scores to names in order

   78 = Cara, 85 = Anna, 92 = Ben, so order is ["Cara", "Anna", "Ben"].

3. Final Answer:

   ["Cara", "Anna", "Ben"] -> Option C

4. Quick Check:

   sort({ score: 1 }) = ascending order [OK]

Hint: Ascending sort orders from smallest to largest [OK]

Common Mistakes:

• Mixing ascending with descending order
• Sorting by name instead of score
• Confusing array order in output

4. What is wrong with this MongoDB query?

db.products.find().sort({ price: 2 })

medium

A. The find() method cannot be chained with sort()

B. The sort value must be 1 or -1, not 2

C. The field name 'price' is invalid

D. Missing parentheses after sort

Solution

1. Step 1: Check valid sort values

   MongoDB sort only accepts 1 for ascending or -1 for descending, not 2.

2. Step 2: Identify the error cause

   Using 2 will cause a syntax or runtime error because it's invalid.

3. Final Answer:

   The sort value must be 1 or -1, not 2 -> Option B

4. Quick Check:

   sort values = 1 or -1 only [OK]

Hint: Sort values must be exactly 1 or -1 [OK]

Common Mistakes:

• Using numbers other than 1 or -1
• Assuming any positive number works
• Thinking sort can't chain after find()

5. You have a collection with documents containing category and price. How do you sort first by category ascending, then by price descending?

hard

A. db.collection.find().sort({ category: 1, price: -1 })

B. db.collection.find().sort({ price: -1, category: 1 })

C. db.collection.find().sort({ category: -1, price: 1 })

D. db.collection.find().sort({ category: 1 }).sort({ price: -1 })

Solution

1. Step 1: Understand multi-field sort syntax

   MongoDB sorts by fields in the order they appear in the object passed to sort().

2. Step 2: Apply ascending to category and descending to price

   Use { category: 1, price: -1 } to sort category ascending, then price descending within each category.

3. Final Answer:

   db.collection.find().sort({ category: 1, price: -1 }) -> Option A

4. Quick Check:

   Multi-field sort = object with fields in order [OK]

Hint: List fields in sort object in desired priority order [OK]

Common Mistakes:

• Reversing field order changes sort priority
• Trying to chain multiple sort() calls
• Using wrong sort values for fields