The assignment is usually asking why that structure, not whether it works
Plenty of solutions produce correct output. The points are in the justification: why this data structure, what the complexity is, and what happens as the input grows. That is a written argument, and it is where most lost points sit.
Get your free quote
We reply within 1 business hour, no delays.
No card details required · 100% confidential · On time, or it's free
Complexity reasoning and structure selection
Big O is a statement about growth, not about speed. An O(n log n) algorithm can be slower than an O(n squared) one on small inputs, and students who treat the notation as a ranking rather than as asymptotic behavior get caught by exactly that question.
Structure selection is the other half. Arrays, linked lists, hash tables, trees and heaps each trade access, insertion, deletion and ordering differently. The assignment usually describes an access pattern, and the correct answer follows from it. Choosing what you are most comfortable with, and justifying afterwards, reads as backwards to a grader.
Then the write-up. Many courses want a proof-style argument that your algorithm is correct and an analysis of its complexity in the worst, average and best cases. That is technical writing, and students who can code fluently sometimes struggle with it more than with the code.
- Complexity derived, not quoted
- Worst, average and best cases distinguished
- Structure chosen from the access pattern in the problem
- Correctness argued rather than asserted
What we work on
Your own assignments and your own code
- Deriving time and space complexity from the code
- Arrays, lists, stacks, queues, hash tables, trees and graphs
- Sorting and searching algorithms, and when each wins
- Recursion, memoization and dynamic programming
- Writing correctness and complexity analyses
We explain. You implement
- We do not write code you will submit.
- We do not complete your assignments or supply solutions.
- We do not sit or assist during any timed assessment or coding test.
- We do not produce analyses for you to hand in.
- We work through your own code and reasoning with you.
Similarity checking on code is routine and catches adapted solutions. This subject in particular is one where an unearned pass makes every later course harder. Read the full policy.
Frequently Asked Questions
Count how the number of basic operations grows with the input size. A single loop over n items is O(n); a nested loop is usually O(n squared); halving the problem each step gives a log factor. Then drop constants and lower-order terms. Deriving it is what is assessed, not quoting a table.
Read the access pattern in the problem. Frequent lookup by key points to a hash table. Ordered traversal points to a tree. Frequent insertion and deletion at both ends points to a deque. Justify from the pattern rather than from familiarity.
Because Big O describes growth, not absolute speed. At small input sizes constant factors and overheads dominate, and a simple quadratic algorithm can genuinely win. Exams ask about this precisely because it shows whether you understand what the notation claims.
Usually with a loop invariant for iterative algorithms, or induction for recursive ones. State what is true before the loop, show it stays true through each iteration, and show what that gives you when the loop ends. It is a written argument rather than a test result.
Understanding beats memorization. Know which are stable, which are in-place, what their complexities are in each case, and why quicksort degrades on already-sorted input without a good pivot choice. Those are what the questions turn on.
Send the problem and your approach
We will work through whether the structure fits the access pattern and help you derive the complexity rather than quote it.
Get Help With My Coursework