一，排序函数

R语言中，和排序相关的常用函数有：order()，sort()，rank()，一般是对向量进行操作，也可以对数据框的列进行操作。
1. order(..., decreasing = FALSE)
“...” 中可以是一个向量（数值型，字符型，逻辑型，因子型均可），也可以是多个向量（长度必须相同）
它返回的是排列后（默认是升序）的元素在该向量中所处的位置，即索引，所以返回的不是原来向量的那些数值，而是排序后那些数值所对应的位置。它在常在数据框中运用，可以根据某一列和某几列来调整数据框。
1.1 单个向量

> vec1 <- c(94,83,72,25,100,98,57,69,29,45)
> vec1
 [1]  94  83  72  25 100  98  57  69  29  45
> order(vec1) #生成的是索引
 [1]  4  9 10  7  8  3  2  1  6  5
> vec1[order(vec1)] #根据 order 函数生成的索引提取后就是排列后的元素，等同于 sort(vec1)
 [1]  25  29  45  57  69  72  83  94  98 100

1.2 多个向量（数据框的多列）

#创建一个向量
> df <- data.frame(var1 = c(1,1,3:1,1:4,3),
+                  var2 = c(9,9:1)，
+                  var3 = c(2,1:9))
> df
   var1 var2 var3
1     1    9    2
2     1    9    1
3     3    8    2
4     2    7    3
5     1    6    4
6     1    5    5
7     2    4    6
8     3    3    7
9     4    2    8
10    3    1    9
#按列var1将排序
##先用order函数处理列var1
> order(df$var1)
 [1]  1  2  5  6  4  7  3  8 10  9
##然后用上面生成的索引来调整数据框 df
> df[order(df$var1),]   #注意是将生成的索引放在行的位置，另外注意的是此时的 df 只是调整后输出到console而已，要使得调整生效必须将调整后的df赋值给原来的 df 
   var1 var2 var3
1     1    9    2
2     1    9    1
5     1    6    4
6     1    5    5
4     2    7    3
7     2    4    6
3     3    8    2
8     3    3    7
10    3    1    9
9     4    2    8

上面最左边的一列数值（不是var1这一列）就是 order(df$var1) 生成的，列var1的顺序就是order后的，注意和前面df 的列var1进行比较，还有一点要牢记的就是这种在数据框里的调整，是整行变动(都按列var1来)。故而本质上，对于数据框而言，order函数出来的是原始数据框中的行号，行号顺序一变，意味着行号代表的整行跟着变。
接着再按列var2排序（注意是在列var1已经排好的基础上再按列var2重新排序，即此时列var1里的非重复值的行顺序不会再变了，只有列var1里有重复值（数值相同的）的行才会变换，而且是按照列var2来变换，。如还要按其它列再排，以此类推）：

> order(df$var1,df$var2)
 [1]  6  5  1  2  7  4 10  8  3  9
> df[order(df$var1,df$var2),]
   var1 var2 var3
6     1    5    5
5     1    6    4
1     1    9    2
2     1    9    1
7     2    4    6
4     2    7    3
10    3    1    9
8     3    3    7
3     3    8    2
9     4    2    8

最后再按列var3排序，此时只有列var2中有重复值的行（当然这时var1肯定也是重复的）才会变换------这里是含有9的那两行，并且是按照这些重复值对应到列var3的那些行的数值（数值1和2）来变的

> order(df$var1,df$var2,df$var3)
 [1]  6  5  2  1  7  4 10  8  3  9
> df[order(df$var1,df$var2,df$var3), ]   #order后的结果放在中括号内行的位置
   var1 var2 var3
6     1    5    5
5     1    6    4
2     1    9    1
1     1    9    2
7     2    4    6
4     2    7    3
10    3    1    9
8     3    3    7
3     3    8    2
9     4    2    8

总结提升，order()函数中，如果第一个向量（或者说是数据框里你想要根据它来调整的那一列）里没有重复值，那么按照后面的所有向量（不管有多少个）的重排都不会进行（或者说重排的结果不会变），order(vec1,vec2,vec3,...) 返回的行号及其顺序和 order(vec1) 的是一样。

> df <- data.frame(var1 = c(2,4,3,1,5,7,9,10,6,8),
+                  var2 = c(9,9:1)，
+                  var3 = c(2,1:9))
> order(df$var1)
 [1]  4  1  3  2  5  9  6 10  7  8
> order(df$var1,df$var2)
 [1]  4  1  3  2  5  9  6 10  7  8
> order(df$var1,df$var2,df$var3)
 [1]  4  1  3  2  5  9  6 10  7  8

同理，也可以处理对应的行（比如矩阵或是数据框的行）

> ob1 <- c(1,1,3:1,1:4,3)
> ob1
 [1] 1 1 3 2 1 1 2 3 4 3
> ob2 <- c(9,9:1)
> ob2
 [1] 9 9 8 7 6 5 4 3 2 1
> ob3 <- c(2,1:9)
> ob3
 [1] 2 1 2 3 4 5 6 7 8 9
> rbind(ob1,ob2,ob3)
    [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
ob1    1    1    3    2    1    1    2    3    4     3
ob2    9    9    8    7    6    5    4    3    2     1
ob3    2    1    2    3    4    5    6    7    8     9
> class(rbind(ob1,ob2,ob3))
[1] "matrix" "array" 
> order(ob1,ob2,ob3)  #注意这里ob1,ob2,ob3对应的是三个向量
 [1]  6  5  2  1  7  4 10  8  3  9
> rbind(ob1,ob2,ob3)[ ,order(ob1,ob2,ob3)]  #order后的结果放在中括号内列的位置
    [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
ob1    1    1    1    1    2    2    3    3    3     4
ob2    5    6    9    9    4    7    1    3    8     2
ob3    5    4    1    2    6    3    9    7    2     8

1.3 factor（因子型向量）

> vec2 <- factor(x=c("B","A","A","C","B","A","C"),levels = c("A","B","C"),ordered = T)
> vec3 <- c(94,83,72,25,100,98,57)
> df1 <- data.frame(var1 = vec2,
+                   var2 = vec3)
> df1
  var1 var2
1    B   94
2    A   83
3    A   72
4    C   25
5    B  100
6    A   98
7    C   57
> order(df1$var1)
[1] 2 3 6 1 5 4 7
> df1[order(df1$var1),]
  var1 var2
2    A   83
3    A   72
6    A   98
1    B   94
5    B  100
4    C   25
7    C   57
> order(df1$var1,df1$var2)
[1] 3 2 6 1 5 4 7
> df1[order(df1$var1,df1$var2),]
  var1 var2
3    A   72
2    A   83
6    A   98
1    B   94
5    B  100
4    C   25
7    C   57

2. sort(x, decreasing = FALSE)
x 只能是一个向量（数值型，字符型，逻辑型，因子型均可）
返回的是排序后（默认是升序）的那个数值向量（还是那些数值，只不过是排序过了的）

> vec1 <- c(94,83,72,25,100,98,57,69,29,45)
> vec1
 [1]  94  83  72  25 100  98  57  69  29  45
> sort(vec1)
 [1]  25  29  45  57  69  72  83  94  98 100
> df1
  var1 var2
1    B   94
2    A   83
3    A   72
4    C   25
5    B  100
6    A   98
7    C   57
> sort(df1$var1)
[1] A A A B B C C
Levels: A < B < C
> sort(df1$var1,df1$var2)   #只能是按照一个向量
Error in sort(df1$var1, df1$var2) : 
  'decreasing' must be a length-1 logical vector.
Did you intend to set 'partial'?

3. rank(x, na.last = TRUE)
求秩的函数，x 只能是一个**向量（数值型，字符型，逻辑型）， 该向量一般不会有重复值，返回的是该向量中对应元素的“排名”，即元素顺序它不会改变，只是告诉你每个元素在整个向量中的名次（如果要排序（默认是升序）的话）。

> vec1 <- c(94,83,72,25,100,98,57,69,29,45)
> vec1
 [1]  94  83  72  25 100  98  57  69  29  45
> rank(vec1)
 [1]  8  7  6  1 10  9  4  5  2  3

如果向量有重复值，出现的结果会有些不太好处理

> df <- data.frame(var1 = c(1,1,3:1,1:4,3),
+                  var2 = c(9,9:1)，
+                  var3 = c(2,1:9))
> df
   var1 var2 var3
1     1    9    2
2     1    9    1
3     3    8    2
4     2    7    3
5     1    6    4
6     1    5    5
7     2    4    6
8     3    3    7
9     4    2    8
10    3    1    9
> rank(df$var1)   # var1有重复值
 [1]  2.5  2.5  8.0  5.5  2.5  2.5  5.5  8.0 10.0  8.0
> rank(df$var2)   # var2有重复值
 [1] 9.5 9.5 8.0 7.0 6.0 5.0 4.0 3.0 2.0 1.0
> vec <- c(94,83,72,25,72,98,57,69,29,45)
> vec
 [1] 94 83 72 25 72 98 57 69 29 45  # 有重复值
> rank(vec)
 [1]  9.0  8.0  6.5  1.0  6.5 10.0  4.0  5.0  2.0  3.0

二，match（x，y)函数

匹配两个向量，返回的是第一个向量 x中的各个元素在第二个向量 y中所匹配的元素的位置值（索引，下标值），即返回的是第二个向量的下标值组成的向量。
注意事项：
1. 返回的下标值向量的长度与第一个向量相等，即 length(x) == length(match(x,y)) 为 TRUE。
2. 第一个向量可以是只有一个元素的向量。
3. 两个向量的长度不一定要相等。
4. 返回的是 x中每个元素在y中的位置，可用来提取y中的元素，没有匹配上的会返回 NA。
拓展用法：
y [match(x, y)]： x中 和y 相同的元素都是哪些，前提是x中的元素在y中都有（即x是y的子集），否则会返回 NA。（最好是用x[ x %in y]）
y[-match(x, y)]： 找出 y里面有 x里面没有的数值，前提是x中的元素在y中都有（即x是y的子集），否则会报错。

> tmp <- LETTERS[1:26]
> tmp
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"
> match("O",tmp)    # 第一个向量只有一个元素
[1] 15
> match(c("Z","D"),tmp)
[1] 26  4
> x <- c("TRUE","Z","D")
> x
[1] "TRUE" "Z"    "D"   
> y <- tmp
> y
 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"
> match(x,y)  #没有匹配上的会返回 NA
[1] NA 26  4
> y[match(x,y)]   #没有匹配上的会返回 NA
[1] NA  "Z" "D"
> y[-match(x,y)]  #会报错
Error in y[-match(x, y)] : only 0's may be mixed with negative subscripts

当两个向量类型不一样时, match函数会进行类型转换，然后再匹配。

> a <- c(1,TRUE,0)   # 逻辑值可以当成1或0，优先级：字符型>数值型>逻辑型
> a
[1] 1 1 0
> class(a)
[1] "numeric"
> b <- c(T,0,"1")  #字符型数据优先级最高
> b
[1] "TRUE" "0"    "1"   
> class(b)
[1] "character"
> match(a,b) 
[1] 3 3 2
> b[match(a,b)]
[1] "1" "1" "0"
> a1 <- c(F,TRUE)
> a1
[1] FALSE  TRUE
> class(a1)
[1] "logical"
> match(a,a1)
[1] 2 2 1
> a1[match(a,a1)]
[1]  TRUE  TRUE FALSE
> match(a1,a)
[1] 3 1
> a[match(a1,a)]
[1] 0 1

x %in% y
判断x中的元素是否都在y中，返回的是个长度和 x 一样的逻辑值向量，存在的话返回TRUE，否则返回FALSE。
sum(x %in% y)： 统计 x 中有多少个元素在y中，或者说 x 和 y 有几个相同元素
x[x %in% y]： x中 和y 相同的元素都是哪些

> x <- c("A","Z","D","ZD")
> y <- LETTERS[1:26]
> x %in% y
[1]  TRUE  TRUE  TRUE FALSE
> sum(x %in% y)   # 统计 x 中有多少个元素在y中，或者说 x 和 y 有几个相同元素
[1] 3    
> x[x %in% y]  # x 和 y中有几个相同元素，都是哪些元素。
[1] "A" "Z" "D"