精华内容
下载资源
问答
  • 数据结构算法 托马斯·H·科门(Thomas H. Cormen)等人在“算法导论第三版”中教授算法合集。 在制品
  • 算法 以不同语言实现的数据结构和算法。
  • 不同语言编写的数据结构和算法的简洁示例实现
  • 用您喜欢的语言实现任何数据结构 ...任何人都可以对此存储库加注星标,分叉或克隆,并且可以添加任何类型的数据结构或算法代码,并且可以在hackerberfest期间提高PR。 贡献者 :sparkles: 感谢这些很棒的人():
  • 用各种不同的语言实现算法和数据结构集合
  • 示例:使用不同的语言练习算法和数据结构-源码
  • 不同语言编写的数据结构和算法的干净示例实现。 实施清单 贡献! 始终欢迎捐款。 语言无所谓。 只要确保您正在实现一个算法即可。 欢迎公关。 要开始开发,请遵循以下结构: 算法类型/算法名称/语言名称/文件...
  • 该存储库包含您将找到的所有著名的数据结构和算法的集合。 作为Hacktoberfest 2019的一部分,您将有机会为该存储库做出贡献并熟悉开源文化。 如何贡献 创建有关您要实现的数据结构/算法或其应用程序的问题。 等待...
  • 各种语言的数据结构实现的存储库。 在这里,我们重点介绍数据结构的实现。 如果您想通过算法做出贡献,请查看此。 贡献准则 为了您的贡献,请遵循我们的新 Hacktober Fest 20更新 PRs符合以下条件: 在十月份提交,...
  • 目录 1. C/C++中数组的实现方式 ...在大部分数据结构和算法书籍中,数组作为最基础的数据类型,是最先被介绍的。一般我们都是这么定义数组的。 数组这种数据结构,是存储相同数据类型的一块连...

    本文完全copy转发的:https://mp.weixin.qq.com/s/E-c41h2v_AfffrlAQpkyLg

    目录

    1. C/C++中数组的实现方式

    2. Java中数组的实现方式

    3. JavaScript中数组的实现方式


    在大部分数据结构和算法书籍中,数组作为最基础的数据类型,是最先被介绍的。一般我们都是这么定义数组的。

    数组这种数据结构,是存储相同数据类型的一块连续的存储空间

    解读一下这个定义的话,那就是:数组中的数据必须是相同类型的,数组中的数据必须是连续存储的。

    只有这样,数组才能实现根据下标快速地(时间复杂度是O(1))定位一个元素(快速的随机访问)。

    但是,如果你是一名比较喜欢钻研的程序员,你会发现,在你所熟悉的编程语言中,”数组“这种数据类型,并不一定完全符合上面的定义。比如Javascript这种语言中,数组中的数据不一定是连续存储的,也不一定非得是相同类型,甚至数组可以是变长的。

    var arr = new Array(4,'hello', new Date());

    除此之外,大部分数据结构和算法书籍中,在讲到二维或者多维数组中数据的存储方式的时候,一般都会这么说:

    二维数组中的数据,是先按行再按列(或者先按列后按行),依次存储在连续的存储空间中。

    如果二维数组定义为a[n][m],那a[i][j]的寻址公式为下面这样(先按行后按列存储):

    address_a[i][j] = address_base + (i*m+j) * data_size;

    但是,在有些编程语言中,二维数组并不满足上面的说法和寻址公式。比如,Java中的二维数组,第二维可以是不同长度的,而且第二维的三个数组(arr[0]、arr[1]、arr[2])并不是连续存储。

    int arr[][] = new int[3][];arr[0] = new int[1];arr[1] = new int[2];arr[2] = new int[3];

    是不是看的一头雾水?难道数据结构和算法书籍里的讲解脱离实践?难道编程语言中的数组没有完全按照数组的定义来设计?哪个对哪个错呢?

    实际上,两个都没错。编程语言中的”数组“并不完全等同于,我们在讲数据结构和算法的时候,提到的”数组“。编程语言在实现自己的”数组“类型的时候,并不是完全遵循数据结构”数组“的定义,而是针对编程语言自身的特点,做了调整。

    在不同的编程语言中,数组这种数据类型的实现方式都不大相同,我就拿几个比较典型的编程语言:C/C++、Java、Javascript,来给你展示一下,几种比较有代表性的数组实现方式。

    1. C/C++中数组的实现方式

    C/C++中的数组,是非常标准的数据结构中的数组,也就是连续存储相同类型的数据的一块内存空间。在C/C++中,不管是基本类型数据,比如int、long、char,还是结构体、对象,在数组中都是连续存储的。我举了一下例子,你可以看下。

    int arr[3];arr[0] = 0;arr[1] = 1;arr[2] = 2;

    数组arr中存储的是int基本类型的数据,对应的内存存储方式,如果用画图的方式表示出来的话,就是下面这样子。从图中可以看出,数据是存储在一片连续的内存空间中的。

    刚刚讲的是用数组存储基本类型数据的例子,我们再来看:用数组存储struct结构体(或者class对象)的例子。​​​​​​​

    struct Dog {  char a;  char b;};struct Dog arr[3];// 为了节省页面,放到了一行里了arr[0].a = '0'; arr[0].b = '1'; arr[1].a = '2'; arr[1].b = '3';arr[2].a = '4'; arr[2].b = '5';

    如果我们把这个结构体数组,用画图的方式表示出来,就是下面这个样子。我们发现,结构体数组中的元素,也是存储在一片连续的内存空间中的。

    刚刚讲的都是一维数组的数据存储方式,我们再来看下,二维数组的数据存储方式。注意,多维数组跟二维数组大同小异,我们就拿二维数组来讲解。我们来看下面这段代码。

    struct Dog {

      char a;    char b;};struct Dog arr[3][2];

    我们把上面的struct Dog arr[3][2]对应的数据存储方式,用图画出来的话,就是下面这样子的。从图中,我们发现,C/C++的二维数组,跟数据结构中二维数组是一样的,数据是先按行后按列,并且是连续存储的。

    刚刚我们分析了C/C++的基本数据类型数组、结构体或对象数组、以及二维数组。它们的数据存储方式,完全符合数据结构和算法中数组的定义。

    你还知道,在其他哪些编程语言中,数组的定义完全符合数据结构中数组的定义吗?

    2. Java中数组的实现方式

    看完了C/C++中的数组,我们再来看下,Java中的数组。Java中的数组就有点跟数据结构中数组的定义不一样了。我们还是分三种情况来分析。这三种情况分别是:基本数据类型数组、对象数组、二维数组(或多维数组)。

    首先,我们先来看下基本数据类型数组,也就是说,数组中存储的是int、long、char等基本数据类型的数据。我们还是拿一段代码来举例。​​​​​​​

    int arr[] = new int[3];arr[0] = 1;arr[1] = 2;arr[2] = 3;

    如果我们把arr中数据在内存中的存储方式,用图画出来的话,就是下面这个样子的。注意,new申请的空间在堆上,arr存储在栈上。arr存储的是数组空间的首地址。

     

    从图中来看,在Java中,基本数据类型数组还是符合数据结构中数组的定义的。数组中数据是相同类型的、并且存储在一片连续的内存空间中。

    看完了基本数据类型数组,我们再来看下对象数组,也就是说,数组中存储的不是int、long、char这种基本类型数据了,而是对象。我们还是拿一个例子来说明。

    ​​​​​​​

    class Person {    private String name;    public Person(String name) {    this.name = name;    }}
    Person arr[] = new Person[3];arr[0] = new Person("0");arr[1] = new Person("1");arr[2] = new Person("2");

    在上面的代码中,数组arr中存储是Person对象。同样,我们还是把数组中数据在内存中的存储方式,用画图的方式表示出来。

     

     

    从图中,你有没有发现,在Java中,对象数组的存储方式,已经跟C/C++中对象数组的存储方式,不大一样了。在Java中,对象数组中存储的是对象在内存中的地址,而非对象本身。对象本身在内存中并不是连续存储的,而是散落在各个地方的。

    了解了一维数组的存储方式,我们再来看下,Java中的二维数组或者多维数组。前面也提到了,因为多维数组跟二维数组类似,我们还是只拿二维数组来讲解。

    Java中的二维数组,跟数据结构中二维数组,有很大区别。在Java中,二维数组中的第二维,可以是不同长度的。这句话有点不好理解。我举个例子说明一下。​​​​​​​

    int arr[][] = new int[3][];arr[0] = new int[1];arr[1] = new int[2];arr[2] = new int[3];

    在上面的代码中,arr是一个二维数组,第一维长度是3,第二维的长度各不相同:arr[0]长度是1,arr[1]长度是2,arr[2]长度是3。如果我们把这个数组在内存中的存储方式,用图画出来的话,就是下面这个样子。

    备注:java中,数组也是一个对象

    刚刚这个二维数组存储的是基本数据类型,我们再来看下,如果二维数组中存储的是对象,那又会是怎么的数据存储方式呢?我们还是拿个例子来说明。​​​​​​​

    Person arr[][] = new Person[3][];arr[0] = new Person[1];arr[1] = new Person[2];arr[2] = new Person[3];
    arr[0][0] = new Person("0");arr[1][1] = new Person("1");

    在上面的代码中,Person arr[][]是一个二维对象数组。对于它在内存中存储方式,你可以在纸上先画下,或者在自己脑海中想下,然后,再来对比一下我画的下面这张图。

    我总结一下。在Java这种编程语言中,数组这种数据类型,除了存储基本数据类型的一维数组之外,对象数组、二维数组,都跟数据结构中数组的定义,有很大区别了。

    3. JavaScript中数组的实现方式

    如果我们说,Java中的数组,只是根据语言自己的特点,在数据结构数组基础之上,做的改造的话,那JavaScript这种动态脚本语言中的数组,完全就被改的“面目全非”了。

    在开头的时候,我们已经提到过,JavaScript中的数组,可以存储不同类型的数据,数组中的数据也不一定是连续存储的(按照下标随机访问的效率不高),并且还能支持变长数组。这完全就是跟数据结构中数组的定义反着的。如果你是一名Web前端工程师,你应该会对此很困惑吧?

    实际上,JavaScript中数组的底层实现原理,已经不是依赖数据结构中的数组了。也就是说,JavaScript中的数组只不过是名字叫数组而已,跟数据结构中数组没啥太大关系。

    接下来,我们就来看下,JavaScript中的数组,底层是如何实现的呢?实际上,JavaScript中的数组,会根据你存储数据的不同,选择不从的实现方式。

    如果数组中存储的是相同类型的数据,那JavaScript就真的用数据结构中数组来实现。也就是说,会分配一块连续的内存空间来存储数据。

    如果数组中存储的是非相同类型的数据,那JavaScript就用类似散列表的结构来存储数据。也就是说,数据并不是连续存储在内存中的。这也是JavaScript数组支持存储不同类型数据的原因。

    如果你往一个存储了相同类型数据的数组中,插入一个不同类型的数据,那JavaScript会将底层的存储结构,从数组变成散列表。

    如果你熟悉JavaScript,你应该知道,JavaScript为了照顾一些底层应用的开发者,还提供了另外一种数据类型,叫做ArrayBuffer。而ArrayBuffer才符合标准的数据结构中数组的定义。它分配一片连续的内存空间,仅仅用来存储相同类型的数据。

    最后,总结

    数据结构和算法先于编程语言出现。编程语言中是一些数据类型,并不能跟数据结构和算法书籍中讲到的经典数据结构,完全一一对应。比如我们今天讲到的数组,很多编程语言中,都会有数组这种数据类型,而它们往往会根据自己语言的特点,在实现上做了调整。

    欢迎留言说说,在你熟悉的语言中,数组这种数据类型符不符合标准的数据结构中数组的定义?或者,说一说,还有哪些数据类型,虽然名字跟数据结构中讲到的一样,但在实现上却有很大不同呢?

    展开全文
  • R语言的数据结构

    2018-10-21 21:15:16
    R语言的数据结构 文本中对R语言的数据结构进行总结,以说明和举例的方式展现出来! 主要包含:向量,数组,列表,数据框,因子,矩阵,和一些常用函数。 注:以下代码均可直接运行! 1、向量 向量,用于存储数值...

    R语言中的数据结构

    文本中对R语言中的数据结构进行总结,以说明和举例的方式展现出来!
    主要包含:向量,数组,列表,数据框,因子,矩阵,和一些常用函数。
    注:以下代码均可直接运行!

    1、向量

    向量,用于存储数值型,字符型,逻辑型数据的一维数组
    同一向量中无法混杂不同模式的数据
    举例:

    创造一个包含1到5的数字的向量

    a<-c(1:5)
    a
    

    添加数据

    b<-append(a,7)
    b
    

    添加向量(在第二个位置插入)

    c<-append(a,c(8:10),after = 2)
    c
    a
    

    求和函数

    sum(a)
    sum(b)
    sum(c)
    

    求最大函数

    max(a)
    max(b)
    max(c)
    

    求最小函数

    min(a)
    min(b)
    min(c)
    

    求平均函数

    mean(a)
    mean(b)
    mean(c)
    

    方差计算

    f <- sum((a-mean(a))^2/4)
    

    标准差

    bb<- sqrt(f)
    bb
    f
    

    求方差函数

    var(a)
    var(b)
    var(c)
    

    求标准差函数

    sd(a)
    sd(b)
    sd(c)
    
    从小到大排序
    为false时从小到大
    sort(a,decreasing = TRUE)#为true是从大到小
    
    反向
    rev(a)
    rev(sort(a))
    

    向量内元素相乘

    prod(a)
    

    阶乘

    prod(1:5)
    

    2、矩阵

    矩阵,用于存储数值型,字符型,逻辑型数据的二维数组
    同一向量中无法混杂不同模式的数据
    举例:

    创建一个3行4列的矩阵

    mat<-matrix(c(1:12),nrow = 3,ncol = 4)
    mat
    

    维数获取

    dim(mat)
    

    矩阵中的每个元素乘以2

    mat_s<-mat*2
    mat_s
    

    满足矩阵相乘的条件

    左边矩阵的列数=右边矩阵的行数
    mat2<-matrix(c(1:12),nrow = 4,ncol = 3)
    mat2
    

    矩阵相乘

    mat %*% mat2
    

    添加列名

    colnames(mat) <- c('序号','语文','英语','数学')
    mat
    

    取出1行2列的值

    mat[1,2]
    

    取出第二行

    mat[2,]
    

    取出第二列

    mat[,2]
    

    取出1,2行1,2列的值

    mat[c(1:2),c(1,2)]
    

    取出2,3行的值

    mat[c(2,3),]
    

    逻辑判断

    判断第二列是否大于5,返回true或者false
    mat[,2] >=5
    
    返回第二列大于等于5的行
    mat[mat[,2]>=5,]
    
    which
    返回第四列大于等于12的行序列
    which(mat[,4]>=12)
    
    返回第四列大于等于12的行
    mat[which(mat[,4]>=12),]
    
    返回第四列大于等于11的行序列
    which(mat[,4]>=11)
    
    返回第四列大于等于11的行
    mat[which(mat[,4]>=11),]
    

    apply

    查看文档
    ?apply
    

    对第二列的数据求均值

    mean(mat[,2])
    

    对行操作

    apply(mat,1,mean)
    

    对列操作

    apply(mat,2,mean)
    

    3、数组

    数组,数组与矩阵类似,但是维度可以大于二
    举例:

    创建一个三维数组

    arr <- array(c(1:24),dim = c(2,3,4))
    arr
    

    获取数组维数

    dim(arr)
    

    获取每一维的第二列第一行的元素

    arr[1,2,]
    

    获取每一维的第一行元素

    arr[1,,]
    

    运用求和函数

    sum(arr[1,2,])
    

    4、数据框

    数据框可以理解为一个高纬度的数组,不同的列可以包含不同的模式
    举例:

    name<- c('zs','lss','ww')
    sex<-c('n','v','v')
    age<-c(22,21,23)
    

    创建一个数据框

    dat<-data.frame(name,sex,age)
    dat
    
    查看数据类
    class(dat)#数据类
    mode(dat)#数据大类(包含字符型,数值型,逻辑性)
    typeof(dat)#数据细类(包含浮点型,int型。。。)
    

    获取第1行第三列的值

    dat[1,3]
    

    根据列名获取第三个值

    dat$age[3]
    

    添加列

    dat$score<-c(98,99,80)
    dat
    

    获取成绩为99的那一行

    dat[which(dat$score==99),]
    

    创建一个矩阵

    dat2<-matrix(c(1:12),nrow = 3)
    dat2
    

    将矩阵转化为数据框,数据框必须有列名

    dat3<-as.data.frame(dat2)
    dat3
    

    根据列名获取某一列数据

    dat3$V1
    

    连接

    dat
    dat3
    
    dat0<-data.frame(name=name,weight=c(60:62))
    dat0
    

    数据框连接

    dat0$age<-c(20:22)
    dat0
    dat01<-merge(dat,dat0,by.x = 'age',by.y = 'age')
    dat01[which(dat01$name.x==dat01$name.y),]
    

    合并

    dat
    dat0
    

    #此处有错误,找找看

    按行合并,列数必须相同

    dat_r<-rbind(dat,dat0)
    dat_r
    

    按列合并,行数必须相同

    dat_c<-cbind(dat,dat0)
    dat_c
    

    重命名列名

    names(dat0)<-c('name','score','agr')
    dat0
    dat0$sex<-c(23,23,24)
    dat0
    

    返回一个列表

    lapply(dat$age,sum)
    

    返回一个向量

    sapply(dat0$score,sum)
    

    5、因子

    因子,名义型变量和有序型变量在R中称为因子
    举例:

    创建一个因子

    a<-factor(c('A','B','C','C','A'))
    a
    

    levels因子可能的水平

    #label因子标签
    #exclude从向量中剔除的水平值
    b<-factor(c('A','B','C','D','C','A'),levels = c('A','B','C','D'),labels = c('A罩杯','B罩杯','C罩杯','D罩杯'))
    b
    
    colour<-c('G','G','R','R','Y','G','G','Y','G','R','G')
    col<- factor(colour)
    col
    col1<-factor(colour,levels = c('G','R','Y'),labels = c('Green','Red','Yellow'))
    col1
    col2<-factor(colour,levels = c('G','R','Y'),labels = c('1','2','3'))
    col2
    
    class(col2)
    typeof(col2)
    mode(col2)
    

    转换成一个向量

    as.vector(col2)
    
    #ordered创建一个有序的因子
    score<-c('A','B','A','C','B')
    score1<-ordered(score)
    score1
    score1<-ordered(score,levels=c('C','B','A'))
    score1
    
    #cut(创建有序型变量)
    exam<-c(98, 97, 52, 88, 85, 75, 97, 92, 77, 74, 70, 63, 97, 71, 98, 65, 79, 74, 58, 59, 60, 63, 87, 82, 95, 75, 79, 96, 50, 88)
    exam1<-cut(exam,breaks = 3)#分成三组
    exam1
    #区间步长
    (max(exam)-min(exam))/3
    
    #常用函数tapply()
    gender<-c('f','m','m','m','f')
    age<-c(12,35,32,34,25)
    #tapply(vector, index, function)
    tapply(age, gender, mean)
    

    6、列表

    列表,列表为一些对象的有序集合,包含向量,矩阵,数据框,或者其他列表。
    举例:

    列表可以包含数字,字符串,向量。。。

    a<-2
    b<-'abc'
    c<-c(1:4)
    l<-list(a,b,c)
    l
    l[[2]]
    l[[3]]
    

    列表索引

    l<-list(a=a,b=b,c=c)
    l
    l$c
    

    绑定列表

    attach(l)
    a
    c
    

    转化为向量

    l<-unlist(l)
    l
    l[5]
    

    计算操作

    x<-list(a=1,b=c(1:4),c=c(3:6))
    x
    

    返回一个列表

    lapply(x,sum)
    lapply(x,mean)
    
    lapply(x,sum)[[2]]
    

    返回一个向量

    sapply(x,sum)
    sapply(x,mean)
    sapply(x,mean)[2]
    sapply(x,mean)
    
    展开全文
  • Python作为一种脚本语言,其要求强制缩进,使其易读、美观,它的数据...首先介绍的数据结构是序列结构,所谓序列,也就是元素顺序是很重要的,不同元素顺序的序列是不同的序列。Python中含有六种内建的序列结构,分别
  • PAGE / NUMPAGES R语言的基本数据结构 向量的赋值 x(10.4,5.6,3.1,6.4,21.7) assign(x,c(10.4,5.6,3.1,6.4,21.7; 多重构造y(x0x) 向量的基本运算 向量运算的遵循规则 向量的每一个元素都进行相应的运算 进行向量运算...
  • R语言数据结构

    2020-12-08 18:02:55
    R中常见的数据结构 向量:一系列元素的组合 数组:数组是k维的数据表 矩阵:矩阵是数组的一个特例,维数k = 2 数据框:是由一个或几个向量和(或)因子构成,它们必须是等长的,但可以是不同的数据类型 列表:列表...

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

    1. 数据结构概述

    概念

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

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

    R中常见的数据结构

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

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

    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
    
    1. 通过表达式进行访问
    > 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
    
    1. 通过索引名进行访问
    > 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。
    
    展开全文
  • Go语言 常见数据结构性能测试

    千次阅读 2014-04-20 21:07:13
    在开发过程中,我们总是在设计不同的数据结构不同的算法对数据进行组织和存取,有些场合我们可以用硬编码或者代码生成器来生成一组函数按条件返回数据,另外一些场合我们可以把数据存储在slice当中,需要查找时就...

    在开发过程中,我们总是在设计不同的数据结构和不同的算法对数据进行组织和存取,有些场合我们可以用硬编码或者代码生成器来生成一组函数按条件返回数据,另外一些场合我们可以把数据存储在slice当中,需要查找时就遍历查找,又或者有的场合我们可以用map存储数据,用key来索引数据。这几种数据存取方式在不同数据量的情况下,性能消耗是怎么样的呢?下面做个对比实验。

    我们知道go的map数据量不管大小都能保证固定的读取时间,而slice和硬编码肯定无法应对大数据量,所以这里不做大数据量的实验,只做小数据量的实验。

    实验代码(github):

    package labs06
    
    import "testing"
    
    type BigStruct struct {
        C01 int
        C02 int
        C03 int
        C04 int
        C05 int
        C06 int
        C07 int
        C08 int
        C09 int
        C10 int
        C11 int
        C12 int
        C13 int
        C14 int
        C15 int
        C16 int
        C17 int
        C18 int
        C19 int
        C20 int
        C21 int
        C22 int
        C23 int
        C24 int
        C25 int
        C26 int
        C27 int
        C28 int
        C29 int
        C30 int
    }
    
    func Loop1(a []BigStruct) int {
        for i := 0; i < len(a); i++ {
            if a[i].C30 == 3 {
                return i
            }
        }
    
        return -1
    }
    
    func Loop2(a []BigStruct) int {
        for i := len(a) - 1; i >= 0; i-- {
            if a[i].C30 == 1 {
                return i
            }
        }
    
        return -1
    }
    
    func Loop3(a map[int]BigStruct) int {
        return a[2].C30
    }
    
    func Loop4(a []*BigStruct) int {
        for i, x := range a {
            if x.C30 == 3 {
                return i
            }
        }
    
        return -1
    }
    
    func Loop5(a []BigStruct) int {
        switch {
        case a[0].C01 == 3:
            return 0
        case a[1].C01 == 3:
            return 1
        case a[2].C01 == 3:
            return 2
        }
    
        return -1
    }
    
    func Benchmark_Loop1(b *testing.B) {
        var a = make([]BigStruct, 3)
    
        a[0].C30 = 1
        a[1].C30 = 2
        a[2].C30 = 3
    
        for i := 0; i < b.N; i++ {
            Loop1(a)
        }
    }
    
    func Benchmark_Loop2(b *testing.B) {
        var a = make([]BigStruct, 3)
    
        a[0].C30 = 1
        a[1].C30 = 2
        a[2].C30 = 3
    
        for i := 0; i < b.N; i++ {
            Loop2(a)
        }
    }
    
    func Benchmark_Loop3(b *testing.B) {
        var a = make(map[int]BigStruct, 3)
    
        a[0] = BigStruct{C30: 1}
        a[1] = BigStruct{C30: 2}
        a[2] = BigStruct{C30: 3}
    
        for i := 0; i < b.N; i++ {
            Loop3(a)
        }
    }
    
    func Benchmark_Loop4(b *testing.B) {
        var a = make([]*BigStruct, 3)
    
        a[0] = &BigStruct{C30: 1}
        a[1] = &BigStruct{C30: 2}
        a[2] = &BigStruct{C30: 3}
    
        for i := 0; i < b.N; i++ {
            Loop4(a)
        }
    }
    
    func Benchmark_Loop5(b *testing.B) {
        var a = make([]BigStruct, 3)
    
        a[0].C30 = 1
        a[1].C30 = 2
        a[2].C30 = 3
    
        for i := 0; i < b.N; i++ {
            Loop5(a)
        }
    }
    

    试验结果:

    dada-imac:labs dada$ go test -test.bench="." labs06
    testing: warning: no tests to run
    PASS
    Benchmark_Loop1    500000000             5.73 ns/op
    Benchmark_Loop2    500000000             5.72 ns/op
    Benchmark_Loop3    50000000              68.0 ns/op
    Benchmark_Loop4    500000000             4.92 ns/op
    Benchmark_Loop5    500000000             4.40 ns/op
    ok      labs06  15.970s    
    

    结论:硬编码 < 指针slice的range循环 < for循环,但是量级是一样的,看情况用。但是map差了一个量级,小数据量尽量少用。

    展开全文
  • 算法语言数据结构;第7章 结构体与联合体;本章主要内容;Table of Contents;7.1 结构体的定义;为何要引入结构体的概念有时需要将不同类型的数据结合成一个有机的整体如有一个学生他有姓名性别年龄地址 ,这些都属于一...
  • R语言数据结构

    2019-01-29 18:27:00
    众所周知,R语言的优势在于进行数据挖掘,大数据处理等方面,因此单个的数据并不能满足我们的需要,于是向量,矩阵,数组,数据框等变量类型应运而生。 向量:与我们在数学里面所学到的向量不同,R语言中的向量类似...
  • SQL SQL结构化查询语言是一种用于在关系数据库中查询或获取数据的语言 数据 数据是以文字数字或图片形式事实集合 数据库 数据的存储器 提供增加修改以及查询数据的功能 不同的数据库以不同形式存储数据 表格形式...
  • R语言数据结构与类型

    2019-10-30 08:39:58
    微信公众号:[R语言小白速通]主要分享一些R语言和统计学知识,提升自己,帮助他人。[如果你觉得本文章对你有帮助,欢迎赞赏] 内容目录 标量向量矩阵数组数据框...R的数据类型包括数值型、字符型、逻辑型(TRUE/FALS...
  • 数据框是最常见的数据结构,一般来讲,从csv或txt文件读入时就会自动存储为数据框对象。 与矩阵不同的是,矩阵只可以存储一种数据类型,而数据框可以存储多种类型,但是每一列必须为相同的数据类型 1.创建数据框 ...
  • 学习 适应不同的语言-练习课程 1) Get Comfortable with Java 2) Get Comfortable with Spring 3) Get Comfortable with RESTFul APIs #注意:每个主题都有详细定义和解释。
  • 字符串 简介  一个字符串是一个不可改变的字节序列,字符...由于Go语言的源代码要求是UTF8编码,导致Go源代码中出现的字符串面值常量一般也是UTF8编码的。  Go语言字符串底层数据也是对应的字节数组,但是字符...
  • 数据结构(C#语言版)

    2015-07-15 11:21:44
    本书分为 8 章,第 1 章介绍...本书所有的数据结构和算法都是用 C#语言进行描述,并在相应章节的末尾介绍了在.NET 框架中常用的数据结构和算法。用 C#在.NET 平台开发的技术人员可以从本书中获得许多有益的知识和技术。
  • 第2期——R的数据结构 R的数据结构 (1) 向量vector 向量:用于存储数值型、字符型或逻辑型的一堆数组 【(建议)单个向量中必须是相同的数据类型,存储不同的数据类型其实没什么意义】 数据类型: 1、数值...
  • R语言数据结构-数据框

    千次阅读 2014-10-09 21:59:21
     数据框是一种矩阵形式的数据,但数据框中各列可以是不同类型的数据。数据框每列是一个变量,每行是一个观测。数据框可以看成是矩阵的推广,也可看作一种特殊的列表对象,很多高级统计函数都会用到数据框。 数据...
  • 数据结构研究怎么使用存储区 算法研究解决一些常见问题通用方法 可以从两个完全不同的角度描述数字之间关系 逻辑关系(逻辑结构)描述是数字之间与计算机无关关系 物理关系(物理结构)描述是记录...
  • 本文采用C#语言实现栈结构算法并举例应用。 一、C#栈对象使用 对C#而言,要使用栈是极其简单事情,因为C#已经有栈对象,所以根本不需要自用再用顺序表构造栈,只需要你会说明、会应用即可。 在C#中栈对象...
  • 在学习数据框之前,我们先来认识一些用于存储数据的数据结构:向量、因子、矩阵、数组和列表。这些数据结构在存储类型、创建方式和操作方式等方面均有所不同,熟悉它们的基本概念和操作技巧,将会让我们能够灵活高效...
  • 学习参考书是:吴艳等编著数据结构(用C++语言描述)》,但是书中代码个别部分有一些错误,我修改了,所以下面代码与原书中有稍微不同。(这些代码是我一边理解原理一边参考书敲出来,在vs上敲完之后进行...
  • 该存储库包含按主题排列文件夹,其中包含有关各种数据结构和算法程序,这些程序进一步分为不同语言代码文件夹。 建立该存储库目的是记录我进度,以便其他像我刚起步人都能从我计划中受益。 代码会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,646
精华内容 3,058
关键字:

不同语言的数据结构

数据结构 订阅