R order 排序排列

说明

order返回一个排列，将其第一个参数重新排列为升序或降序，通过其他参数打破联系。sort.list执行相同的操作，仅使用一个参数。
有关如何使用这些函数对 DataFrame 进行排序等的信息，请参阅示例。

用法

order(..., na.last = TRUE, decreasing = FALSE,
      method = c("auto", "shell", "radix"))

sort.list(x, partial = NULL, na.last = TRUE, decreasing = FALSE,
          method = c("auto", "shell", "quick", "radix"))

参数

...	具有相同长度的数字、复数、字符或逻辑向量的序列，或分类的向量R对象。
x	一个原子向量methods "shell"和"quick".什么时候x是非原子的R对象，默认"auto"和"radix"方法可能有效，如果order(x,..)做。
partial	用于部分排序的索引向量。 (未实现非 NULL 值。)
decreasing	合乎逻辑的。排序顺序应该是递增还是递减？对于 "radix" 方法，这可以是长度等于 ... 中参数数量的向量，并且根据需要回收元素。对于其他方法，其长度必须为一。
na.last	用于控制 NA 的处理。如果是TRUE，则数据中缺失的值放在最后；如果是 FALSE ，则将它们放在第一位；如果 NA ，它们将被删除(参见“注意”。)
method	使用的方法：允许部分匹配。对于数值向量、整数向量、逻辑向量和元素少于 2^{31} 的因子，默认值 ( "auto" ) 意味着 "radix"。否则，它意味着 "shell" 。有关方法 "shell" 、 "quick" 和 "radix" 的详细信息，请参阅 sort 的帮助。

细节

如果第一个向量中存在平局，则使用第二个向量中的值来打破平局。如果值仍然相等，则后面的参数中的值将用于打破平局(请参阅第一个示例)。使用的排序是稳定的(method = "quick" 除外)，因此任何未解决的关系都将保留其原始顺序。

复数值首先按实部排序，然后按虚部排序。

除了方法 "radix" 之外，字符向量的排序顺序将取决于所使用的语言环境的整理顺序：请参阅 Comparison 。

"shell" 方法通常是最安全的选择，并且是默认方法，除了短因子、数值向量、整数向量和逻辑向量(其中假设为 "radix")。方法 "radix" 在线性时间内稳定地对逻辑、数字和字符向量进行排序。尽管存在缺点，但它优于其他方法，特别是对于字符向量(请参阅 sort )。 sort.list 的方法 "quick" 仅支持数字 x 和 na.last = NA ，该方法不稳定，并且比 "radix" 慢。

支持 partial = NULL 是为了与 S 的其他实现兼容，但不接受其他值，并且排序始终是完整的。

对于一个类R对象，排序顺序取自xtfrm：正如它的帮助页面所指出的，这可能会很慢，除非已经定义了合适的方法或is.numeric(x)是真的。对于因子，这对内部代码进行排序，这特别适合有序因子。

值

整数向量，除非任何输入具有 2^{31} 或更多元素(当它是双向量时)。

警告

在编程使用中，命名 ... 参数是不安全的，因为名称可能与当前或将来的控制参数(例如 decreasing )匹配。有时遇到的不安全做法是调用 do.call('order', df_obj)，其中 df_obj 可能是数据帧：复制 df_obj 并删除任何名称，例如使用 unname 。

注意

sort.list 可能会被错误地调用为带有列表参数的 sort 的方法：它为列表 x 提供合适的错误消息。

na.last = NA 的行为存在历史差异：sort.list 删除 NA，然后计算剩余元素之间的顺序：order 计算原始向量的非 NA 元素之间的顺序。因此

   x[order(x, na.last = NA)]
   zz <- x[!is.na(x)]; zz[sort.list(x, na.last = NA)]

两者都对 x 的非 NA 值进行排序。

之前R3.3.0method = "radix"仅支持范围小于 100,000 的整数。

例子

require(stats)

(ii <- order(x <- c(1,1,3:1,1:4,3), y <- c(9,9:1), z <- c(2,1:9)))
## 6  5  2  1  7  4 10  8  3  9
rbind(x, y, z)[,ii] # shows the reordering (ties via 2nd & 3rd arg)

## Suppose we wanted descending order on y.
## A simple solution for numeric 'y' is
rbind(x, y, z)[, order(x, -y, z)]
## More generally we can make use of xtfrm
cy <- as.character(y)
rbind(x, y, z)[, order(x, -xtfrm(cy), z)]
## The radix sort supports multiple 'decreasing' values:
rbind(x, y, z)[, order(x, cy, z, decreasing = c(FALSE, TRUE, FALSE),
                       method="radix")]

## Sorting data frames:
dd <- transform(data.frame(x, y, z),
                z = factor(z, labels = LETTERS[9:1]))
## Either as above {for factor 'z' : using internal coding}:
dd[ order(x, -y, z), ]
## or along 1st column, ties along 2nd, ... *arbitrary* no.{columns}:
dd[ do.call(order, dd), ]

set.seed(1)  # reproducible example:
d4 <- data.frame(x = round(   rnorm(100)), y = round(10*runif(100)),
                 z = round( 8*rnorm(100)), u = round(50*runif(100)))
(d4s <- d4[ do.call(order, d4), ])
(i <- which(diff(d4s[, 3]) == 0))
#   in 2 places, needed 3 cols to break ties:
d4s[ rbind(i, i+1), ]

## rearrange matched vectors so that the first is in ascending order
x <- c(5:1, 6:8, 12:9)
y <- (x - 5)^2
o <- order(x)
rbind(x[o], y[o])

## tests of na.last
a <- c(4, 3, 2, NA, 1)
b <- c(4, NA, 2, 7, 1)
z <- cbind(a, b)
(o <- order(a, b)); z[o, ]
(o <- order(a, b, na.last = FALSE)); z[o, ]
(o <- order(a, b, na.last = NA)); z[o, ]


##  speed examples on an average laptop for long vectors:
##  factor/small-valued integers:
x <- factor(sample(letters, 1e7, replace = TRUE))
system.time(o <- sort.list(x, method = "quick", na.last = NA)) # 0.1 sec
stopifnot(!is.unsorted(x[o]))
system.time(o <- sort.list(x, method = "radix")) # 0.05 sec, 2X faster
stopifnot(!is.unsorted(x[o]))
##  large-valued integers:
xx <- sample(1:200000, 1e7, replace = TRUE)
system.time(o <- sort.list(xx, method = "quick", na.last = NA)) # 0.3 sec
system.time(o <- sort.list(xx, method = "radix")) # 0.2 sec
##  character vectors:
xx <- sample(state.name, 1e6, replace = TRUE)
system.time(o <- sort.list(xx, method = "shell")) # 2 sec
system.time(o <- sort.list(xx, method = "radix")) # 0.007 sec, 300X faster
##  double vectors:
xx <- rnorm(1e6)
system.time(o <- sort.list(xx, method = "shell")) # 0.4 sec
system.time(o <- sort.list(xx, method = "quick", na.last = NA)) # 0.1 sec
system.time(o <- sort.list(xx, method = "radix")) # 0.05 sec, 2X faster

参考

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.

Knuth, D. E. (1998) The Art of Computer Programming, Volume 3: Sorting and Searching. 2nd ed. Addison-Wesley.

也可以看看

sort、rank、xtfrm。