R语言：数据结构

1. 数据结构概述

概念

数据结构是计算机存储、组织数据的方式

数据结构是指相互之间存在一种或多种特定关系的数据元素集合

R中常见的数据结构

• 向量：一系列元素的组合
• 数组：数组是k维的数据表
• 矩阵：矩阵是数组的一个特例，维数k = 2
• 数据框：是由一个或几个向量和（或）因子构成，它们必须是等长的，但可以是不同的数据类型
• 列表：列表可以包含任何类型的对象
• 因子：如"a",“a”,“a”,“a”,“b”,“b”,“b”,“c”

2. 向量

向量概述

向量(vector)用于存储数值型、复数型、字符型或逻辑型数据，可通过执行组合功能的函数c()来创建向量。

单个向量中，数据的模式(mode)必须是相同的

字符型向量的每个元素都带有双引号

向量创建

score<-c(90,77,82,85)
character<-c("one hundred", "two thousand", "three million")
logical<-c(TRUE, FALSE, TRUE, FALSE)

score
[1] 90 77 82 85
character
[1] "one hundred" "two thousand" "three million"
logical
[1] TRUE FALSE TRUE FALSE

x<-c(1, "one", TRUE)
x[1] "1" "one hundred" "TRUE"
mode(x)
[1] "character"

score<-c(90,77,82,85)
score
[1] 90 77 82 85
attributes(score)
NULL
names(score)<-c("A","C","B","B")
score
A C B B
90 77 82 85
attributes(score)
$names
[1] "A" "C" "B" "B"

向量元素的选取

1. 通过数字索引进行访问

> x <- c(1:10)
> x
 [1]  1  2  3  4  5  6  7  8  9 10
# R语言中的索引位置从1开始
> x[1]
 [1] 1
# 可以一次用向量索引多个元素
> x[c(1,3,5)]
 [1] 1 3 5
# 索引负元素指显示除负元素以外的所有元素
> x[-4]
 [1]  1  2  3  5  6  7  8  9 10

2. 通过表达式进行访问

> x <- c(1:10)
# 输出大于4的数
> x[x>4]
 [1]  5  6  7  8  9 10
# 输出大于4小于8的数
> x[x>4 & x<8]
 [1] 5 6 7
# 判断1是否在x中
> 1 %in% x
 [1] TRUE
# 将x中的数据定义为TRUE，并输出为TRUE的元素
> x[1 %in% x]
 [1]  1  2  3  4  5  6  7  8  9 10

3. 通过索引名进行访问

> x <- c(1:10)
> names(x) <- c("一","二","三","四","五","六","七","八","九","十")
> x["三"]
三 
 3 
> x
一 二 三 四 五 六 七 八 九 十 
 1  2  3  4  5  6  7  8  9 10 

向量运算

1. 向量与数值的加减乘除

   > x <- 1:10
   # 对向量的运算都是对所有元素的操作
   > x + 2
    [1]  3  4  5  6  7  8  9 10 11 12
   > x - 3
    [1] -2 -1  0  1  2  3  4  5  6  7
   > x <- x + 1
   > x
    [1]  2  3  4  5  6  7  8  9 10 11
   # **是幂次运算
   > x ** 2
    [1]   4   9  16  25  36  49  64  81 100 121
   # %%是求余数
   > x %% 2
    [1] 0 1 0 1 0 1 0 1 0 1
   # %/%是整除运算
   > x %/% 2
    [1] 1 1 2 2 3 3 4 4 5 5
   

2. 向量与向量的加减乘除

   > x <- 1:10
   > y <- seq(1,100,length.out = 10)
   > x + y
    [1]   2  14  26  38  50  62  74  86  98 110
   > x * y
    [1]    1   24   69  136  225  336  469  624  801 1000
   > x ** y
    [1]  1.000000e+00  4.096000e+03  9.414318e+10
    [4]  2.951479e+20  2.842171e+31  3.771117e+43
    [7]  4.183778e+56  2.760699e+70  8.464150e+84
   [10] 1.000000e+100
   > x %% y
    [1]  0  2  3  4  5  6  7  8  9 10
   > x %/% y
    [1] 1 0 0 0 0 0 0 0 0 0
   #向量运算长的必须是短的元素的整数倍，可以进行循环
   

3. 数学函数

   • abs：返回每个向量的绝对值
   • sqrt：计算平方根
   • log、log10：计算对数
   • exp：计算指数
   • ceiling：返回不小于向量的最小整数
   • floor：返回不大于向量的最大整数
   • trunc：返回整数部分
   • round：进行四舍五入

4. 统计函数

   • sum：向量所有元素之和
   • max：向量元素最大值
   • min：向量元素最小值
   • range：向量元素最大和最小值
   • mean：向量均值
   • var：向量方差
   • sd：向量标准差
   • prod：向量连乘积
   • median：向量中位数
   • quantile：向量分位数
   • which.min：最大值的索引值，还可以与其它统计函数结合

3. 矩阵

矩阵概述

矩阵(matrix)是向量的推广，可通过函数matrix()来创建

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

• data包含了矩阵的元素
• nrow和ncol用以指定行和列的维数
• byrow则表明矩阵应当按行填充（byrow=TRUE）还是按列填充（byrow=FALSE），默认情况下按列填充
• dimnames包含了可选的、以字符型向量表示的行名和列名

与向量一样，矩阵中所有元素必须为同一种数据类型

矩阵的创建

x<-matrix(c(1:12),nrow=3,ncol=4) 
x
   [,1][,2][,3][,4] 
[1,] 1   4   7  10
[2,] 2   5   8  11
[3,] 3   6   9  12

x<-matrix(c(1:12),nrow=3,ncol=4,byrow=TRUE)
x
   [,1][,2][,3][,4] 
[1,] 1  2   3   4 
[2,] 5  6   7   8 
[3,] 9  10  11  12

矩阵元素的选取

#选取列
M1[,2]
#选取行
M1[1,]
#选取单个元素
M1[3,4]
#选取符合要求的元素
M1[M1>10]
#选取矩阵x的第2行第2、4列，第3行第2、4列
x[c(2,3),c(2,4)]
#剔除矩阵x的第1行
x[-1,]
#剔除矩阵的第1行同时剔除矩阵的第3列
x[-1,-3]

矩阵的其他知识

• 参数drop=FALSE的作用

x[2,]
[1] 5 6 7 8
x[,3] 
[1] 3 7 11
is.vector(x[,3])
[1] TRUE

x[,3,drop=FALSE]
    [,1] 
[1,] 3 
[2,] 7 
[3,] 11
is.matrix(x[,3,drop=FALSE])
[1] TRUE

• 命名函数rownames()和colnames()

rownames(x)<-c("x", "y", "z")
colnames(x)<-c(LETTERS[1:4])
x
 A B C D x 1 2 3 4 y 5 6 7 8 z 9 10 11 12
x["z","B"]
[1] 10

• 结合函数cbind()：将所需要的变量以列的方式组合

• 结合函数rbind()：将所需要的变量以行的方式组合

• 判断函数is.vector()、is.matrix() 、identical()

4. 数组

数组概述

数组(array)是矩阵的推广，可通过函数array()来创建。数组和矩阵作为数据结构的一个主要特征是具有维度（缩写为dim），可以说，数组和矩阵是添加了维度属性的向量

数组中所有元素必须为同一种数据类型

array(data = NA, dim = length(data), dimnames = NULL)

数组的创建

创建数组有两种方式：一是通过函数dim()创建

二是通过array()函数创建，同时可以指定索引名

# 方式一：dim()
> x <- 1:8
> dim(x) <- c(2,2,2)
> x
, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

# 方式二：array()
> dim1 <- c("A1","A2")
> dim2 <- c("B1","B2")
> dim3 <- c("C1","C2")
> z <- array(1:8,c(2,2,2),dimnames = list(dim1,dim2,dim3))
> z
, , C1

   B1 B2
A1  1  3
A2  2  4

, , C2

   B1 B2
A1  5  7
A2  6  8

数组元素的选取

ray<-array(c(1:20), dim=c(5,3,2))
ray
, , 1
 [,1] [,2] [,3] [1,] 1 6 11
[2,] 2 7 12
[3,] 3 8 13
[4,] 4 9 14
[5,] 5 10 15
, , 2
    [,1][,2][,3] 
[1,] 16   1  6 
[2,] 17   2  7 
[3,] 18   3  8 
[4,] 19   4  9 
[5,] 20   5  10

#访问数组中一个元素
ray[3, 2, 2] 
[1] 3
#访问数组x中两个矩阵的第1行 第1、2列，第2行第1、2列
x[c(1,2),c(1,2),c(1,2)]

, , 1

  [,1][,2] 
[1,] 1 6 
[2,] 2 7 

, , 2

   [,1][,2] 
[1,] 16 1 
[2,] 17 2

5. 列表

列表概述

列表中的元素可以是单个字符，数值，也可以是向量，矩阵，数组，数据框，列表。换言之，列表允许包含不同类型的元素

列表顾名思义就是用来存储很多内容的一个集合，在其他编程语言中，列表一般和数组是等同的，但是在R语言中，列表却是R中最复杂的一种数据结构，也是非常重要的一种数据结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nka151LX-1607421681290)(F:\JianShu_material\R\图片\数据结构\002.png)]

list()函数可以创建一个列表，其用法与矩阵函数相似

列表的创建

创建一个列表使用函数list()，将列表元素添加其中，并且可以为列表元素命名

> a <- 1:10
> b <- "hello world"
> c <- matrix(1:12,nrow = 3,ncol = 4)
> mlist <- list(a,b,c)
> mlist
[[1]]
 [1]  1  2  3  4  5  6  7  8  9 10

[[2]]
[1] "hello world"

[[3]]
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

> mlist <- list(first=a,second=b,third=c)
> mlist
$first
 [1]  1  2  3  4  5  6  7  8  9 10

$second
[1] "hello world"

$third
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

列表元素的选取

# 通过数值进行索引
> mlist[1]
$first
 [1]  1  2  3  4  5  6  7  8  9 10

# 可以一次索引多个向量
> mlist[c(1,2)]
$first
 [1]  1  2  3  4  5  6  7  8  9 10
$second
[1] "hello world"

# 可以通过名称进行索引
> mlist["first"]
$first
 [1]  1  2  3  4  5  6  7  8  9 10

# 使用两个中括号进行索引时，代表是被索引元素的数据类型，而不是列表类型
> mlist[[1]]
 [1]  1  2  3  4  5  6  7  8  9 10

6. 数据框

数据框概述

数据框是R语言中应用最广泛的数据结构

数据框的每一列的数据类型必须相同，但不同的列可以存储不同的类型的数据

数据框(dataframe)可容纳不同类型的数据，通过函数data.frame()来创建

data.frame(..., row.names = NULL, check.rows = FALSE, 
   check.names = TRUE, fix.empty.names = TRUE, 
   stringsAsFactors = default.stringsAsFactors())

数据框的创建

> a <- c("北京","上海","广州")
> b <- c("100平","125平","126平")
> c <- c("100万","150万","200万")
# 使用data.frame将已经建立好的向量作为参数传入其中
> d <- data.frame(a,b,c)
> d
     a     b     c
1 北京 100平 100万
2 上海 125平 150万
3 广州 126平 200万

数据框元素的选取

> d[1]
     a
1 北京
2 上海
3 广州
> d[c(1,3)]
     a     c
1 北京 100万
2 上海 150万
3 广州 200万

单层方括号[]和双层方括号[[]]的区别

baby[7]
 breastmilk
1 TRUE
2 TRUE
3 FALSE
4 FALSE
5 FALSE
6 FALSE
is.data.frame(baby[7])
[1] TRUE

baby[[7]]
[1] TRUE TRUE FALSE FALSE FALSE FALSE
is.data.frame(baby[[7]])
[1] FALSE
is.vector(baby[[7]])
[1] TRUE

• 命令baby[7]提取了第7列，形成一个新的数据框
• 命令baby[[7]]与命令baby[7]不同，baby[[7]]只提取了第7列的观测值，即数据框中第7列向量的元素，其结果是一个向量

符号"$"的用法

使用“数据框名$变量名”来提取对应的列，其作用与双方括号[[]]相同

baby$observation
[1] 1 2 3 4 5 6
baby$height
[1] 71 69 68 70 68 68
is.vector(baby$height) [1] TRUE

7. 因子

因子概述

因子是R语言中非常重要的的对象，或者说向量对象

因子主要用于管理离散的分类变量，比如成绩评定等级（A、B、C），颜色的分类（红、黄、蓝）

因子对象就是管理这些类别变量的重要工具+

因子(factor)主要用于管理离散的类别变量，可通过函数factor()来创建

factor(x = character(), levels, labels = levels, exclude = NA, 
   ordered = is.ordered(x), nmax = NA)

• x是字符型向量
• 参数levels用来指定因子的水平值
• 参数labels用来指定水平值的名称
• 参数exclude用来指定与向量x对应的、需要剔除的水平值
• 参数ordered表示是否对因子的水平值进行排序
• 参数nmax表示水平值的上界

因子的创建

> grade <- c("A","B","B","A","C")
> gradef <- factor(grade)
# levels是因子的一个重要属性，揭示了因子中的类别
> gradef
[1] A B B A C
Levels: A B C

grade<-c("A","B","D","C","B")
gradef<-factor(grade)
gradef
[1] A B D C B
Levels: A B C D
class(gradef) [1] "factor"
mode(gradef) [1] "numeric"
str(gradef)
Factor w/ 4 levels "A","B","C","D": 1 2 4 3 2

#变量grade是长度为5的字符型向量，经过factor()函数赋值后，变量gradef是长度为5、类型为因子的对象，它有4个水平（levels），并默认地按字母顺序排列分别为A、B、C、D  

#mode() 函数和str() 函数显示 ，factor()函数将变量grade的向量存储为数值型(1,2,4,3,2) ，即存在对应关系A=1、B=2、C=3、D=4。