Mean vs Median — Which Is Better? Force a Choice.

Both are "center" but in different senses.

Mean: the value that minimizes the sum of squared deviations.

$\bar{x} = \arg\min_c \sum_i (x_i - c)^2$

Equivalently, the balance point of the distribution — the center of mass.

Median: the value that minimizes the sum of absolute deviations.

$\text{median} = \arg\min_c \sum_i |x_i - c|$

Equivalently, the 50th percentile — splits the data into two equal halves.

The difference traces back to L2 vs L1 loss. Mean penalizes outliers quadratically (they pull it hard); median treats them equally (only the middle value matters).

For i.i.d. samples from the normal-distribution $\mathcal{N}(\mu, \sigma^2)$:

• $\text{Var}(\bar{X}) = \sigma^2 / n$
• $\text{Var}(\text{median}) \approx (\pi / 2) \cdot \sigma^2 / n \approx 1.57 \sigma^2 / n$

So for normal data, the mean is about 57% more efficient — you'd need 1.57× the sample size with the median to get the same precision.

But for heavy-tailed distributions (Cauchy, Student-t with low df, real-world income data, latency data), the mean can have infinite variance while the median stays finite and stable.

Concretely:

• For Cauchy: mean has infinite variance, median has finite variance. Median is infinitely more efficient.
• For t-distribution with 2 df: variance is infinite.
• For log-normal: mean is unbiased but high-variance; median is more stable.

Rule of thumb: light tails → mean is more efficient. Heavy tails or outliers → median is more efficient AND more robust.

Mean: $O(n)$ — one pass, add up values, divide.

Median:

• Naive: sort the array, take the middle element. $O(n \log n)$.
• Better: quickselect (partition-based selection) gives $O(n)$ expected time, $O(n^2)$ worst case.
• Linear worst-case: median-of-medians algorithm — $O(n)$ guaranteed but with a large constant. Rarely used in practice.

In distributed / streaming settings:

• Mean: trivially parallel — compute partial sums, combine.
• Median: hard to parallelize or stream. Approximate quantile algorithms (t-digest, KLL sketch) exist but are approximate.

Rule of thumb: mean is dramatically cheaper at scale.

Mean: a single outlier can pull the mean arbitrarily far. If you have [1, 2, 3, 4, 1000], mean is 202 — very unrepresentative.

Median: outliers in the tails don't move the median. [1, 2, 3, 4, 1000] has median 3. A value could be $10^{100}$ and the median wouldn't change.

Formally: mean has breakdown point 0 (one contaminated value ruins it). Median has breakdown point 0.5 (up to half the data can be arbitrary before median moves to an uninformative position).

For "which is better as a one-size-fits-all summary":

Median.

Reasoning:

• The dominant failure mode of mean is being pulled by outliers, which is common in real data.
• The dominant failure mode of median is slight inefficiency (needs 57% more data on normal) — small cost.
• Real-world data is rarely clean normal; most distributions have heavy tails or outliers.
• Median is almost never misleading; mean frequently is.

Counter-arguments (for mean):

• Mean has linearity: $E[aX + bY] = aE[X] + bE[Y]$. Median doesn't ($\text{median}(X+Y) \neq \text{median}(X) + \text{median}(Y)$).
• Mean is unbiased by construction; median has bias even when unbiased-in-limit.
• Under homogeneity (truly normal clean data), mean is uniformly better.
• Computational ease at scale.

So for predictive modeling, economic aggregates, or physical measurements with known distributions, the mean is the right answer. For summarizing unknown/messy distributions to a stakeholder, the median is the safer default.

The "force a choice" is about what you'd pick as a default. I'd pick median.

import random

def quickselect(arr, k):
    """Find the k-th smallest element (0-indexed) in arr."""
    if len(arr) == 1:
        return arr[0]
    
    pivot = random.choice(arr)
    lows = [x for x in arr if x < pivot]
    highs = [x for x in arr if x > pivot]
    pivots = [x for x in arr if x == pivot]
    
    if k < len(lows):
        return quickselect(lows, k)
    elif k < len(lows) + len(pivots):
        return pivot
    else:
        return quickselect(highs, k - len(lows) - len(pivots))

def median_quickselect(arr):
    n = len(arr)
    if n % 2 == 1:
        return quickselect(arr, n // 2)
    else:
        return (quickselect(arr, n // 2 - 1) + quickselect(arr, n // 2)) / 2

This runs in $O(n)$ expected time, which matters for very large arrays.

1. "Median is always better because of outliers." Not always. For clean normal data, mean is strictly more efficient. "Always" claims lose nuance.
2. Forgetting to handle even-length arrays. Average of the two middle values, not just taking one.
3. Sorting with a nested loop ($O(n^2)$). Use Python's built-in sorted or manual quickselect for better complexity.
4. Claiming mean is O(1) memory. Running mean needs one accumulator. Median requires all data to be seen (for exact median) — it's inherently memory-heavy.