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。