🔍 How I Verified If a Linked List Is Sorted Using a Simple Count-Based Approach

When working with linked lists, one common interview or coding challenge is:

“Determine whether a singly linked list is sorted (ascending or descending).”

Most people use two flags (like ascending, descending) to track the trend. That works, but I found a cleaner and more elegant way — and I want to share it with you.

🧠 The Core Idea

Instead of tracking booleans, we count how many steps are in the ascending or descending direction, and use that to determine if the list is sorted.

✅ Java Implementation: Check if the List Is Sorted

class Node {
    int data;
    Node next;
}

class Solution {
    public static boolean isSorted(Node head) {
        int size = 0;
        int sortCount = 0;

        while (head.next != null) {
            if (head.data < head.next.data) {
                sortCount++;
                size++;
            } else if (head.data > head.next.data) {
                sortCount--;
                size++;
            }
            head = head.next;
        }

        return size == Math.abs(sortCount);
    }
}

🧪 How This Works

• size counts the total number of comparisons (ignoring equal values).
• sortCount increments for ascending pairs and decrements for descending.
• If all comparisons go in the same direction, Math.abs(sortCount) == size.

✅ Test Cases

Linked ListOutput1 → 2 → 3true3 → 2 → 1true2 → 2 → 2true1 → 3 → 2 → 4false

🧭 Bonus: Detecting Ascending or Descending

public static String getSortOrder(Node head) {
    int size = 0;
    int sortCount = 0;

    while (head != null && head.next != null) {
        if (head.data < head.next.data) {
            sortCount++;
            size++;
        } else if (head.data > head.next.data) {
            sortCount--;
            size++;
        }
        head = head.next;
    }

    if (size == 0) return "all elements equal";
    if (sortCount == size) return "ascending";
    if (sortCount == -size) return "descending";
    return "unsorted";
}

✅ Direction Test Cases

Linked ListOutput1 → 2 → 3"ascending”5 → 4 → 2"descending”3 → 3 → 3 → 3"all elements equal”1 → 3 → 2 → 4"unsorted”

🎯 Why This Approach Works So Well

• One-pass (O(n)) time complexity
• Handles duplicates naturally
• Compact and readable
• Doesn’t require tracking two flags

📌 Final Thoughts

There are always multiple ways to solve a problem — and while flag-based solutions are common, this count-based approach is just as valid, often cleaner, and fun to explain.

If you’re preparing for interviews or like writing smart utility functions — try this out. And if you’re already using it — you’re ahead of the curve! 😉