Sorting in R: sort(), order() and arrange()

sort() Sorts a Vector's Values

For a plain vector, sort() does exactly what you expect - returns the values in ascending order (the original is untouched):

times <- c(12.4, 9.8, 15.1, 11.0)

print(sort(times))
print(sort(times, decreasing = TRUE))

words <- c("pear", "apple", "cherry")
print(sort(words))

Two options worth knowing. decreasing = TRUE flips the direction. And sort() silently drops NA values by default - sort(c(3, NA, 1)) returns just 1 3. If missing values must survive the sort, say where they go: sort(x, na.last = TRUE) keeps them, placed after the ordered values.

So far, so obvious. The interesting part is why sort() is the wrong tool for data frames.

order() Returns Positions - The Mental Shift

sort() answers "what are the values, in order?" order() answers a different question: "which positions would I visit to see the values in order?"

times <- c(12.4, 9.8, 15.1, 11.0)

print(sort(times))    # the values, ordered
print(order(times))   # 2 4 1 3 - the positions, in order

Read order(times) as instructions: the smallest value sits at position 2, the next at position 4, then 1, then 3. Indexing with those instructions - times[order(times)] - reproduces sort(times) exactly.

Why does that matter? Because a data frame row is a team of values that must move together. Sorting the time column alone with sort() would reorder one column and leave its teammates behind - every row scrambled. order() gives you row positions instead, and putting positions in the row slot of the brackets moves whole rows:

runners <- data.frame(
    name = c("Ana", "Ben", "Chen", "Dana"),
    time = c(12.4, 9.8, 15.1, 11.0)
)

print(runners[order(runners$time), ])

Ben's 9.8 arrives with Ben's name still attached. That is the whole trick, and it is the idiom for sorting data frames in base R: df[order(df$column), ]. (The printed row labels - 2 4 1 3 - are the original row numbers tagging along; harmless.)

Descending and Multi-Column Sorts

For descending numeric sorts, negate the column - ordering -time ascending is ordering time descending. And order() takes multiple columns, earlier ones first, later ones breaking ties:

staff <- data.frame(
    name   = c("Ana", "Ben", "Chen", "Dana", "Eli"),
    dept   = c("ops", "eng", "eng", "ops", "eng"),
    salary = c(70, 95, 88, 75, 95)
)

print(staff[order(-staff$salary), ])                 # highest paid first
print(staff[order(staff$dept, -staff$salary), ])     # by dept, then salary desc

The second call sorts departments alphabetically and, within each department, salaries high to low. The negation trick only works on numbers - -df$name on a character column is an error. For descending text, use order(df$name, decreasing = TRUE) instead (which flips every sort key at once).

rank() Is the Third Sibling

In passing: rank(x) answers yet another question - "what place does each value hold?" - without moving anything:

times <- c(12.4, 9.8, 15.1, 11.0)
print(rank(times))   # 3 1 4 2 - Ana came 3rd, Ben 1st...

sort() gives ordered values, order() gives positions to visit, rank() gives each value's standing in place. People conflate order() and rank() constantly; notice they are inverse permutations of each other, and reach for rank() only when you literally want rankings (leaderboards, percentiles).

The dplyr Way: arrange()

dplyr's arrange() wraps the whole order() dance in a verb - columns are sort keys, desc() flips one (static; the sandbox runs base R only):

library(dplyr)

runners |> arrange(time)
staff   |> arrange(dept, desc(salary))

No brackets, no $, no negation trick - desc() works on character columns too. One behavioral difference worth knowing: arrange() puts NA values at the end regardless of direction, while base order() also defaults to na.last = TRUE. See the dplyr intro for how arrange() chains with filter() and friends.

Character Sorting Has Sharp Edges

Two caveats when sorting text. First, digits stored as text sort as text - character comparison goes symbol by symbol:

versions <- c("10", "2", "1", "30")

print(sort(versions))              # "1" "10" "2" "30" - not numeric order!
print(sort(as.numeric(versions)))  # 1 2 10 30

"10" sorts before "2" because the comparison stops at the first symbol: "1" < "2". If a column of numbers sorts weirdly, it is almost certainly stored as character - convert with as.numeric() first (a frequent aftermath of a messy CSV import).

Second, text ordering depends on your system locale - accents, case, and non-Latin scripts can sort differently on your laptop than on a server with a C locale. Sorted output that must be identical across machines should either set the locale explicitly or sort a normalized key.

What You Take Away

• sort(x) orders a vector's values; decreasing = TRUE flips it; NAs are dropped unless na.last = TRUE.
• order(x) returns positions, and df[order(df$x), ] is the base idiom for sorting data frames.
• Multi-column: order(df$a, -df$b); negation for descending works on numbers only.
• rank() gives standings without reordering - not a substitute for order().
• dplyr's arrange(dept, desc(salary)) is the same sort with less punctuation.
• "10" sorts before "2" in text - check your column types.

Next up: collapsing rows into group summaries with table(), tapply(), aggregate(), and dplyr's group_by().