一，排序函数
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"