精华内容
下载资源
问答
  • 视觉感知的frosig发育测试的临床和心理测量优点 视觉感知的frostig发育测试的临床和心理测量指标 GEORGIA PITCHER-BAKER St. Elimbeth医院医疗中心 临床医生和测量专家经常争论心理测量与临床诊断方法的优点程序。 ...
  • 医学图像分割综述—学习

    千次阅读 2013-09-05 11:58:11
    优点:在分割的同时,分割出的每一类对应的解剖部位也就唯一的确定了。 缺点:考虑到人体解剖结构的千差万别,完全用简单的映射关系来对所有的图像进行分割在实现上是很困难的。 6.2 数学形态 形态图像...

    图像处理流程大致如下图所示:


    图像分割的定义:

    将一副图像g(x,y),其中0≤x≤Max_x,0≤y≤Max_y,进行分割就是将图像划分为满足如下条件的子区域:


    1.基于区域的分割方法:

    图像分割通常用到不同对象间特征的不连续性和同一对象内部特征的相似性。

    基于区域的算法则侧重于利用区域内特征的相似性。

    1.1阈值法:

    阈值分割是最常见的并行直接检测区域的分割方法。

    单阈值分割:将图像分为目标和背景。

    多阈值分割:将图像分为多个目标区域和背景。为区分目标,还要对各个区域进行标记。

    阈值分割方法基于对灰度图像的一种假设:目标或背景内的相邻像素间的灰度值是相似的。

    但不同目标或背景的像素在灰度上有差异,反映在图像直方图上就是不同目标和背景对应不同的峰。

    选取的阈值应该位于两个峰之间的谷,从而将各个峰分开。

    1.2 区域生长和分裂合并

    区域生长和分裂合并是两种典型的串行区域分割方法。

    区域生长的基本思想是将具有相似性质的像素集合起来构成区域。

    该方法首先要选取一个种子点,然后依次将种子像素周围的相似像素合并到种子像素所在的区域内。

    1.3 分类器和聚类

    分类是模式识别领域中一种基本的统计分析方法。

    分类的目的是利用已知的训练样本集在图像的特征空间找到点、曲线、曲面或超曲面,从而实现对图像的划分。

    分类器分为两种:非参数分类器和参数分类器

    聚类算法与分类器极为相似,只是它不需要训练样本。

    1.4 基于随机场的方法

    在MRF假设下,大多数像素和其临近的像素属于同一类。

    1.5 其它基于统计学的方法

    2. 基于边缘的图像分割方法

    2.1 并行微分算子

    2.2 基于曲面拟合的方法

    2.3 基于边界曲线拟合的方法

    2.4 基于反应—扩散方程的方法

    2.5 串行边界查找

    2.6 基于形变模型的方法

    2.7 小波多尺度边缘检测

    2.8 基于数学形态学的边缘检测

    3. 结合区域与边界技术的方法


    4. 基于模糊集理论的方法

    图像分割问题是典型的结构不良问题,而模糊集理论具有描述不良问题的能力。
    基于模糊理论的图像分割方法包括:
    • 模糊阈值分割方法
    • 模糊聚类分割方法
    • 模糊连接度分割方法

    5. 基于神经网络的方法

    神经网络模拟生物特别是人类大脑的学习过程,它由大量的节点构成。

    每个节点都能执行一个基本的运算。

    神经网络的出发点是将图像分割问题转化为诸如能力最小化、分类等问题,

    从而借助神经网络技术来解决问题。

    其基本思想是用训练样本集对ANN进行训练以确定节点间的连接和权值,

    再用训练好的ANN去分割新的图像数据。

    6. 图像分割中的其它方法和问题

    6.1 图谱引导方法(Atlas-Guided)

    图谱引导方法是利用已有标准模版对医学图像进行分割。

    主要用于对脑部MR图像的分割。

    优点:在分割的同时,分割出的每一类对应的解剖部位也就唯一的确定了。

    缺点:考虑到人体解剖结构的千差万别,完全用简单的映射关系来对所有的图像进行分割在实现上是很困难的。

    6.2 数学形态学

    形态学图像处理以在图像中移动一个结构元素并进行卷积的方式进行,结构元素可以具有任意大小。

    形态学理论在图像分割中比较有代表性的是水线算法

    6.3 尺度空间理论的应用

    尺度空间理论的概念被引入到医学图像的分割问题中,强调医学图像特征呈现出多种级别的现象

    6.4 分割评估

    图像分割中的另一重要问题是对分割算法的定性和定量评估。

    展开全文
  • 今天就给大家简单介绍下Python和人工智能的关系及应用,以及想要人工智能的你,究竟需要些什么Python的知识,先来上两张图人工智能和Python的图。 从上图可以看出,人工智能包含常用机器学习和深度学习两...

    python与人工智能

    什么是人工智能

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    视频
    阿里菜鸟无人仓
    -科技-高清完整正版视频在线观看-优酷
    https://v.youku.com/v_show/id_XMzgwMDEyOTE5Mg==.html?spm=a2h0k.11417342.soresults.dtitle

    在不远的将来
    机器人将会为人类提供各方位的服务
    替代掉劳动力型,计算型,创建型,检察型等种类型的工作岗位
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    人工智能的应用

    人工智能的应用

    无人超市

    无人驾驶

    人机配合仓库管理

    无人工厂

    下棋机器人

    智能语音识别

    写诗机器人,小冰

    歌手机器人,洛天依

    养老机器人

    等等。。。

    人工智能与python的关联

    人工智能掀起了世界的新一波科技浪潮,如今,你要是不懂点AI、机器学习和python都不好意思说你是现代人。

    那么Python究竟和人工智能什么关系,为什么人工智能把Python也给带火了?

    今天就给大家简单介绍下Python和人工智能的关系及应用,以及想要学人工智能的你,究竟需要学些什么Python的知识,先来上两张图人工智能和Python的图。

    在这里插入图片描述

    在这里插入图片描述

    从上图可以看出,人工智能包含常用机器学习和深度学习两个很重要的模块,而下图中Python拥有matplotlib、Numpy、sklearn、keras等大量的库,像pandas、sklearn、matplotlib这些库都是做数据处理、数据分析、数据建模和绘图的库,基本上机器学习中对数据的爬取(scrapy)、对数据的处理和分析(pandas)、对数据的绘图(matplotlib)和对数据的建模(sklearn)在Python中全都能找到对应的库来进行处理。

    所以,要想学习AI而不懂Python,那就相当于想学英语而不认识单词,所以,Python学起来吧。

    那么要想学人工智能,想学Python,那些东西要学习呢,下面给大家简单介绍下:

    首先,你要学Python如何爬取数据,你要做数据分析、数据建模,起码你要有数据,这些数据来源有多种方法,但是很多都来自网络,这就是爬虫。

    爬虫:requests、scrapy、selenium、beautifulSoup,这些库都是写网络爬虫需要使用到的,好好掌握这些东西,数据就有了。

    然后,有了数据就可以进行数据处理和分析了,这个时候,你需要用到数据处理的一些库

    数据处理:Numpy、scipy、pandas、matplotlib,这些库分别可以进行矩阵计算、科学计算、数据处理、绘图等操作,有了这些库,你就可以一步步开始把数据处理成你需要的格式。

    接着,数据符合你的格式以后,你就需要利用这些数据进行建模了,这个时候你用到的库也有很多。

    建模:nltk、keras、sklearn,这些库主要是用于自然语言处理、深度学习和机器学习的,把这些用好了,你的模型就构建出来了。

    最后,如果你的项目是基于Python开发的线上系统,你还可以学一学Python的Web开发,这样,你做的模型还能直接用在线上系统。

    Web开发:django、flask、tornado,这些库搞明白了,你Web开发也就搞定了。

    以上只是你入门要学习人工智能所要掌握的一些基本的库,要想真正使用起来,你可能需要花费很多时间去研究和学习这里面的每一个细节。

    不过,有句话叫**“人生苦短,我用Python”**,之所以这么说是因为Python在实现各个功能的时候要远比其他语言简练的多,很多功能在Python中只需要一行代码搞定,但是在Java中你可能需要写好多好多代码才能实现

    编程代码量pk

    python与java代码量,1:5
    例子:下面是对比程序了(计算出1~100中7的倍数已经数字中带7 的数):

    c 代码
    在这里插入图片描述

    java代码
    在这里插入图片描述

    python代码

    print([x for x in range(1,101) if x%7 == 0])
    

    运行结果

    [7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]
    

    市场热度

    python编程语言 vs java编程语言
    之所以比较java语言,因为它是编程排行傍常年位居榜首的语言
    看图识别
    2017年7月左右市场热度反超java语言并且差距渐渐拉大
    在这里插入图片描述

    python语言应用领域

    谷歌:Google App Engine、code.Google.com、Google earth、谷歌爬虫、Google广告等项目都在大量使用Python开发

    CIA:美国中情局网站就是用Python开发的

    NASA:美国航天局(NASA)大量使用Python进行数据分析和运算

    YouTube:世界上最大的视频网站YouTube就是Python开发的

    Dropbox:美国最大的在线云存储网站,全部用Python实现,每天网站处理10亿个文件的上传和下载

    Instagram:美国最大的图片分享社交网站,每天超过3千万张照片被分享,全部用Python开发

    Facebook:大量的基础库均通过Python实现的

    Redhat:世界上最流行的Linux发新版本中的yum包管理工具就是用Python开发的

    豆瓣:公司几乎所有的业务均是通过Python开发的

    知乎:国内最大的问答社区,通过Python开发(Quora)

    春雨医生:国内知名的在线医疗网站是用Python开发的

    除上面之外,还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务。

    python语言的特点

    Python 的特点
    Python 是一种面向对象、解释型、弱类型的脚本语言,它也是一种功能强大而完善的通用型语言。

    相比其他编程语言(比如 Java),Python 代码非常简单,上手非常容易。比如我们要完成某个功能,如果用 Java 需要 100 行代码,但用 Python 可能只需要 20 行代码,这是 Python 具有巨大吸引力的一大特点。

    Python 的两大特色是清晰的语法和可扩展性:
    Python 的语法非常清晰,它甚至不是一种格式自由的语言。例如,它要求 if 语句的下一行必须向右缩进,否则不能通过编译。
    Python 的可扩展性体现为它的模块,Python 具有脚本语言中最丰富和强大的类库(这些类库被形象地称为“batteries included ,内置电池”),这些类库覆盖了文件 I/O、GUI、网络编程、数据库访问、文本操作等绝大部分应用场景。

    此外,Python 的社区也很发达,即使一些小众的应用场景,Python 往往也有对应的开源模块来提供解决方案。

    Python 作为一门解释型的语言,它天生具有跨平台的特征,只要为平台提供了相应的 Python 解释器,Python 就可以在该平台上运行。
    解释型语言几乎天然是跨平台的。

    国家重视

    1 python编程语言已明确会加入中小学课程

    在这里插入图片描述

    2 纳入高考

    高考新宠
    在高考更改之前,提起编程,人们可能更多的会想起c语言之类的。
    然而,高考更始之后,Python这门编程说话一夜之间传进了千家万户。
    现实上,在IEEE(美国电气电子工程师学会出书的旗舰杂志)公布的2017年编程说话排行榜中,Python高居首位,成为最受接待的适用编程说话。
    那么问题来了,为什么连高考都必定要考Python呢?

    五大理由告诉你
    1、易学
    良多人可能都市认为高考考Python是在开玩笑!
    Python是不是很难?
    其实恰恰相反,得益于简单的语法,Python极其随意上手。
    轨范圈中就不息流穿着一句话“人生苦短,我用 Python”
    所以,不要感受Python高不成攀,其实Python相称“驯良可掬”。

    2、高效
    Python虽然不复杂,可是它的标准库很复杂,它可以辅佐各类工作。
    精练的几行代码就可以处理一个问题,非常牛逼。

    3、应用广
    Python经由十多年的生长,能支撑的规模很是泛博,按照《Python进修手册》作者的说法,Python可以从支撑航空航天器体系的开发到小游戏开发的几乎所有的规模。
    这是个什么概念呢?简单点说就是:python是个万金砖,哪里必要往哪搬!任何体系的开发都可以!

    4、跨平台
    Python是脚本语言,没必要编译,它的实行只跟诠释器有关。同样的代码不必要改动也经验在其它系统上运行。
    对,它不仅什么体系都能开发,并且什么系统都能把持!

    5、扩展性
    Python常被昵称为胶水语言,可以把用其他语言建造的各类模块(尤其是C/C++)很轻松地联络在一起。
    比如3D游戏中的图形衬着模块,机能要求特别高,就可以用C/C++重写,此后封装为Python可以挪用的扩展类库。这也是人工智能的必备知识。

    3 纳入国家计算机等级考试

    在这里插入图片描述

    学习python语言的注意

    • 了解并重视python
    • 明确python的本质,它是高级编程语言,最易学习的编程语言
    • 勤学习,勤练习
    • 常用英语的记忆
    • 相信自己
    展开全文
  • 作者 | Alexandr Honchar 译者 | 大鱼 编辑 | Rachel、琥珀 出品 | AI科技大本营(id:rgznai100) 【导语】本文对传统的人工数学建模和机器学习的优缺点进行了介绍和比较,并介绍了一种将二者优点相结合的方法——...

    640?wx_fmt=jpeg


    作者 | Alexandr Honchar

    译者 | 大鱼

    编辑 | Rachel、琥珀

    出品 | AI科技大本营(id:rgznai100)


    【导语】本文对传统的人工数学建模和机器学习的优缺点进行了介绍和比较,并介绍了一种将二者优点相结合的方法——解耦表示学习。之后,作者利用 DeepMind 发布的基于解耦表示学习的 beta-VAE 模型,对医疗和金融领域的两个数据集进行了探索,展示了模型效果,并提供了实验代码。


    实验中 GitHub 项目地址:

    https://github.com/Rachnog/disentanglment


    这篇文章会对传统数学建模与机器学习建模之间的联系进行讨论。传统数学建模是我们在学校里都学过的建模方法,该方法中,数学家们基于专家经验和对现实世界的理解进行建模。而机器学习建模则是另一种完全不同的建模方式,机器学习算法以一种更加隐蔽的方式来描述一些客观事实,尽管人类并不能够完全理解模型的描述过程,但在大多数情况下,机器学习模型要比人类专家构建的数学模型更加精确。当然,在更多应用领域(如医疗、金融、军事等),机器学习算法,尤其是深度学习模型并不能满足我们需要清晰且易于理解的决策。


    本文会着重讨论传统数学建模和机器学习建模的优缺点,并介绍一个将两者相结合的方法 —— 解耦表示学习 (Disentangled Representation Learning)。


    如果想在自己的数据集上尝试使用解耦表示学习的方法,可以参考 Github 上关于解耦学习的分享,以及 Google Research 提供的关于解耦学习的项目代码


    深度学习存在的问题


    由于深度学习技术的发展,我们在许多领域都对神经网络的应用进行了尝试。在一些重要的领域,使用神经网络确实是合理的,并且获得了较好的应用效果,包括计算机视觉、自然语言处理、语音分析和信号处理等。在上述应用中,深度学习方法都是利用使用线性和非线性转换对复杂的数据进行自动特征抽取,并将特征表示为“向量”(vector),这一过程一般也称为“嵌入”(embedding)。之后,神经网络对这些向量进行运算,并完成相应的分类或回归任务:


    640?wx_fmt=png


    从特征提取和准确度来看,这种 “嵌入”的方法非常有效,但在许多方面也存在不足:


    • 可解释性:嵌入所使用的N维向量无法对模型分析的原理和过程进行很好的解释,只有通过逆向工程才能找到输入数据中对分析影响更大的内容。

    • 数据需求量庞大:如果只有 10~100 个样本,深度学习无法使用。

    • 无监督学习:大多数深度学习模型都需要有标签的训练数据。

    • 零样本学习:这是一个很关键的问题,基于一个数据集所训练出的神经网络,若不经过重新训练,很难直接应用在另一个数据集上。

    • 对象生成:除了 GANs(生成对抗网络)以外,其他模型都很难生成一个真实的对象。

    • 对象操作:难以通过嵌入调整输入对象的具体属性。

    • 理论基础:虽然我们已经掌握了比较通用的逼近理论,但这还不够。


    这些问题很难用机器学习框架来解决,但在最近,我们取得了一些新的进展。


    数学建模的优势


    在 20 年、50 年 甚至 100 年以前,大多数数学家都没有遇到过上述问题。其中原因在于,他们主要关注数学建模(mathematical modeling),并通过数学抽象来描述现实世界中的对象和过程,如使用分布、公式和各种各样的方程式。在这个过程中,数学家定义了我们在标题中提到的常微分方程(ordinary differential equations, ODE)。我们通过对比深度学习存在的问题,对数学建模的特点进行了分析。需要注意的是,在下面的分析中,“嵌入”代表数学模型的参数,如微分方程的自由度集合。


    • 可解释性:每个数学模型都是基于科学家对客观事物的描述而建立的,建模过程包含数据家对客观事物的描述动机和深入理解。例如,对于物理运动的描述, “嵌入” 包括物体质量、运动速率和坐标空间,不涉及到抽象的向量。

    • 数据需求量大:大多数数学建模上的突破并不需要基于巨大的数据集进行。

    • 无监督学习:对数学建模来说也不适用。

    • 零样本学习:一些随机微分方程(如几何布朗运动)可以应用于金融、生物或物理领域,只需要对参数进行重新命名。

    • 对象生成:不受限制,对参进行采样即可。

    • 对象操作:不受限制,对参数进行操作即可。

    • 理论基础:上百年的科学基础。


    我们没有使用微分方程解决所有问题的原因在于,对于大规模的复杂数据来说,微分方程的表现与深度学习模型相比要差得多,这也是深度学习得到飞速发展的原因。但是,我们仍然需要人工的数学建模。


    将机器学习与基于人工的建模方法相结合


    如果在处理复杂数据时,我们能把表现较好的神经网络和人工建模方法结合起来,可解释性、生成和操作对象的能力、无监督特征学习和零样本学习的问题,都可以在一定程度上得到解决。举个例子,视频1中呈现的是对于人像的特征提取方法。


    对于微分方程和其他人工建模方法来说,图像处理很难进行,但通过和深度学习进行结合,上述模型允许我们进行对象的生成和操作、可解释性强,最重要的是,该模型可以在其他数据集上完成相同的工作。该模型唯一的问题是,建模过程不是完全无监督的。另外,对于对象的操作还有一个重要的改进,即当我改变 ”胡须“ 这一特征时,程序自动让整张脸变得更像男人了,也就是意味着,模型中的特征虽然具有可解释性,但特征之间是相关联的,换句话说,这些特征是耦合在一起的。


    β -VAE


    有一个方法可以帮助我们实现解耦表示,也就是让嵌入中的每个元素对应一个单独的影响因素,并能够将该嵌入用于分类、生成和零样本学习。该算法是由 DeepMind 实验室基于变分自编码器开发的,相比于重构损失函数(restoration loss),该算法更加注重潜在分布与先验分布之间的相对熵。

    若想了解更多细节,可阅读beta-VAE的论文(https://openreview.net/forum?id=Sy2fzU9gl);也可参考这个视频2中的介绍,详细解释了 beta-VAE 的内在思想,以及该算法在监督学习和强化学习中的应用。


    beta-VAE 可以从输入数据中提取影响变量的因素,提取的因素包括物理运动的方向、对象的大小、颜色和方位等等。在强化学习应用中,该模型可以区分目标和背景,并能够基于已有的训练模型在实际环境中进行零样本学习。


    实验过程


    我主要研究医疗和金融领域的模型应用,在这些领域的实际问题中,上述模型能够在很大程度上解决模型解释性、人工数据生成和零样本学习问题。因此在下面的实验中,我使用 beta-VAEs 模型对心电图(ETC)数据和和比特币(BTC)的价格数据进行了分析。该实验的代码在 Github上可以找到。

    首先,我使用veta-VAE(一个非常简单的多层神经网络)对PTB诊断数据中的心电图数据进行了建模,该数据包含三类变量:心电图图表,每个人随着时间变化的脉搏数据,以及诊断结果(即是否存在梗塞)。在 VAE 训练过程中,epoch 大小设置为 50,bottleneck size 设置为 10,学习率为 0.0005,capacity 参数设置为 25(参数设置参考了这个GitHub项目)。模型的输入是心跳。经过训练,该模型学习到了数据集中影响变量的实际因素。


    下图展示了我使用其中一个单一特征对心跳数据进行操作的过程,其中黑线代表心跳,使用的特征数据值从 -3 逐渐增大至 3。在这一过程中,其他特征始终保持不变。不难发现,第 5 个特征对心跳形式的影响很大,第 8 个代表了心脏病的情况(蓝色心电图代表有梗塞症状,而红色则相反),第 10 个特征可以轻微地影响脉博。


    640?wx_fmt=png

    图:对心电图的心跳进行解耦


    正如预期的一样,金融数据的实验效果没有这么明显。模型的训练参数设置与上一实验相似。使用的数据为 2017 年收集的比特币价格数据集,该数据集包含一个时间长度为 180 分钟的比特币价格变化数据。预期的实验效果为使用 beta-VAE 学习一些标准的金融时间序列模型,如均值回归的时间序列模型,但实际很难对所获得的表示进行解释。在实验结果中可以发现,第 5 个特征改变了输入的时间序列的趋势,第 2、4、6 个特征增加/减少了时间序列上不同阶段的波动,或者说使其更加趋于稳定或动荡。


    640?wx_fmt=png

    图:对比特币的收盘价格进行解耦


    多个对象的解耦


    假设在图像中包含多个对象,我们想要找出每一个对象的影响因素。下面的动图展示了模型的效果。


    640?wx_fmt=gif

    640?wx_fmt=gif


    总结


    下面针对于机器学习存在的问题列表对 beta-VAE 模型进行总结:


    • 可解释性:特征完全可解释,我们只需要对每个具体嵌入的元素进行验证。

    • 数据需求量大:由于该模型属于深度学习框架,数据需求量依然较大。

    • 无监督学习:可以实现完全的无监督学习。

    • 零样本学习:可以进行,在文中展示的强化学习应用就属于这一类。

    • 对象生成:和普通的 VAE 一样易于对参数进行采样。

    • 对象操作:可以轻松操作任何感兴趣的变量。

    • 理论基础:有待研究。


    上文的模型几乎具备了数学建模的全部优质特性,也具有深度学习在分析复杂数据时的高准确度。那么,如果能使用完全无监督的方式,从复杂数据中学习到如此好的表示结果,是不是意味着传统数学建模的终结?如果一个机器学习模型就可以对复杂模型进行构建,而我们只需要进行特征分析,那还需要基于人工的建模吗?这个问题还有待讨论。


    这里列出了文中视频的网址链接和百度网盘链接,供参考:


    • 视频1:

    • 链接:https://youtu.be/O1by05eX424

    • 百度网盘:链接: https://pan.baidu.com/s/11qsgCVlRF0R4jm7ZLlzF2w 提取码: f76s

    • 视频2:

    • 链接:https://youtu.be/yV698Fi2XzE

    • 百度网盘:链接: https://pan.baidu.com/s/153FBz8YWaw3PWrqJAbPj2A 提取码: ee8v


    原文链接:

    https://towardsdatascience.com/gans-vs-odes-the-end-of-mathematical-modeling-ec158f04acb9


    (本文为 AI科技大本营编译文章,转载请微信联系 1092722531)


    CTA核心技术及应用峰会


    5月25-27日,由中国IT社区CSDN与数字经济人才发展中心联合主办的第一届CTA核心技术及应用峰会将在杭州国际博览中心隆重召开,峰会将围绕人工智能领域,邀请技术领航者,与开发者共同探讨机器学习和知识图谱的前沿研究及应用。


    更多重磅嘉宾请识别海报二维码查看,目前会议早鸟票发售中(原票价1099元),点击阅读原文即刻抢购。添加小助手微信15101014297,备注“CTA”,了解票务以及会务详情。

    640?wx_fmt=jpeg

    推荐阅读

    640?wx_fmt=png

    展开全文
  • java详细学习路线及路线图

    万次阅读 多人点赞 2018-05-20 16:15:02
    数组实现的线性表优点在于可以通过下标来访问或者修改元素,比较高效,主要缺点在于插入和删除的花费开销较大,比如当在第一个位置前插入一个元素,那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加...

    本文将告诉你学习Java的一些步骤,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。

    一、Java基础






    二、Java学习七大阶段



    阶段1、JavaSE基础



    阶段2、WEB前端



    阶段3、数据库



    阶段4、JavaWeb

    Javaweb

    XML

    XML以及相关概念

    dom4j+xpath

    Servlet

    B/S架构概论

    Tomcat服务器安装与配置

    怎么写一个Servlet

    Servlet生命周期

    ServletConfig

    ServletContext

    Servlet线程安全问题

    Http协议详解&GET和POST区别与选用

    HttpServletRequest

    HttpServletResponse

    Cookie

    HttpSession

    转发和重定向

    Filter

    责任链设计模式

    Listener

    观察者设计模式

    JSP&FreeMarker&Velocity

    JSP核心语法

    EL表达式

    JSTL标签

    FreeMarker

    Velocity

    AJAX

    AJAX核心原理

    jQuery-AJAX

    AJAX跨域



    阶段5、JavaWeb项目



    阶段6、流行框架



    阶段7、前沿技术&架构师项目

    上述原文点击打开链接

    上面图片来自原文链接

    上面图片来自原文链接

    数据结构与算法

    数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容,如有错误,欢迎指出。

    为了便于描述,文中涉及到的代码部分都是用Java语言编写的,其实Java本身对常见的几种数据结构,线性表、栈、队列等都提供了较好的实现,就是我们经常用到的Java集合框架,有需要的可以阅读这篇文章。Java - 集合框架完全解析

    一、线性表
      1.数组实现
      2.链表
    二、栈与队列
    三、树与二叉树
      1.树
      2.二叉树基本概念
      3.二叉查找树
      4.平衡二叉树
      5.红黑树
    四、图
    五、总结
    

    一、线性表

    线性表是最常用且最简单的一种数据结构,它是n个数据元素的有限序列。

    实现线性表的方式一般有两种,一种是使用数组存储线性表的元素,即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素,即用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的)。

    数组实现

    数组是一种大小固定的数据结构,对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后,它的大小就无法改变了,但是当数组不能再存储线性表中的新元素时,我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

    • 代码1 创建一个更大的数组来替换当前数组
    int[] oldArray = new int[10];
            
    int[] newArray = new int[20];
            
    for (int i = 0; i < oldArray.length; i++) {
        newArray[i] = oldArray[i];
    }
    
    // 也可以使用System.arraycopy方法来实现数组间的复制     
    // System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
            
    oldArray = newArray;
    
    • 代码2 在数组位置index上添加元素e
    //oldArray 表示当前存储元素的数组
    //size 表示当前元素个数
    public void add(int index, int e) {
    
        if (index > size || index < 0) {
            System.out.println("位置不合法...");
        }
    
        //如果数组已经满了 就扩容
        if (size >= oldArray.length) {
            // 扩容函数可参考代码1
        }
    
        for (int i = size - 1; i >= index; i--) {
            oldArray[i + 1] = oldArray[i];
        }
    
        //将数组elementData从位置index的所有元素往后移一位
        // System.arraycopy(oldArray, index, oldArray, index + 1,size - index);
    
        oldArray[index] = e;
    
        size++;
    }
    

    上面简单写出了数组实现线性表的两个典型函数,具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素,比较高效,主要缺点在于插入和删除的花费开销较大,比如当在第一个位置前插入一个元素,那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率,可以采用链式结构来实现线性表。

    链表

    链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成,这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next,Next指向下一个节点,这样当添加或者删除时,只需要改变相关节点的Next的指向,效率很高。

    单链表的结构

    下面主要用代码来展示链表的一些基本操作,需要注意的是,这里主要是以单链表为例,暂时不考虑双链表和循环链表。

    • 代码3 链表的节点
    class Node<E> {
    
        E item;
        Node<E> next;
        
        //构造函数
        Node(E element) {
           this.item = element;
           this.next = null;
       }
    }
    
    • 代码4 定义好节点后,使用前一般是对头节点和尾节点进行初始化
    //头节点和尾节点都为空 链表为空
    Node<E> head = null;
    Node<E> tail = null;
    
    • 代码5 空链表创建一个新节点
    //创建一个新的节点 并让head指向此节点
    head = new Node("nodedata1");
    
    //让尾节点也指向此节点
    tail = head;
    
    • 代码6 链表追加一个节点
    //创建新节点 同时和最后一个节点连接起来
    tail.next = new Node("node1data2");
    
    //尾节点指向新的节点
    tail = tail.next;
    
    • 代码7 顺序遍历链表
    Node<String> current = head;
    while (current != null) {
        System.out.println(current.item);
        current = current.next;
    }
    
    • 代码8 倒序遍历链表
    static void printListRev(Node<String> head) {
    //倒序遍历链表主要用了递归的思想
        if (head != null) {
            printListRev(head.next);
            System.out.println(head.item);
        }
    }
    
    • 代码 单链表反转
    //单链表反转 主要是逐一改变两个节点间的链接关系来完成
    static Node<String> revList(Node<String> head) {
    
        if (head == null) {
            return null;
        }
    
        Node<String> nodeResult = null;
    
        Node<String> nodePre = null;
        Node<String> current = head;
    
        while (current != null) {
    
            Node<String> nodeNext = current.next;
    
            if (nodeNext == null) {
                nodeResult = current;
            }
    
            current.next = nodePre;
            nodePre = current;
            current = nodeNext;
        }
    
        return nodeResult;
    }
    

    上面的几段代码主要展示了链表的几个基本操作,还有很多像获取指定元素,移除元素等操作大家可以自己完成,写这些代码的时候一定要理清节点之间关系,这样才不容易出错。

    链表的实现还有其它的方式,常见的有循环单链表,双向链表,循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点,整体构成一个链环。 双向链表 主要是节点中包含两个指针部分,一个指向前驱元,一个指向后继元,JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。

    二、栈与队列

    栈和队列也是比较常见的数据结构,它们是比较特殊的线性表,因为对于栈来说,访问、插入和删除元素只能在栈顶进行,对于队列来说,元素只能从队列尾插入,从队列头访问和删除。

    栈是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫作栈顶,对栈的基本操作有push(进栈)和pop(出栈),前者相当于插入,后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表,即后进先出。

    栈的模型

    下面我们看一道经典题目,加深对栈的理解。

    关于栈的一道经典题目

    上图中的答案是C,其中的原理可以好好想一想。

    因为栈也是一个表,所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码,可以看到它就是继承类Vector的。当然,Stack是Java2前的容器类,现在我们可以使用LinkedList来进行栈的所有操作。

    队列

    队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

    队列示意图

    我们可以使用链表来实现队列,下面代码简单展示了利用LinkedList来实现队列类。

    • 代码9 简单实现队列类
    public class MyQueue<E> {
    
        private LinkedList<E> list = new LinkedList<>();
    
        // 入队
        public void enqueue(E e) {
            list.addLast(e);
        }
    
        // 出队
        public E dequeue() {
            return list.removeFirst();
        }
    }
    

    普通的队列是一种先进先出的数据结构,而优先队列中,元素都被赋予优先级。当访问元素的时候,具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的,比如医院的急症室为病人赋予优先级,具有最高优先级的病人最先得到治疗。在Java集合框架中,类PriorityQueue就是优先队列的实现类,具体大家可以去阅读源码。

    三、树与二叉树

    树型结构是一类非常重要的非线性数据结构,其中以树和二叉树最为常用。在介绍二叉树之前,我们先简单了解一下树的相关内容。

    ** 树 是由n(n>=1)个有限节点组成一个具有层次关系的集合。它具有以下特点:每个节点有零个或多个子节点;没有父节点的节点称为节点;每一个非根节点有且只有一个 父节点 **;除了根节点外,每个子节点可以分为多个不相交的子树。

    树的结构

    二叉树基本概念

    • 定义

    二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

    • 相关性质

    二叉树的每个结点至多只有2棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。

    二叉树的第i层至多有2(i-1)个结点;深度为k的二叉树至多有2k-1个结点。

    一棵深度为k,且有2^k-1个节点的二叉树称之为** 满二叉树 **;

    深度为k,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中,序号为1至n的节点对应时,称之为** 完全二叉树 **。

    • 三种遍历方法

    在二叉树的一些应用中,常常要求在树中查找具有某种特征的节点,或者对树中全部节点进行某种处理,这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成,根节点、左子树和右子树。如果限定先左后右,那么根据这三个部分遍历的顺序不同,可以分为先序遍历、中序遍历和后续遍历三种。

    (1) 先序遍历 若二叉树为空,则空操作,否则先访问根节点,再先序遍历左子树,最后先序遍历右子树。 (2) 中序遍历 若二叉树为空,则空操作,否则先中序遍历左子树,再访问根节点,最后中序遍历右子树。(3) 后序遍历 若二叉树为空,则空操作,否则先后序遍历左子树访问根节点,再后序遍历右子树,最后访问根节点。

    给定二叉树写出三种遍历结果

    • 树和二叉树的区别

    (1) 二叉树每个节点最多有2个子节点,树则无限制。 (2) 二叉树中节点的子树分为左子树和右子树,即使某节点只有一棵子树,也要指明该子树是左子树还是右子树,即二叉树是有序的。 (3) 树决不能为空,它至少有一个节点,而一棵二叉树可以是空的。

    上面我们主要对二叉树的相关概念进行了介绍,下面我们将从二叉查找树开始,介绍二叉树的几种常见类型,同时将之前的理论部分用代码实现出来。

    二叉查找树

    • 定义

    二叉查找树就是二叉排序树,也叫二叉搜索树。二叉查找树或者是一棵空树,或者是具有下列性质的二叉树: (1) 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;(2) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;(3) 左、右子树也分别为二叉排序树;(4) 没有键值相等的结点。

    典型的二叉查找树的构建过程

    • 性能分析

    对于二叉查找树来说,当给定值相同但顺序不同时,所构建的二叉查找树形态是不同的,下面看一个例子。

    不同形态平衡二叉树的ASL不同

    可以看到,含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下,当先后插入的关键字有序时,构成的二叉查找树蜕变为单支树,树的深度为n,其平均查找长度(n+1)/2(和顺序查找相同),最好的情况是二叉查找树的形态和折半查找的判定树相同,其平均查找长度和log2(n)成正比。平均情况下,二叉查找树的平均查找长度和logn是等数量级的,所以为了获得更好的性能,通常在二叉查找树的构建过程需要进行“平衡化处理”,之后我们将介绍平衡二叉树和红黑树,这些均可以使查找树的高度为O(log(n))。

    • 代码10 二叉树的节点
    
    class TreeNode<E> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    

    二叉查找树的三种遍历都可以直接用递归的方法来实现:

    • 代码12 先序遍历
    protected void preorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        System.out.println(root.element + " ");
    
        preorder(root.left);
    
        preorder(root.right);
    }
    
    • 代码13 中序遍历
    protected void inorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        inorder(root.left);
    
        System.out.println(root.element + " ");
    
        inorder(root.right);
    }
    
    • 代码14 后序遍历
    protected void postorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        postorder(root.left);
    
        postorder(root.right);
    
        System.out.println(root.element + " ");
    }
    
    • 代码15 二叉查找树的简单实现
    /**
     * @author JackalTsc
     */
    public class MyBinSearchTree<E extends Comparable<E>> {
    
        // 根
        private TreeNode<E> root;
    
        // 默认构造函数
        public MyBinSearchTree() {
        }
    
        // 二叉查找树的搜索
        public boolean search(E e) {
    
            TreeNode<E> current = root;
    
            while (current != null) {
    
                if (e.compareTo(current.element) < 0) {
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    current = current.right;
                } else {
                    return true;
                }
            }
    
            return false;
        }
    
        // 二叉查找树的插入
        public boolean insert(E e) {
    
            // 如果之前是空二叉树 插入的元素就作为根节点
            if (root == null) {
                root = createNewNode(e);
            } else {
                // 否则就从根节点开始遍历 直到找到合适的父节点
                TreeNode<E> parent = null;
                TreeNode<E> current = root;
                while (current != null) {
                    if (e.compareTo(current.element) < 0) {
                        parent = current;
                        current = current.left;
                    } else if (e.compareTo(current.element) > 0) {
                        parent = current;
                        current = current.right;
                    } else {
                        return false;
                    }
                }
                // 插入
                if (e.compareTo(parent.element) < 0) {
                    parent.left = createNewNode(e);
                } else {
                    parent.right = createNewNode(e);
                }
            }
            return true;
        }
    
        // 创建新的节点
        protected TreeNode<E> createNewNode(E e) {
            return new TreeNode(e);
        }
    
    }
    
    // 二叉树的节点
    class TreeNode<E extends Comparable<E>> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    
    

    上面的代码15主要展示了一个自己实现的简单的二叉查找树,其中包括了几个常见的操作,当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂,所以下面我详细介绍一下这里。

    • 二叉查找树中删除节点分析

    要在二叉查找树中删除一个元素,首先需要定位包含该元素的节点,以及它的父节点。假设current指向二叉查找树中包含该元素的节点,而parent指向current节点的父节点,current节点可能是parent节点的左孩子,也可能是右孩子。这里需要考虑两种情况:

    1. current节点没有左孩子,那么只需要将patent节点和current节点的右孩子相连。
    2. current节点有一个左孩子,假设rightMost指向包含current节点的左子树中最大元素的节点,而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值,将parentOfRightMost节点和rightMost节点的左孩子相连,然后删除rightMost节点。
        // 二叉搜索树删除节点
        public boolean delete(E e) {
    
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
    
            // 找到要删除的节点的位置
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    break;
                }
            }
    
            // 没找到要删除的节点
            if (current == null) {
                return false;
            }
    
            // 考虑第一种情况
            if (current.left == null) {
                if (parent == null) {
                    root = current.right;
                } else {
                    if (e.compareTo(parent.element) < 0) {
                        parent.left = current.right;
                    } else {
                        parent.right = current.right;
                    }
                }
            } else { // 考虑第二种情况
                TreeNode<E> parentOfRightMost = current;
                TreeNode<E> rightMost = current.left;
                // 找到左子树中最大的元素节点
                while (rightMost.right != null) {
                    parentOfRightMost = rightMost;
                    rightMost = rightMost.right;
                }
    
                // 替换
                current.element = rightMost.element;
    
                // parentOfRightMost和rightMost左孩子相连
                if (parentOfRightMost.right == rightMost) {
                    parentOfRightMost.right = rightMost.left;
                } else {
                    parentOfRightMost.left = rightMost.left;
                }
            }
    
            return true;
        }
    

    平衡二叉树

    平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1。

    平衡二叉树

    AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

    红黑树

    红黑树是平衡二叉树的一种,它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下:(1) 红黑树放弃了追求完全平衡,追求大致平衡,在与平衡二叉树的时间复杂度相差不大的情况下,保证每次插入最多只需要三次旋转就能达到平衡,实现起来也更为简单。(2) 平衡二叉树追求绝对平衡,条件比较苛刻,实现起来比较麻烦,每次插入新节点之后需要旋转的次数不能预知。点击查看更多

    四、图

    • 简介

    图是一种较线性表和树更为复杂的数据结构,在线性表中,数据元素之间仅有线性关系,在树形结构中,数据元素之间有着明显的层次关系,而在图形结构中,节点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。图的应用相当广泛,特别是近年来的迅速发展,已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

    • 相关阅读

    因为图这部分的内容还是比较多的,这里就不详细介绍了,有需要的可以自己搜索相关资料。

    (1) 《百度百科对图的介绍》
    (2) 《数据结构之图(存储结构、遍历)》

    这篇文章是常见数据结构与算法整理总结的下篇,上一篇主要是对常见的数据结构进行集中总结,这篇主要是总结一些常见的算法相关内容,文章中如有错误,欢迎指出。

    一、概述
    二、查找算法
    三、排序算法
    四、其它算法
    五、常见算法题
    六、总结
    

    一、概述

    以前看到这样一句话,语言只是工具,算法才是程序设计的灵魂。的确,算法在计算机科学中的地位真的很重要,在很多大公司的笔试面试中,算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升,花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。

    算法简介

    算法是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决,可能会存在着不同的算法,为了衡量一个算法的优劣,提出了空间复杂度与时间复杂度这两个概念。

    时间复杂度

    一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数f(n),算法的时间度量记为 ** T(n) = O(f(n)) **,它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法的渐近时间复杂度,简称时间复杂度。这里需要重点理解这个增长率。

    举个例子,看下面3个代码:
    
    1、{++x;}
    
    2、for(i = 1; i <= n; i++) { ++x; }
    
    3、for(j = 1; j <= n; j++) 
            for(j = 1; j <= n; j++) 
                 { ++x; }
    
    上述含有 ++x 操作的语句的频度分别为1 、n 、n^2,
    
    假设问题的规模扩大了n倍,3个代码的增长率分别是1 、n 、n^2
    
    它们的时间复杂度分别为O(1)、O(n )、O(n^2)
    

    空间复杂度

    空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度,记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

    二、查找算法

    查找和排序是最基础也是最重要的两类算法,熟练地掌握这两类算法,并能对这些算法的性能进行分析很重要,这两类算法中主要包括二分查找、快速排序、归并排序等等。

    顺序查找

    顺序查找又称线性查找。它的过程为:从查找表的最后一个元素开始逐个与给定关键字比较,若某个记录的关键字和给定值比较相等,则查找成功,否则,若直至第一个记录,其关键字和给定值比较都不等,则表明表中没有所查记录查找不成功,它的缺点是效率低下。

    二分查找

    • 简介

    二分查找又称折半查找,对于有序表来说,它的优点是比较次数少,查找速度快,平均性能好。

    二分查找的基本思想是将n个元素分成大致相等的两部分,取a[n/2]与x做比较,如果x=a[n/2],则找到x,算法中止;如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x。

    二分查找的时间复杂度为O(logn)

    • 实现
    //给定有序查找表array 二分查找给定的值data
    //查找成功返回下标 查找失败返回-1
    
    static int funBinSearch(int[] array, int data) {
    
        int low = 0;
        int high = array.length - 1;
    
        while (low <= high) {
    
            int mid = (low + high) / 2;
    
            if (data == array[mid]) {
                return mid;
            } else if (data < array[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }
    

    三、排序算法

    排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍,并分析它们的时空复杂度。

    常见排序算法

    常见排序算法性能比较:

    图片来自网络

    上面这张表中有稳定性这一项,排序的稳定性是指如果在排序的序列中,存在前后相同的两个元素的话,排序前和排序后他们的相对位置不发生变化。

    下面从冒泡排序开始逐一介绍。

    冒泡排序

    • 简介

    冒泡排序的基本思想是:设排序序列的记录个数为n,进行n-1次遍历,每次遍历从开始位置依次往后比较前后相邻元素,这样较大的元素往后移,n-1次遍历结束后,序列有序。

    例如,对序列(3,2,1,5)进行排序的过程是:共进行3次遍历,第1次遍历时先比较3和2,交换,继续比较3和1,交换,再比较3和5,不交换,这样第1次遍历结束,最大值5在最后的位置,得到序列(2,1,3,5)。第2次遍历时先比较2和1,交换,继续比较2和3,不交换,第2次遍历结束时次大值3在倒数第2的位置,得到序列(1,2,3,5),第3次遍历时,先比较1和2,不交换,得到最终有序序列(1,2,3,5)。

    需要注意的是,如果在某次遍历中没有发生交换,那么就不必进行下次遍历,因为序列已经有序。

    • 实现
    // 冒泡排序 注意 flag 的作用
    static void funBubbleSort(int[] array) {
    
        boolean flag = true;
    
        for (int i = 0; i < array.length - 1 && flag; i++) {
    
            flag = false;
    
            for (int j = 0; j < array.length - 1 - i; j++) {
    
                if (array[j] > array[j + 1]) {
    
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
    
                    flag = true;
                }
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
    
    • 分析

    最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序,不需要进行下一次遍历,所以最佳情况下,时间复杂度为** O(n) **。

    最坏情况下冒泡排序需要n-1次遍历,第一次遍历需要比较n-1次,第二次遍历需要n-2次,...,最后一次需要比较1次,最差情况下时间复杂度为** O(n^2) **。

    简单选择排序

    • 简介

    简单选择排序的思想是:设排序序列的记录个数为n,进行n-1次选择,每次在n-i+1(i = 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。

    例如,排序序列(3,2,1,5)的过程是,进行3次选择,第1次选择在4个记录中选择最小的值为1,放在第1个位置,得到序列(1,3,2,5),第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置,得到有序序列(1,2,3,5),第3次选择因为最小的值3已经在第3个位置不需要操作,最后得到有序序列(1,2,3,5)。

    • 实现
    static void funSelectionSort(int[] array) {
    
        for (int i = 0; i < array.length - 1; i++) {
    
            int mink = i;
    
                // 每次从未排序数组中找到最小值的坐标
            for (int j = i + 1; j < array.length; j++) {
    
                if (array[j] < array[mink]) {
                    mink = j;
                }
            }
    
            // 将最小值放在最前面
            if (mink != i) {
                int temp = array[mink];
                array[mink] = array[i];
                array[i] = temp;
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时,需进行n-1次比较;当i=2时,需进行n-2次比较;依次类推,共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2,即进行比较操作的时间复杂度为 O(n^2) ,进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。

    最好情况下,即待排序记录初始状态就已经是正序排列了,则不需要移动记录。最坏情况下,即待排序记录初始状态是按第一条记录最大,之后的记录从小到大顺序排列,则需要移动记录的次数最多为3(n-1)。

    简单选择排序是不稳定排序。

    直接插入排序

    • 简介

    直接插入的思想是:是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增1的有序表。

    例如,排序序列(3,2,1,5)的过程是,初始时有序序列为(3),然后从位置1开始,先访问到2,将2插入到3前面,得到有序序列(2,3),之后访问1,找到合适的插入位置后得到有序序列(1,2,3),最后访问5,得到最终有序序列(1,2,3,5).

    • 实现
    static void funDInsertSort(int[] array) {
    
        int j;
    
        for (int i = 1; i < array.length; i++) {
    
            int temp = array[i];
    
            j = i - 1;
    
            while (j > -1 && temp < array[j]) {
    
                array[j + 1] = array[j];
    
                j--;
            }
    
            array[j + 1] = temp;
    
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    最好情况下,当待排序序列中记录已经有序时,则需要n-1次比较,不需要移动,时间复杂度为** O(n) 。最差情况下,当待排序序列中所有记录正好逆序时,则比较次数和移动次数都达到最大值,时间复杂度为 O(n^2) 。平均情况下,时间复杂度为 O(n^2) **。

    希尔排序

    希尔排序又称“缩小增量排序”,它是基于直接插入排序的以下两点性质而提出的一种改进:(1) 直接插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。点击查看更多关于希尔排序的内容

    归并排序

    • 简介

    归并排序是分治法的一个典型应用,它的主要思想是:将待排序序列分为两部分,对每部分递归地应用归并排序,在两部分都排好序后进行合并。

    例如,排序序列(3,2,8,6,7,9,1,5)的过程是,先将序列分为两部分,(3,2,8,6)和(7,9,1,5),然后对两部分分别应用归并排序,第1部分(3,2,8,6),第2部分(7,9,1,5),对两个部分分别进行归并排序,第1部分继续分为(3,2)和(8,6),(3,2)继续分为(3)和(2),(8,6)继续分为(8)和(6),之后进行合并得到(2,3),(6,8),再合并得到(2,3,6,8),第2部分进行归并排序得到(1,5,7,9),最后合并两部分得到(1,2,3,5,6,7,8,9)。

    • 实现
        //归并排序
        static void funMergeSort(int[] array) {
    
            if (array.length > 1) {
    
                int length1 = array.length / 2;
                int[] array1 = new int[length1];
                System.arraycopy(array, 0, array1, 0, length1);
                funMergeSort(array1);
    
                int length2 = array.length - length1;
                int[] array2 = new int[length2];
                System.arraycopy(array, length1, array2, 0, length2);
                funMergeSort(array2);
    
                int[] datas = merge(array1, array2);
                System.arraycopy(datas, 0, array, 0, array.length);
            }
    
        }
    
        //合并两个数组
        static int[] merge(int[] list1, int[] list2) {
    
            int[] list3 = new int[list1.length + list2.length];
    
            int count1 = 0;
            int count2 = 0;
            int count3 = 0;
    
            while (count1 < list1.length && count2 < list2.length) {
    
                if (list1[count1] < list2[count2]) {
                    list3[count3++] = list1[count1++];
                } else {
                    list3[count3++] = list2[count2++];
                }
            }
    
            while (count1 < list1.length) {
                list3[count3++] = list1[count1++];
            }
    
            while (count2 < list2.length) {
                list3[count3++] = list2[count2++];
            }
    
            return list3;
        }
    
    • 分析

    归并排序的时间复杂度为O(nlogn),它是一种稳定的排序,java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。

    快速排序

    • 简介

    快速排序的主要思想是:在待排序的序列中选择一个称为主元的元素,将数组分为两部分,使得第一部分中的所有元素都小于或等于主元,而第二部分中的所有元素都大于主元,然后对两部分递归地应用快速排序算法。

    • 实现
    // 快速排序
    static void funQuickSort(int[] mdata, int start, int end) {
        if (end > start) {
            int pivotIndex = quickSortPartition(mdata, start, end);
            funQuickSort(mdata, start, pivotIndex - 1);
            funQuickSort(mdata, pivotIndex + 1, end);
        }
    }
    
    // 快速排序前的划分
    static int quickSortPartition(int[] list, int first, int last) {
    
        int pivot = list[first];
        int low = first + 1;
        int high = last;
    
        while (high > low) {
    
            while (low <= high && list[low] <= pivot) {
                low++;
            }
    
            while (low <= high && list[high] > pivot) {
                high--;
            }
    
            if (high > low) {
                int temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
    
        while (high > first && list[high] >= pivot) {
            high--;
        }
    
        if (pivot > list[high]) {
            list[first] = list[high];
            list[high] = pivot;
            return high;
        } else {
            return first;
        }
    }
    
    • 分析

    在快速排序算法中,比较关键的一个部分是主元的选择。在最差情况下,划分由n个元素构成的数组需要进行n次比较和n次移动,因此划分需要的时间是O(n)。在最差情况下,每次主元会将数组划分为一个大的子数组和一个空数组,这个大的子数组的规模是在上次划分的子数组的规模上减1,这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。

    最佳情况下,每次主元将数组划分为规模大致相等的两部分,时间复杂度为** O(nlogn) **。

    堆排序

    • 简介

    在介绍堆排序之前首先需要了解堆的定义,n个关键字序列K1,K2,…,Kn称为堆,当且仅当该序列满足如下性质(简称为堆性质):(1) ki <= k(2i)且 ki <= k(2i+1) (1 ≤ i≤ n/2),当然,这是小根堆,大根堆则换成>=号。

    如果将上面满足堆性质的序列看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有的非终端节点的值均不大于(或不小于)其左右孩子节点的值。

    堆排序的主要思想是:给定一个待排序序列,首先经过一次调整,将序列构建成一个大顶堆,此时第一个元素是最大的元素,将其和序列的最后一个元素交换,然后对前n-1个元素调整为大顶堆,再将其第一个元素和末尾元素交换,这样最后即可得到有序序列。

    • 实现
    //堆排序
    public class TestHeapSort {
    
        public static void main(String[] args) {
            int arr[] = { 5, 6, 1, 0, 2, 9 };
            heapsort(arr, 6);
            System.out.println(Arrays.toString(arr));
        }
    
        static void heapsort(int arr[], int n) {
    
            // 先建大顶堆
            for (int i = n / 2 - 1; i >= 0; i--) {
                heapAdjust(arr, i, n);
            }
    
            for (int i = 0; i < n - 1; i++) {
                swap(arr, 0, n - i - 1);
                heapAdjust(arr, 0, n - i - 1);
            }
        }
    
        // 交换两个数
        static void swap(int arr[], int low, int high) {
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
        }
    
        // 调整堆
        static void heapAdjust(int arr[], int index, int n) {
    
            int temp = arr[index];
    
            int child = 0;
    
            while (index * 2 + 1 < n) {
                            
                child = index * 2 + 1;
                            
                // child为左右孩子中较大的那个
                if (child != n - 1 && arr[child] < arr[child + 1]) {
                    child++;
                }
                // 如果指定节点大于较大的孩子 不需要调整
                if (temp > arr[child]) {
                    break;
                } else {
                    // 否则继续往下判断孩子的孩子 直到找到合适的位置
                    arr[index] = arr[child];
                    index = child;
                }
            }
    
            arr[index] = temp;
        }
    }
    
    
    • 分析

    由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn),空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比,堆排序在最差情况下的时间复杂度优于快排,空间效率高于归并排序。

    四、其它算法

    在上面的篇幅中,主要是对查找和常见的几种排序算法作了介绍,这些内容都是基础的但是必须掌握的内容,尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。(这里不禁想起百度一面的时候让我写二分查找和堆排序,二分查找还行,然而堆排序当时一脸懵逼...)下面主要是介绍一些常见的其它算法。

    递归

    • 简介

    在平常解决一些编程或者做一些算法题的时候,经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。

    • 经典例子

    斐波那契数列,又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入,故又称为“兔子数列”,指的是这样一个数列:0、1、1、2、3、5、8、13、21、34、……在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*)。

    //斐波那契数列 递归实现
    static long funFib(long index) {
    
        if (index == 0) {
            return 0;
        } else if (index == 1) {
            return 1;
        } else {
            return funFib(index - 1) + funFib(index - 2);
        }
    }
    

    上面代码是斐波那契数列的递归实现,然而我们不难得到它的时间复杂度是O(2^n),递归有时候可以很方便地解决一些问题,但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式,效率比递归方法的效率高。

    static long funFib2(long index) {
    
        long f0 = 0;
        long f1 = 1;
        long f2 = 1;
    
        if (index == 0) {
            return f0;
        } else if (index == 1) {
            return f1;
        } else if (index == 2) {
            return f2;
        }
    
        for (int i = 3; i <= index; i++) {
            f0 = f1;
            f1 = f2;
            f2 = f0 + f1;
        }
    
        return f2;
    }
    

    分治算法

    分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容

    动态规划

    动态规划与分治方法相似,都是通过组合子问题的解来求解待解决的问题。但是,分治算法将问题划分为互不相交的子问题,递归地求解子问题,再将它们的解组合起来,而动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容

    动态规划典型的一个例子是最长公共子序列问题。

    常见的算法还有很多,比如贪心算法,回溯算法等等,这里都不再详细介绍,想要熟练掌握,还是要靠刷题,刷题,刷题,然后总结。

    五、常见算法题

    下面是一些常见的算法题汇总。

    不使用临时变量交换两个数

    static void funSwapTwo(int a, int b) {
    
        a = a ^ b;
        b = b ^ a;
        a = a ^ b;
    
        System.out.println(a + " " + b);
    }
    

    判断一个数是否为素数

    static boolean funIsPrime(int m) {
    
        boolean flag = true;
    
        if (m == 1) {
            flag = false;
        } else {
    
            for (int i = 2; i <= Math.sqrt(m); i++) {
                if (m % i == 0) {
                    flag = false;
                    break;
                }
            }
        }
    
        return flag;
    }
    

    其它算法题

    1、15道使用频率极高的基础算法题
    2、二叉树相关算法题
    3、链表相关算法题
    4、字符串相关算法问题

    Java入门书籍,Java基础及进阶书籍,框架与中间件,架构设计,设计模式,数学与算法,JVM周边语言,项目管理&领导力&流程,职业素养与个人成长

    数据结构与算法原文出自简书尘语凡心常见数据结构与算法整理总结

    当然作为后端也要掌握一些架构师技术图谱

    展开全文
  • 医学图像分割是医学图像处理与分析领域的复杂而关键的步骤,其目的是将医学图像中具有某些特殊含义的部分分割出来,并提取相关特征,为临床诊疗和病理研究提供可靠的依据,辅助医生作出更为准确的诊断。...
  • X光检查是传统的影像检查手段,它是应用较早、最普遍,价格也相对便宜。主要用于一些疾病的初步检查,便于发现较明显病变的组织和结构,是疾病初筛的首选检查方式。 ①优点:X光是观察骨骼简便的检查方式,价格也...
  • 移动医疗是什么 移动医疗应用实例

    千次阅读 2019-07-10 17:48:51
    移动医疗简介 移动医疗(mHealth),就是通过使用移动通信技术——例如PDA、移动电话和卫星通信来...移动医疗服务主要包括移动护、患者服务、移动支付、资产管理及远程诊疗。其涉及到医院的门诊、输液、病房、手术...
  • 在这篇文章中,作者通过 4 篇...然而在一些应用领域中,例如医学领域、经济领域以及一些政务信息化领域中,海量的可用训练数据往往是非常有限的。存在这些问题的主要原因:一是,针对机器学习算法的数据标注任务需要
  • 留学韩国的十大优点

    千次阅读 2006-07-02 23:18:00
    留学韩国的十大优点 留学韩国的十大优点: 教育水平位居世界前列,学习费用低廉。
  • 基于深度学习的医学图像分割综述

    万次阅读 多人点赞 2018-07-03 10:15:34
    二维图像中的每个元素称为像素,三维区域中每个元素称为体素,在某些情形下,可以把三维图像表示为一系列的二维切片进行观察,优点是计算复杂度低且需要的内存较小。 1.1 MR图像 磁共振成像(MRI)是无线电...
  • ,阿里健康虽已与多家医疗公司签订战略合作协议,将这些公司作为其业务的线下落地,但影像方向万东是目前唯一一家,此次参与万东三年期的定增也体现阿里系对于万东未来的看好。万东之前基于政府计划在中山、平谷、...
  • 在此,我就我们小组的六位组员对这一年来的工作和学习做一个小小的总结,希望从中发现一些优点和缺点,为我们以后的学习和工作增加经验。 临床的实习是对理论学习阶段的巩固与加强,也是对临床技能操作的培养和锻炼...
  • 医学图像分割综述(上)

    万次阅读 2017-11-28 11:23:45
    医学图像分割是医学图像处理与分析领域的复杂而关键的步骤,其目的是将医学图像中具有某些特殊含义的部分分割出来,并提取相关特征,为临床诊疗和病理研究提供可靠的依据,辅助医生作出更为准确的诊断。...
  • 学生科室实习鉴定表内容 学生科室实习会让你受益匪浅并将终生受用,那么你要怎么去写学生科室实习鉴定表内容呢?下面由本小编精心整理的... 就我们儿科而言,首先要善于发现科内护理人员的优点,利用其优点,...
  • 优点是什么? 真实有效。 大部分方案在办公室、电脑前面就能做。 在此之后,我开始有意识的看了很多中医相关的书籍和理论。 虽然现在 ...
  • 医学图像处理综述

    万次阅读 多人点赞 2019-07-09 22:15:51
    由于人体解剖结构的复杂性和功能的系统性,虽然已有研究通过医学图像的自动分割区分出所需的器官、组织或找到病变区的方法,但目前现成的软件包一般无法完成全自动的分割,尚需要解剖方面的人工干预[9]。...
  • 医疗his系统的优势

    千次阅读 2019-05-29 15:07:24
    1、医院管理系统—医疗HIS系统实现了”以病人为中心、以医疗信息为主线”的设计思想,真正达到了医院信息管理的要求。 2、医院管理系统—医疗HIS系统实临床信息的网络化管理,保证了医生可以及时、准确地得到病人...
  • 结合法国的教育制度,分析了其对学生培训过程中注重理论课程的综合性、理论教学与临床实践合理结合、安排大量见习实习及鼓励学生自主学习的特点。法国对临床医生的培养还具有国家统筹规划、重视全科医学、不断进行...
  • 研究了中医推拿中常用的滚法、按法、揉法、推法等手法的运动及动力...该串并联机器人机构综合了串并联机构的优点,不仅能模拟中医推拿常用的几种手法,而且结构简单、位置分析求解容易、解耦性强,易于实时控制。
  • 稀疏性的优点

    万次阅读 2018-12-23 20:51:59
    这种稀疏性带来许多优点. 参数稀疏有什么好处 1)特征选择(Feature Selection): 大家对稀疏规则化趋之若鹜的一个关键原因在于它能实现特征的自动选择。一般来说,xi的大部分元素(也就是特征)都是和最终的输出yi...
  • 机器人编程简介~2019~

    万次阅读 2019-04-22 21:21:34
    在这篇文章中,将介绍机器人技术中使用的5大最流行的编程语言,并将讨论它们的优点和缺点,以及使用它们的原因与不适用场合。 这实际上是一个非常合理的问题。毕竟,如果事实证明你永远不会使用它,那么投入大量...
  • 医疗标准一览表

    千次阅读 2004-12-12 10:45:00
    ATC的优点如下: (1)确定了一个药物产品,包括有效物质、用药途径和相关的剂量。 (2)既面向治疗、又面向化学药品,这个特征是其他系统所缺乏的。 (3)其分级结构允许逻辑分组。 (4)已作为WHO药物应用研究的...
  • 医学影像手术规划和手术导航

    千次阅读 2018-04-16 21:56:24
    “全息导航平台”还有一个很大的优点,就是降低患者和医生受辐射照射的危险。因为手术时医生要通过核磁共振、CT 等数据来判断手术位置、角度和深度,但有了它的协助,可以减少医生判断的时间。 二. 法国Medtech...
  • 该设计方案结合了串并联机构的优点,保证机构有足够的刚度、精度和工作空间完成推拿动作。建立了机械臂的运动模型,利用D-H变换求解其运动的正解和逆解。利用Pro/E建立机械臂的三维模型,导入ADAMS就其位移、速度、...
  • 推荐词:慕课网的一个小优点就是项目式驱动,并且有很多好玩的小项目。比如这一课非常短,但是短小精悍。用几个小时的时间就能学会2048的制作,很有成就感。 还有其他很多平台,比如Khan Academy、网易云课堂、...
  • ​ 通过迁移学习我们可以将已经到的模型参数(也可理解为模型到的知识)通过某种方式来分享给新模型从而加快并优化模型的学习效率不用像大多数网络那样从零学习(starting from scratch,tabula rasa)。...
  • 2020年学生自我鉴定1000字范文三篇 篇一 短短一年的实习生活就要结束了,回顾这段时间的点点滴滴,虽然说不上*澎湃,但是毕竟我们为此付出了诸多的心血,心里难免有着激动。现在要离开带领我们踏入医生行列的老师...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,335
精华内容 8,134
关键字:

学医的优点