Home › DSA › Foundations

Linear Time On

Linear Time Complexity describes algorithms where the runtime grows directly in proportion to the input size. This means that as the input size doubles, the time taken by the algorithm also doubles.

Key Characteristics

In an algorithm with time complexity:

The number of steps the algorithm takes grows linearly with the input size.
This is common in algorithms that need to examine every element of the input, like searching or filtering.

Code Example

Let’s look at an example of an algorithm. This function calculates the sum of all elements in a list:

java

class Solution {
    public int calculate_sum(int[] arr) {
        int total = 0;
        for (int num : arr) { // Calculating sum
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5}; // Example array

        Solution solution = new Solution();
        int sum = solution.calculate_sum(arr);
        System.out.println("Sum of elements: " + sum);
    }
}

Explanation: calculate_sum method iterates through each element of arr, adding it to total.

Why ? The loop runs once for each element, so if arr has elements, the function performs additions, giving it a time complexity of .

Examples of operations

Iterating through each element in a list: When you need to process every item in a list, like summing numbers or finding the maximum, the time taken grows with the list length.
Searching through unsorted data: In an unsorted list, you might need to check each element to find a specific value, making the operation take time.
Counting items in a collection: If you’re counting all items in a stack, queue, or similar data structure, the time taken will be proportional to the number of items.

🤖 Don't fully get this? Learn it with Claude

Stuck on Linear Time On? Open Claude, copy a block below, and it'll teach you this exact concept — visually and interactively.

🎨 Explain it visually

Build the mental picture, not memorization.

I just read a lesson on **Linear Time On** (DSA) and want to truly understand it. Explain Linear Time On from first principles using ONE vivid real-world analogy and a visual mental model — draw it as ASCII art or a clear step-by-step diagram — with a concrete example using real numbers. Then ask me one question to check I got the mental picture, and wait for my reply. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🤔 Walk me through it (interactive)

Socratic — adapts to where you're stuck.

Teach me **Linear Time On** interactively. Ask me ONE guiding question at a time, wait for my answer, and adapt to my confusion — build the idea with me step by step instead of explaining it all at once. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🧪 Quiz me & fix my gaps

Active recall exposes what you missed.

Quiz me on **Linear Time On** with 5 questions, easy to tricky, ONE at a time. Tell me if each answer is right; at the end, explain clearly what I got wrong and why. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

🧠 Make it stick

Intuition + hook + flashcards for long-term memory.

Help me remember **Linear Time On** for the long term: give the one-sentence intuition, a memorable hook/mnemonic, a tiny worked example, and 3 active-recall flashcards (Q -> A). If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

📝 My notes

← Constant Time O1 Quadratic Time On² →