精华内容
参与话题
问答
  • 有效学习的6个方法学习方法

    千次阅读 2018-03-09 13:56:01
    有效学习的6个方法(上) 的一些感想。 1.价值感 这个就是做这件事情的动力,没有动力的话,是不愿意去做这件事的,效果当然也不会很好。做一件事把这做这件事的意义定的越大,越有动力,也就是这件事做成...

    今天看了得到
    有效学习的6个方法(上)
    的一些感想。

    1.价值感

    这个就是做这件事情的动力,没有动力的话,是不愿意去做这件事的,效果当然也不会很好。做一件事把这做这件事的意义定的越大,越有动力,也就是这件事做成之后自己会收获的东西。

    2.目标

    学习,做事前一定要有个目标,计划安排是目标的具体实现,当然好多人会说计划赶不上变化,据我观察,凡是拿这句话当借口的人往往,没有好的计划安排。其实好的计划就是提前模拟一下能预期的过程,好的计划一定要对流程十分熟悉,尽量减少模糊不清的地方。
    设定目标的几个要点:

    • 阶段性设立目标:
    • 目标一定要:目标要明确,不要模糊(比如多读书、好好工作)
    • 要确立时间节点
    • 目标定位:比平时所掌握的课程稍微难一点,既不能太难,也不能太容易。

    3.提升:

    及时建立反馈机制,优化学习效果要学会提问:
    比如:

    • 这段文字表达的是什么意思?
    • 我有什么不理解的吗?
    • 如果不按照书上的做会怎么样?
    • 我怎么知道我掌握了那些内容?
    • 有没有办法衡量一下自己的理解程度(可以使用自己的语言通俗的描述一下)

    4.提取练习

    回忆学过的内容

    任何有效的学习过程都需要大脑主动参与。

    我是IT小王,如果喜欢我的文章,可以扫码关注我的微信公众号
    在这里插入图片描述

    展开全文
  • 反馈式学习

    千次阅读 2019-03-13 22:21:34
    本篇文章将讲述我自己的学习方法——反馈式学习。每个人对学习方法都有不同的理解,可能某人对某种学习方式有较深刻的感触,而别人却不感兴趣。但如果你深究到底,你可能发现它们的核心基本是一样的。这篇文章里面的...

    本篇文章将讲述我自己的学习方法——反馈式学习。每个人对学习方法都有不同的理解,可能某个人对某种学习方式有较深刻的感触,而其他人却不感兴趣。这可能是学习方式没能勾起你的生活体验。但如果你深究到底,你可能会发现它们的核心原理是一样的。同样,这篇文章里面的学习形式其实并不重要,最主要的还是其原理。希望你能根据其背后原理整出自己的学习方法。

    基础篇

    一、反馈式学习

    反馈式学习是以反馈为根本的学习方式,一切反馈都可以当作一种学习。你首先搭建好一个有信息反馈的环境,然后在里面探索,在探索过程中逐渐形成知识体系。此时的你犹如一个新奇的小孩走进了糖果屋一样,到处探索,无拘无束,你想要的东西都能从探索中获取到。

    反馈环境可以各式各样的,可以是搜索引擎,可以是调试环境,可以是书籍,也可以是同行专家。你就假定你的反馈环境可以给你各种想要的答案。以搜索引擎作为反馈来源的话,你有什么不懂的概念可以直接用搜索引擎搜索。如果书是你的信息来源,你有什么疑惑就在书上找答案。在调试的时候,你有什么想法你可以放到调试环境里试,它会告诉你正确与否。各种反馈方式其实并不孤立的,你可以把它们组合在一起用。不懂的问题找书,书上没有答案就上网查,百度不到就谷歌搜索,其他博客找不到就官网找。从质量来说,它们的质量从低到高为:网站博客<书籍<官网<源码(这里并不全罗列)。你尽量挑选质量高的信息来源,这样保证了信息的可靠程度。
    反馈式学习模型
    反馈式学习本质是自身和反馈源形成反馈回路来修正认知偏差。自身是指现在已有的认知框架,反馈源是对照组。当自身的认知和反馈源存在误差时候,根据反馈来修正偏差。当你在反馈环境里面探索中,错误的认知会被纠正,正确的会被夯实。

    虽然你知道本质,但在实际操作上不好操作,你会用到另外一个反馈回路:“问题——答案”反馈回路。在考驾照时,有个科目一,是考驾驶的相关规则的,大抵上是在电脑上完成相关的题目的作答。这时候你能获取到到的资料是题库里面的题目。即使刚开始什么都不懂,随着做题,做着做着自己就会了。这个从不会到学会的过程是一个很奇妙的感觉。这时题目和答案构成了一个反馈回路。不断做题的过程中,其实你也是不断修正自己认知。做对做错,答案会告诉你结果。哪怕做的时候没有一点概念,看答案你也能从中学到理论。相比比于你直接看理论,自己做题探索得来的则更加深刻。

    问题和答案的关系将会像下面这图一样。

    问题-答案

    在这里,问题不单单指的是问题,它更代表着一种搓揉机制;答案也同样不单指答案,它是一种学习机制。搓揉机制你想方设法去产生问题的地方,是你学习的方向。你可以复盘,用现在的认知和过去的认知相对比,搓出偏差来。你可以自己对自己提出各种问题。你也可以用下面将要说的框架理论来指导和扩展自己的认知圈。总之,任何你想要提出的问题都尽情地在这里提出。学习机制是你根据问题然后在环境里探索得出的答案。你假定反馈环境是能给你带来任何你想要的答案。你所要做的是在你环境里找到那个答案。搓揉机制产生问题,你就带着问题到环境里探索得到答案返回,然后搓揉机制再根据这答案的基础上继续产生问题,一圈圈扩展。

    反馈式学习是把你放在一个有反馈的容器里反馈。它分为两个观点:结构化,容器化。结构化是把知识整理方法,容器化是用来学习的环境,结构化也细分目标,引导你在容器内前进。下面将细将这两点。

    二、结构化

    结构化概括来说是:自上而下套框架,自下而上提炼框架。主要是用来作为产生学习方向和提炼知识架构用的。

    2.1 自上而下套框架

    狭义的框架指的是知识体系,广义的框架指的是计划。如果你知道一个知识点的知识体系,你要学这个知识,那么这个知识体系架构就变成你要走的路。知识体系上面的每一个节点都是你的计划里面的目标。你一步一脚印,按顺序一个个实现,最终会到达你想去的目的地。但现实情况并没有这么理想,随着时间推移,你的认知会逐渐扩大,你的所认识的知识体系也会有所变化。这就有点抓狂了,有种计划赶不上变化的感觉了。但你也不必慌。一般来说你前一次的框架会是后一次的框架扩展的枝干。你每次掌握住当前层次的大方向,然后在枝节方面再细节化行了。

    下面说个实际的例子。如果让你学一个你从来没接触过的知识的时候,你会怎么做?你可以像下面的这么做。首先,你利用搜索引擎了解到相关概念,了解相关的术语。然后找一个简单的Demo来实现。这个Demo最好是有详细的讲解,这样方便理解。接着,你就在这个Demo上添加其他的功能,丰富这方面的知识。这里你如果能有同行专家来交流就更好了,有人指导还是学得还是比较快的。到最后,为了完善这个知识体系,你需上官网看最官方最权威最全面的解读,如有源码可以直接看源码。

    反馈式学习-扩展过程

    这个学习的过程发生了什么呢?当你刚开始用搜索搜索概念做Demo的时候,你会在心里会形成一个初步的认识。这个初步的认知是颗种子,它会指导后面你要去了解的方向。而后面的看源码问同行是在逐步填充你这个架构,在细节方面丰满它。

    套框架的总体思路是先搭建一个架子,然后往里面填充内容。即使刚开始搭起来的框架有点简陋,那也没关系。随着你的认知进一步发展,你的框架会逐步壮大完善的。你的认知圈子是以螺旋扩展的形式扩大的。换一个行为动力你可能更容易懂些,其实这个就是深挖。平时可能不会这么按部就班地操作,但是心里可以以深挖为方向,你会比较有动力学下去。

    扩展模式

    这个也可以用于解决问题上。这个思想好比光学显微镜调节中的粗调和细调。你要观察到你观察的东西,先用粗调螺旋调整到你能看清楚的大致区域,然后用细调的方式来逐步调整。如果你知道解决这个问题的大致流程,那你就可以据此进一步划分,把大的问题分解为小问题,小问题继续划分更小的问题,直到细分最小可执行颗粒,然后一个个解决。

    在每一个阶段里面,大的方向由大纲提供,细节方向可以在头脑里生成。即使你把目标分解到最小可执行颗粒时候你仍然会有很多细节步骤要走的。这些细小目标可能是就是十分钟的计划,全罗列出来就比较繁琐了,心里知道就行。当一个目标执行完成后需要迅速调整,否则你可能就无所事事的空虚之中,所以让你的行动目标保持动态调整中。

    问题分析

    2.2 自下而上提炼框架

    提炼框架一般用来提炼知识点。当你不清楚知识点时候可以用此来提炼和总结。提炼框架有以下几个步骤:

    • 搜罗信息
    • 罗列信息
    • 分组分类
    • 提炼框架
    • 完善框架

    下面以程序员的出路为例来说明一下。

    (1)搜罗信息

    这个就不用多说了,尽你的能力去搜罗你要的信息。

    (2)罗列信息

    拿一张A4纸把你搜罗的信息全部写下来。不需要什么限制,能想到什么就写什么。

    (做架构师,做管理,接私单、做测试、做金融经理、卖奶茶、开饭店,公务员、写书、做讲师、创业)
    (3)分组分类
    根据信息的差异性和共性,把各个信息分组分类。

    • 做架构师,做管理,接私单、做讲师、创业、写书、做测试
    • 做金融经理、卖奶茶、开饭店,公务员

    (4)提炼框架
    根据分类出来的信息提取框架。

    • 行业内
      • 做架构师,做管理,接私单、做讲师、创业、写书、做测试
    • 行业外
      • 做金融经理、卖奶茶、开饭店,公务员

    (5)完善框架
    根据框架不完善的地方继续补充完整。 这个过程可能要继续重复上面几个步骤。
    在上面的程序员出路可以继续补充为:

    • 行业内
      • 主业
        • 做架构师,做管理、做讲师、创业、做测试
      • 副业
        • 接私单,写书
    • 行业外
      • 开店
        • 卖奶茶、开饭店
      • 其他
        • 做金融经理,公务员,啃老……

    整个过程是一个先发散再收敛的过程。提炼框架后,你对整个知识结构的认知就比较清晰了。

    知识要有结构才好驾驭。首先把知识分解成一个个元素,然后找这些元素之间的联系。这个联系可以是旧知识也可以是新知识,一般是和旧知识联系,这样记忆更加有效。最后运用的时候,你会用这个简化的结构驾驭外部的复杂知识。

    2.3 框架的生长

    “自上而下套框架,自下而上提炼框架。”说的是两个功能,看起来比较有菱角分明,实际用的时候基本是合着一起用。先生成一个最小框架,然后在这个框架上生长。从0到1是搭建框架的过程,有时遇到新的知识会补充进原有的知识体系里面,从1到N是框架的生长。这就是框架的生长。上面几步,可以用思维导图软件来操作。

    这个框架是核心部分,需要你长期维护迭代,也需要你不断去复习。这个框架现实里一份,头脑里一份。你要每天都要检查框架,哪里忘了要去复习一下。

    三、容器化

    容器是一个有边界的反馈环境。在这个有限边界的环境内,你自由探索,然后根据反馈来学习。这个环境可以是一个项目,可以是一个知识点,也可以是一本书。下面将从时间、内容、空间三方面来叙说。总得来说,时间和内容上都是一份份输出。这里的输出方式不限定这这几种,你要想一个适合你自己的输出方式。有输出才有反馈。

    3.1 时间一份份输出

    无论是有多大的任务,都是时间累积而成。你到达你的目标是靠时间一份份输出的。

    时间管理

    上面的图是时间分配的一种方式。时间是一份份输出。每一份时间里面由任务的时间和冗余时间组成。任务时间是你的学习任务执行时间,冗余时间是给你消化用的。每当你学习完一个知识点后,留出一段冗余时间来复习一下,这样效果会更好。这个的冗余时间不多,但给你直观的感受是像有无限多的时间来消化一样。这样的构造能给你有机会喘气来回顾你所学的知识点。如果一份时间不够那就再加一份,直至学会为止。一份时间可以是1小时,可以是一天,也可以是一个星期,一个月。这时间由你来定。一般选一个星期为一份会比较好点。

    根据时间和任务的限制来划分,有这么三种组合:限制时间和任务、限制任务不限制时间、限制时间不限制任务。我个人更倾向于限制时间不限制任务这种,这种有自己的独立思考空间,有些事是不是一开始就能规划好的。把时间分成一份份的,我直接按学校的上课时间来安排了,学习40分钟,休息10分钟,然后循环,每天都是那个固定时间学习。

    3.2 内容一份份输出

    内容是你目标。用上面的自上下套框架的方式,分解你的学习任务,最后分成一个个点。然后你一个个点去突破。

    具体如下:

    • 1.选一个知识点:*****。

    • 2.查阅资料。

    • 3.把知识点将给你假想的学生。

    • 4.如果卡住,继续看课本查资料。

    • 5.重复上面步骤,直到完整说出来。

    • 6.简化模型,如有可能,和以往知识对比。不断简化,简化到你认为可以为止。

    想好在一份时间内你想要学到什么,然后围绕这个目标去查资料,看书。以这个目标是方向来查书,而不是顺着书上的内容顺序来学。这是一个结果思维。它和过程思维不同。结果思维是从你想要结果来规划方向,遇到问题就见招拆招。如果是过程思维,你的思维是专注于问题本身,为解决问题而解决问题。当问题解决了,你学习动力就没了。有时候你是为了维持一个勤奋的状态而勤奋的。那样你会陷入一个焦虑的循环中。一放松就焦虑,享受不了学习带来的成果。为了维持勤奋的状态,你不得不焦虑以维持前进的动力。以结果为向导就没这样的问题了。中间是否勤奋无关紧要,你是为了完成这个目标,你的动力一直都在。

    这里步骤不单指一个知识点,你可以套入为一个项目。你想着未来某个时间内想要完成一个什么样的作品,然后去创作它。以向外输出的形式输出你的知识。这个输出你可以说出来,做出来,或者回想都可以。在回想的过程中哪里还模糊就去补哪里。你就自己选择合适你自己的形式来操作。

    输出不一定是这一种形式,你也可以用其他方式输出,比如是回想,做项目,做题测试等等。
    下面用回想的方式作为例子,列举一下步骤。

    • 1.选一个知识点:*****。

    • 2.查阅资料。

    • 3.回想你学到了什么知识点。

    • 4.如果回想不起来,那就继续查资料。

    • 5.重复上面步骤,直到完整地在脑海里看到整个知识脉络。

    • 6.简化模型,如有可能,和以往知识对比。不断简化,简化到你认为可以为止。

    在实践中,我发现用查字典式看书会比较有效率。比如说你要学一个知识点,你就在书里的找该内容相关的来看就行了。入深山探险,每次只取一物,如此往复,每次作一意求之。

    3.3 空间化

    空间化是分给空间成一块块,把你的行为和空间结合在一起,当你一进入这个空间就想做这事。这个怎么理解呢?你可以参照图书馆,你一进入图书馆,你就想看书学习。再比如,你一靠上客厅的沙发,你就想看电视一样。这里空间和某些行为联系在一起了。这里的行为有两种,一个是他人给你的,另外一个是你过去在这个空间的行为。你在图书馆,你看到别人都在看书,你行为就会向着这方向来趋近。你过去在沙发上都是在看电视的,你在这个空间就绑定了这个看电视的行为,一靠近就想看电视了。

    如果过去你都是一打开电脑就娱乐的话,我想你很难静下心来学习了。因为你一边踩着刹车想要学习,一边踩着油门说我要看娱乐。要解决这个问题是找个书房,在这个书房里面你就只学习。你在这个空间内做的事情越纯粹,你和这个空间绑定越牢固。当你下次再进入这个书房内就会想着学习了。如果不得不用电脑的话,就建议你用两台电脑,一台专门用来学习,一台专门用来娱乐的。你在家学习的话就专门培养这个一个环境,这样学习才有效率。

    应用篇

    四、专题训练

    这是上面几个结构化和容器化内容的综合运用。如其本意,专门针对一个主题来训练。这里关键点是多练,然后从中总结规律。对于一个专题,你想办法扩展它的练习次数。在第一次做的时候,不要追求完美或最优解,能做出来就行。然后多次重复这个专题,逐步优化。参考蚂蚁算法。蚂蚁寻食,要找到最优解,不是一蹴而就的。第一次可能找到时一条比较远的路,然后往后几次,蚂蚁可能找到一个最近的路线。经过大量的刺探,由于最短的路线用时最短,蚂蚁就上面的走的次数最多,留下的信息素最多;最远的路,由于路程远,在相同时间内蚂蚁能走的次数有限,留下信息素少,相比之下就筛选出最短的路。所以呢,你也别指望第一次就能做到最好了。能做出来就行,然后再逐步优化。够造一个种子,然后通过反馈系统来优化。

    如果把每一次的训练轮回当作一颗韭菜,训练多了,你可以把它们靠拢在一起,进行割韭菜。这是什么意思呢?这是说,训练多了,对于中间的高频模块和规律就比较容易有好的感知,这时候割韭菜就是收获的时候。总结一下它们的规律,收获训练的果实。如果把理论知识当作树根,知识的实现当做树冠部分,那么要快速掌握一个知识点的方法是撞我连接理论知识和知识应用的桥梁——树干。进行大量练习,把树干部分的知识共性把握出来,然后上下延伸,那么你能很好地把握住知识点。

    你可以理解为一个范式,这个范式反复练。

    五、种子计划

    种子计划是说先生成一个种子,然后悉心培育,慢慢壮大。大规模试错可以收割到种子,有了最简单的原型后,可以在这个原型慢慢演变繁育。这个适合于有项目的做法。如果你有一个项目,可以先实现它的最基本功能,然后逐渐扩充它的功能。

    六、费曼学习法

    上面这个学习方法适合有项目的学习方式。如果没有项目的学习方式呢?比如说看书上的知识。用费曼学习法就很实用。主要是说出来。
    上面说到的那几个步骤就是费曼学习法,和种子计划的内涵类似。

    • 1.选一个知识点:*****。

    • 2.查阅资料。

    • 3.把知识点将给你假想的学生。

    • 4.如果卡住,继续看课本查资料。

    • 5.重复上面步骤,直到完整说出来。

    • 6.简化模型,如有可能,和以往知识对比。不断简化,简化到你认为可以为止。

    这个就有点像对小黄鸭debug的做法。小黄鸭查虫法是说,你对着一个小黄鸭说出你项目的逻辑思路,这时候可以发现你的漏洞。你学到什么也可以这样做,学到了什么,对你身边的毛公仔说。如果发现自己说不明白就继续看书,看完后继续说,如此反复,最后优化。

    六、PPC理论

    这个是用来建立你的影响力的。PPC,对应的解释是:profession专业、presentation展现、connection连接。专业是你的专业技能。展现是你能展现你技术的方式,比如说你的作品,你的博客等等。连接是说你能连接多少用户。能连接多少个用户你的影响力就有多大。比如说你的GitHub上的作品能用1w个star,那么你的影响力已经很大了。专业是配重,展现是支点,连接是杠杆,这几个点用来放大你的影响力。

    七、感觉打分法

    这个类似上面说的费曼学习法,但这次是自己讲给自己听的。你学完一个知识点,你回忆一下你学到了什么,自己感觉一下有多少成把握掌握了这个知识。如果回想过程遇到有模糊,那就去看书,继续回想,直到所有内容清新展现在你眼前。你对该内容有百分百把握的时候就是你出师的时候。如果感觉还没到能控制的时候,就重复执行这样的动作。这是一个反馈渐进的过程。你就当自己是考官,不断问有关这些知识点的问题。

    八、习惯法

    习惯法意思是培养一个习惯。比如说每天背英语,这个养成一种习惯。或者固定时间做固定事。

    九、笔记法

    笔记法对应的过程是:随机乱序+集中突破+六经注我。
    这是一个看书的方法。这三个是看书过程。

    • 随机乱序:随意翻书,翻到哪看到哪。
    • 集中突破:看到有困难的地方就专门去查一下。每进宝山,每次作一意求之。
    • 六经注我:把外面的资料打碎搬到脑里,重新组装一部自己的书。

    十、总结

    上面主要讲了两个理论和一堆实践方法。理论篇有两个理论结构化和容器化。“反馈式学习”这个名称也是一个隐含的条件。应用篇说的是对理论的具体实践。应用篇那里面的方法其实其本质是一样的,只是以不同的形式表现。你根据你自己的喜好来选取。我自己就选取了“随机乱序+集中突破+六经注我”和“习惯法”这两种形式为主,其他形式为辅助。

    在这里插入图片描述

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

    万次阅读 多人点赞 2018-05-20 16:15:02
    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? 路线 Java发展到现在,按应用来分主要分为三大...

     

     

    java详细路线:

     

    原文出自点击打开链接

    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢?

    路线

    Java发展到现在,按应用来分主要分为三大块:J2SE,J2ME和J2EE。

    这三块相互补充,应用范围不同。

    J2SE就是Java2的标准版,主要用于桌面应用软件的编程;

    J2ME主要应用于嵌入是系统开发,如手机和PDA的编程;

    J2EE是Java2的企业版,主要用于分布式的网络程序的开发,如电子商务网站和ERP系统。

    先学习j2se

    要学习j2ee就要先学习j2se,刚开始学习j2se先建议不要使用IDE,然后渐渐的过渡到使用IDE开发,毕竟用它方便嘛。学习j2se推荐两本书,《java2核心技术一二卷》,《java编程思想》,《java模式》。其中《java编程思想》要研读,精读。这一段时间是基本功学习,时间会很长,也可能很短,这要看学习者自身水平而定。

    不要被IDE纠缠

    在学习java和j2ee过程中,你会遇到五花八门的IDE,不要被他们迷惑,学JAVA的时候,要学语言本身的东西,不要太在意IDE的附加功能,JAVA编程在不同IDE之间的转换是很容易的,过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder,eclipse和eclipse的加强版WSAD。用好其中一个就可以了,推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。

    选择和学习服务器使用配置

    当你有了j2se和IDE的经验时,可以开始j2ee的学习了,web服务器:tomcat,勿庸置疑,tomcat为学习web服务首选。而应用服务器目前主要有三个:jboss、weblogic、websphere。有很多项目开始采用jboss,并且有大量的公司开始做websphere或weblogic向jboss应用服务器的移植(节省成本),这里要说的是,学习tomcat和jboss我认为是首选,也是最容易上手的。学习服务器使用配置最好去询问有经验的人(有条件的话),因为他们或许一句话就能解决问题,你自己上网摸索可能要一两天(我就干过这种傻事),我们应该把主要时间放在学习原理和理论上,一项特定技术的使用永远代替不了一个人的知识和学问。

    学习web知识

    如果你是在做电子商务网站等时,你可能要充当几个角色,这是你还要学习:

    html,可能要用到vscode或者webstorm或者sublime或者等IDE。

    Javascript,学会简单的数据校验,数据联动显示等等。

    J2eeAPI学习

    学习j2eeAPI和学习服务器应该是一个迭代的过程。

    先学习jsp和servlet编程,这方面的书很多,我建立看oreilly公司的两本《jsp设计》和《java servlet编程》,oreilly出的书总是那本优秀,不得不佩服。

    学习jdbc数据库编程,j2ee项目大多都是MIS系统,访问数据库是核心。这本应属于j2se学习中,这里拿出来强调一下。

    学习jndi api,它和学习ejb可以结合起来。

    学习ejb api,推荐书《精通ejb》

    经过上面的这些的学习,大概可以对付一般的应用了。

    有人说跟着sun公司的《j2ee tutorial》一路学下来,当然也可以。

    学习ejb设计模式和看代码(最重要)

    设计模式是练内功,其重要性可以这么说吧,如果你不会用设计模式的话,你将写出一堆使用了ejb的垃圾,有慢又是一堆bug,其结果不如不用ejb实现(ejb不等于j2ee)

    无论学习什么语言,都应该看大量代码,你看的代码量不到一定数量,是学不好j2ee的。

    目前有很多开源的工程可以作为教材:

    jive论坛

    petstore sun公司

    dune sun公司

    等等,研读一个,并把它用到自己的工程中来。

    J2ee其他学习

    当你渐渐对j2ee了解到一定深度时,你要开始关注当前领域中的一些技术变化,J2ee是一块百家争鸣的领域,大家都在这里提出自己的解决方案,例如structs,hiberate,ofbiz等等,学习这些东西要你的项目和目标而定,预先补充一下未尝不可,但不用涉及太深,毕竟学习原理和理论是最最重要的事。

    目前常见j2eeAPI

    JavaServer Pages(JSP)技术1.2

    Java Servlet技术2.3

    JDBC API 2.0

    Java XML处理API(JAXP)1.1

    Enterprise JavaBeans技术2.0

    Java消息服务(JMS)1.0

    Java命名目录接口(JNDI)1.2

    Java事务API(JTA) 1.0

    JavaMail API 1.2

    JavaBeans激活架构(JAF)1.0

    J2EE连接器体系结构(JCA)1.0

    Java认证和授权服务(JAAS)1.0

    学习上面的某些API要以你的项目而定,了解所有他们总之是有好处的。

    上面印证了大家说的一句话,java语言本身不难学,但是技术太多,所以学java很费劲。回想一下,基本上每个初学者,在刚学习java的时候可能都会问别人这么一句话,你怎么知道的哪个方法(api)在哪个包里的?呵呵,无他,唯手熟尔。

    1 基础是王道。我们的基础要扎实扎实再扎实。

    以上面的整个流程来看java的技术分支很多,要想完全掌握是绝对不可能的。我们只有从中精通1到2个部分。但是java也是有通性的,所谓万变不离其宗。java的所有编程思路都是“面向对象”的编程。所以大家在往更高境界发展以前一定要打好基础,这样不管以后是jree还是j3d都有应刃而解的感觉。在这里强烈推荐“java编程思想”.

    2 所谓打好基础并不是说要熟悉所有的java代码。我说的意思是要了解java的结构。class,methode,object,各种套用import,extend 让自己在结构上对java有个立体而且整体的了解即刻。其实java的学习不用固执于对代码的熟悉,1来java本身带有很多demo,java2d

    的所有问题几乎都有demo的样例。2来java是开放代码,即使没有demo网络上也有很多高手把自己的代码分享。所以不要怕没有参考,参考是到处都有的。

    3 最后还有1点经验和大家分享,对sun的api一定要学会活用,不论是学习还是作为参考api都有很大的帮助,在完全了解java的结构的基础上,不论什么方法都是可以通过api来找到的.所以不要怕找不到方法,了解结构,了解api就能找到方法。

    重点

    精通:能够掌握此技术的85%技术要点以上,使用此技术时间超过两年,并使用此技术成功实施5个以上的项目。能使用此技术优化性能或代码,做到最大可能的重用。

    熟练:能够掌握此技术的60%技术要点以上,使用此技术时间超过一年,并使用此技术成功实施3个以上的项目。能使用此技术实现软件需求并有经验的积累在实现之前能做优化设计尽可能的实现模块或代码的重用。

    熟悉:能够掌握此技术的50%技术要点以上,使用此技术时间超过半年上,并使用此技术成功实施1个以上的项目。能使用此技术实现软件需求。

    了解:可以在实际需要时参考技术文档或帮助文件满足你的需要,基本知道此项技术在你运用是所起的作用,能够调用或者使用其根据规定提供给你的调用方式。

    二:基本要求

    1:html 掌握程度:熟练。原因:不会html你可能写JSP?

    2:javascript/jscript:掌握程度:熟悉。原因:client端的数据校验、一些页面处理需要你使用脚本。

    3:CSS 掌握程度:熟悉。原因:实现页面风格的统一通常会使用css去实现。

    4:java基础编程 掌握程度:熟练。原因:不会java你能写JSP?开玩笑吧。还有你必须非常熟悉以下几个包java.lang;java.io;java.sql;java.util;java.text;javax.sevrlet;javax.servlet.http; javax.mail;等。

    5:sql 掌握程度:熟练。原因:如果你不使用数据库的话你也许不需要掌握sql。同时你必须对以下几种数据库中的一种以上的sql比较熟悉。Oracle,DB2,Mysql,Postgresql.

    6:xml 掌握程度:了解 原因:AppServer的配置一般是使用XML来实现的。

    7:ejb 掌握程度:了解 原因:很多项目中商业逻辑是由ejb来实现的,所以呢„„

    8:以下几种AppServer(engnier) 你需要了解一个以上。

    a:)Tomcat b:)WebLogic c:)WebSphere d:)JRun e:)Resin 原因:你的jsp跑在什么上面啊!

    三:选择要求(因项目而定)

    1:LDAP 掌握程度:了解 原因:LADP越来越多的运用在权限控制上面。

    2:Struts 掌握程度:熟练 原因:如果符合MVC设计通常会使用Struts实现C。

    3:Xsp 掌握程度:根据需要而定很多时候是不使用的,但在不需要使用ejb但jsp+servlet+bean实现不了的时候Xsp是一个非常不错的选择。

    4:Linux 掌握程度:熟悉 原因:如果你的运用跑在Linux/Unix上你最少要知道rm ,mv,cp,vi,tar gzip/gunzip 是用来做什么的吧。

    四:工具的使用 1:UltraEdit(EditPlus)+jakarta-ant+jakarta-log4j; 2:Jubilder4-6 3:Visual Age For Java 4:VCafe

    以上的工具你选择你自己熟悉的吧。不过强烈建议你用log4j做调试工具。

    五:成长之路

    1:html 学习时间,如果你的智商在80以上,15天时间应该够用了。至少你能手写出一个页面来。

    2:jacascript/jscript学习时间,这真的不好说,比较深奥的东西,够用的话一个礼拜可以学写皮毛。

    3:css 学习时间,三天的时间你应该知道如何使用css了,不要求你写,一般是美工来写css。

    4:java 学习时间,天才也的三个月吧。慢满学吧。如果要精通,那我不知道需要多少时间了。用来写

    jsp,四个月应该够了。

    5:sql 学习时间,只需要知道insert ,delete ,update ,select,create/drop table的话一天你应该知道了。

    6:xml 学习时间,我不知道我还没有学会呢。呵呵。不过我知道DTD是用来做什么的。

    7:ejb 学习时间,基本的调用看3天你会调用了。不过是建立在你学会java的基础上的。

    8:熟悉AppServer,Tomcat四天你可以掌握安装,配置。把jsp跑起来了。如果是WebLogic也够了,但要使用ejb那不关你的事情吧。SA做什么去了。

    9:熟悉Linux那可得需要不少时间。慢慢看man吧。

    10:Struts如果需要你再学习。

    目标

    1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF,J2EEDP)以及综合模式。你应该十分了解UML,尤其是class,object,interaction以及statediagrams。

    2. 你需要学习JAVA语言的基础知识以及它的核心类库(collections,serialization,streams, networking, multithreading,reflection,event,handling,NIO,localization,以及其他)。

    3.你应该了解JVM,classloaders,classreflect,以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。

    4. 如果你将要写客户端程序,你需要学习WEB的小应用程序(applet),必需掌握GUI设计的思想和方法,以及桌面程序的SWING,AWT, SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。

    5.你需要学习java数据库技术,如JDBCAPI并且会使用至少一种persistence/ORM构架,例如Hibernate,JDO, CocoBase,TopLink,InsideLiberator(国产JDO红工厂软件)或者iBatis。

    6.你还应该了解对象关系的阻抗失配的含义,以及它是如何影响业务对象的与关系型数据库的交互,和它的运行结果,还需要掌握不同的数据库产品运茫 热?oracle,mysql,mssqlserver。

    7.你需要学习JAVA的沙盒安全模式(classloaders,bytecodeverification,managers,policyandpermissions,

    codesigning, digitalsignatures,cryptography,certification,Kerberos,以及其他)还有不同的安全/认证 API,例如JAAS(JavaAuthenticationandAuthorizationService),JCE (JavaCryptographyExtension),JSSE(JavaSecureSocketExtension),以及JGSS (JavaGeneralSecurityService)。

    8.你需要学习Servlets,JSP,以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。

    9.你需要熟悉主流的网页框架,例如JSF,Struts,Tapestry,Cocoon,WebWork,以及他们下面的涉及模式,如MVC/MODEL2。

    10.你需要学习如何使用及管理WEB服务器,例如tomcat,resin,Jrun,并且知道如何在其基础上扩展和维护WEB程序。

    11.你需要学习分布式对象以及远程API,例如RMI和RMI/IIOP。

    12.你需要掌握各种流行中间件技术标准和与java结合实现,比如Tuxedo、CROBA,当然也包括javaEE本身。

    13.你需要学习最少一种的XMLAPI,例如JAXP(JavaAPIforXMLProcessing),JDOM(JavaforXMLDocumentObjectModel),DOM4J,或JAXR(JavaAPIforXMLRegistries)。

    14. 你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC),SAAJ (SOAPwithAttachmentsAPIforJava),JAXB(JavaArchitectureforXMLBinding),JAXM (JavaAPIforXMLMessaging), JAXR(JavaAPIforXMLRegistries),或者JWSDP(JavaWebServicesDeveloperPack)。

    15.你需要学习一门轻量级应用程序框架,例如Spring,PicoContainer,Avalon,以及它们的IoC/DI风格(setter,constructor,interfaceinjection)。

    16. 你需要熟悉不同的J2EE技术,例如JNDI(JavaNamingandDirectoryInterface),JMS (JavaMessageService),JTA/JTS(JavaTransactionAPI/JavaTransactionService), JMX (JavaManagementeXtensions),以及JavaMail。

    17.你需要学习企业级 JavaBeans(EJB)以及它们的不同组件模式:Stateless/StatefulSessionBeans,EntityBeans(包含 Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL),或者 Message-DrivenBeans(MDB)。

    18.你需要学习如何管理与配置一个J2EE应用程序服务器,如WebLogic,JBoss等,并且利用它的附加服务,例如簇类,连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。

    19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩

    写为AOP),以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。

    20. 你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing),Quartz (scheduling),JGroups(networkgroupcommunication),JCache (distributedcaching), Lucene(full-textsearch),JakartaCommons等等。

    21.如果你将要对接或者正和旧的系统或者本地平台,你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。

    22.你需要熟悉JINI技术以及与它相关的分布式系统,比如掌握CROBA。

    23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs),例如Portlets(168),JOLAP(69),DataMiningAPI(73),等等。

    24.你应该熟练掌握一种JAVAIDE例如sunOne,netBeans,IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了:)

    25.JAVA(精确的说是有些配置)是冗长的,它需要很多的人工代码(例如EJB),所以你需要熟悉代码生成工具,例如XDoclet。

    26.你需要熟悉一种单元测试体系(JNunit),并且学习不同的生成、部署工具(Ant,Maven)。

    27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。

    28.你需要能够深入了解加熟练操作和配置不同的操作系统,比如GNU/linux,sunsolaris,macOS等,做为跨平台软件的开发者。

    29.你还需要紧跟java发展的步伐,比如现在可以深入的学习javaME,以及各种java新规范,技术的运用,如新起的web富客户端技术。

    30.你必需要对opensource有所了解,因为至少java的很多技术直接是靠开源来驱动发展的,如java3D技术。(BlogJava-Topquan's Blog)

    原文出自点击打开链接

    当然学习了基础知识,也少不了了解一些数据结构与算法

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

    为了便于描述,文中涉及到的代码部分都是用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 技术书籍大全本文档目前已收录 277本 Java相关领域经典技术书籍,从初级开发者到资深架构师,涵盖 Java 从业者的各个阶段,并持续更新。涵盖领域:Java入门书籍,Java基础及进阶书籍,框架与中间件,架构设计,设计模式,数学与算法,JVM周边语言,项目管理&领导力&流程,职业素养与个人成长

     

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

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

    阿里云学生机1年114元限时活动(24岁以下都可以购买)https://promotion.aliyun.com/ntms/act/campus2018.html?userCode=a6violqw阿里云1888元红包:https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=a6violqw

    展开全文
  • 人生就是一个不断学习的过程

    万次阅读 2018-03-17 14:31:16
    人如果能主动去接受这种变化,并视这样的变化是积极的,那人能做且必须做的就是——不断学习学习,可以说是人想改变命运、实现自由的最好方式。一个开放的人,也注定是一个肯学习、愿意接受新鲜事物的人。这个世界...

    在这个不断变化的世界里,如果把人看成是静态的,那就有些太落伍了。其实,人随着时间的推移,也是在不断变化的。尽管有时候这种变化是被动的,但是这也是人为适应环境所作出的本能反应。


    人如果能主动去接受这种变化,并视这样的变化是积极的,那人能做且必须做的就是——不断学习。学习,可以说是人想改变命运、实现自由的最好方式。一个开放的人,也注定是一个肯学习、愿意接受新鲜事物的人。

    这个世界没有天生的王者,都是需要一个从无到有、从有到多,从多到优的过程,没有人能够跨越。而这个过程,也正是人在学习中不断积累和选择的过程。人从一张白纸,经过努力,升华成一幅可以被世人传颂的名画,中间需要经历的就是在学习中改进的过程。


    那些把自己封闭起来的人,就像一潭死水一样,永远没有“新鲜水源”来丰富自己,到最后只能是在自我满足中抑郁而终。人的不上进,也决定了命运不会有太大的改变。总是被这个世界看似美好的事物所诱惑,今天馋嘴了,约上三五好友胡吃海喝一回;明天想看电视剧了,就坐在电脑前熬了一个通宵;后天想玩游戏了,然后就不管不顾的把所有业余时间耗费在电子游戏中。

    不管是没有规律的消遣,还是找到了喜欢的嗜好一直娱乐下去,都不能掩饰人贪玩儿的心。貌似很快乐的活着,有吃有喝、有玩有乐,但是终究是在用自己人生的宝贵时间做了“成全别人”的事,除了获得短暂的欢愉外,对自己人生的进步没有一丁点儿的好处。


    古语有云:活到老,学到老。这个世界有太多可以丰富自己的知识,是需要学习才可以掌握的。能力和修养的养成也是需要知识的不断积累和眼界的不断开阔。所以说,没有什么比学习更能提升一个人的价值了,也没有什么能够比学习更能让人获得人生的成长和进步了。

    人生就是一个不断学习的过程,通过学习来充实自己的头脑,让自己更有智慧的生活下去,去探索那未知领域的神秘,去享受成长带来的快乐和惬意。不要再回忆了,人生的全部意义其实都在现在和将来,而通过现在的努力学习,正是通向美好未来、实现人生自我实现的必由之路。

    展开全文
  • 自学网站大全(值得收藏)

    千次阅读 2019-01-08 22:49:13
    自学,顾名思义就是自我学习。在这个信息爆炸的时代里,网络上有很多学习资源的。以下就是学习网站的介绍: 目录 综合类 中国大学MOOC(慕课)_国家精品课程在线学习平台 https://www.icourse163.org/ MOOC中国 - ...
  • 自学时代的学习死循环 在市面上能看到很多‘零基础’这类关键词,然而不管是文字教程,还是视频教程,都是直接开撸,缺乏定制服务。 比如,他不会问你的实际情况,然后根据实际情况来给予关键性的安排,不管是免费,...
  • 学习R》

    2019-01-08 08:06:35
    学习R》 基本信息 原书名:Learning R 原出版社: O'Reilly Media 作者: (美)Richard Cotton  译者: 刘军 丛书名: 图灵程序设计丛书 出版社:人民邮电出版社 ISBN:9787115351708 上架时间:2014-4-...
  • 学习

    2020-11-11 19:36:11
    问这个问题的人其实知道学是最好的,但是他们又不想学,所以才会问要不要学习技术,这反映了他内心的纠结,知道要学习的不会问这个问题,感觉不要学习的也不会问这个问题,只有纠结的人才会问这个问题。那产品经理要...
  • 新手学黑客基础知识(一)

    千次阅读 2019-04-13 17:39:53
    端口是计算机与外界通信交流的出口,而IP地址相当于网络主机的一个虚拟地址,如果黑客想要攻击某个网络主机。 首先要确定该目标的域名或IP,然后通过端口来攻击该主机; IP是Internet protocol的缩写,网络互联...
  • 推荐一套适合运维的书籍

    万次阅读 2017-11-08 15:36:03
    linux基础入门 全面的是《鸟哥的Linux私房菜》 精简的当然是我的《跟阿铭学Linux》 shell 我看过最好的 《shell编程艺术》 综合运维 《高性能Linux服务器构建实战》 lamp/lnmp ...安全
  • Java学习路线(完整详细版)超详细

    万次阅读 多人点赞 2019-05-14 10:56:47
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • 从入门到精通,Java学习路线导航

    万次阅读 多人点赞 2019-09-09 11:00:25
    当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。 基础阶段 首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Ora...
  • Java 学习路线

    万次阅读 多人点赞 2018-01-06 13:21:35
    对于入门java将近两年的时间...结合多种书籍(其中个人觉得“疯狂java讲义”这本书写的特别好,所以大部分是根据这本书整理的),特别整理出了下面的java学习路线,跟大家分享,觉得好的话,希望大家多多指点,下面进入
  • 2019全新Java学习路线图-分享

    万次阅读 多人点赞 2019-03-20 18:14:46
    2019年最新Java学习路线图,路线图的宗旨就是分享,专业,便利,让喜爱Java的人,都能平等的学习。从今天起不要再找借口,不要再说想学Java却没有资源,赶快行动起来,Java等你来探索,高薪距你只差一步! java...
  • Java入门学习路线目录索引(持续更新中)

    万次阅读 多人点赞 2019-10-08 16:33:09
    一、Java基础 Java基础-继承 Java基础-抽象 Java基础-接口 Java基础-多态 Java基础-重写 Java基础-匿名对象 Java基础-内部类 Java基础-final、static关键字 Java基础-ArrayList集合 ...
  • Java学习路线

    千次阅读 2016-08-24 00:48:47
    Java学习路线 关于Java的学习路线,我是买到一本书,名字叫《疯狂Java讲义》,感觉作者写的非常好,讲的东西比以前看到的书要深入一点,但又讲的很清晰,看到书的开头有一份关于Java的学习路线图,现在分享到...
  • 传智播客于2020年升级了Java学习线路图,硬核升级,免费放送! 学完你就是中级程序员,能更快一步找到工作! 一、Java基础 JavaSE基础是Java中级程序员的起点,是帮助你从小白到懂得编程的必经之路。 在Java...
  • java学习路线图(2018年最新版)

    万次阅读 多人点赞 2018-04-10 12:05:40
    java学习路线图(2018年最新版)最近有些网友问我如何自学 Java 后端,还有些是想从别的方向想转过来,但都不太了解 Java 后端究竟需要学什么,究竟要从哪里学起,哪些是主流的 Java 后端技术等等,导致想学,但又很...
  • Java学习路线图(如何快速学Java)

    万次阅读 多人点赞 2018-11-21 15:12:30
    可能总结的不是很详细,但给出了一个大概的学习路线。希望对大家有帮助哈~ 如何快速学Java 这里我以Java EE(Jakarta EE)/Java Web的经验来说哦。(都把你们看做是零基础入门的了) 学习Java EE(Jakarta EE)总体来...
  • 2020Java学习路线(珍藏版)

    万次阅读 多人点赞 2020-02-03 12:09:08
    但是也是学习过并且之后肯定还要继续学习Java的,原因就是5G时代,万物互联,更多的终端会使用安卓系统,随之而来的Java开发必然是会越来越火爆,所以学习Java是必要且必须的,下边就是总结了下Java的学习路线 ...
  • 从入门到精通,Java学习路线导航(附学习资源)

    万次阅读 多人点赞 2019-09-16 17:34:06
    当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。 基础阶段 首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Ora...
  • 推荐10个堪称神器的学习网站

    万次阅读 多人点赞 2020-01-07 10:27:26
    每天都会收到很多读者的私信,问我:“二哥,有什么推荐的学习网站吗?最近很浮躁,手头的一些网站都看烦了,想看看二哥这里有什么新鲜货。” 今天一早做了个恶梦,梦到被老板辞退了。虽然说在我们公司,只有我辞退...
  • java学习路线

    千次阅读 2018-07-25 21:24:13
    基础阶段: ... 1、java基础,也被称为java SE。 2、JUnit单元测试。 3、mysql数据库。 4、oracle数据库。 5、jdbc,ODBC。 6、XML技术。   网络相 1、HTML + HTML5技术。 2、CSS +...
  • 推荐JAVA学习路线

    千次阅读 2016-12-22 13:26:49
    一直以来,都想写一篇介绍Java学习路线的博客。为什么有这个想法?原因有两个,其一:笔者从大三开始学习JAVA,至今也3年了。由于身边缺乏老司机带路,只能自己一步步探索,深知没人指路的痛苦。所以看过很多垃圾的...
  • Java学习路线图—精心整理

    千次阅读 多人点赞 2019-02-23 11:42:04
    到现在为止还在云端飘着,对于Java小白来说就像天书一般,Java大神看了以后感觉云山雾绕不知道讲什么东西,作为Java业界标杆深意为耻,于是从实际教学出发,呕心沥血整理出来Java学习路线图希望大家点波关注,你的...
  • Java学习路线

    万次阅读 多人点赞 2017-03-25 20:34:16
    一、Java学习路线图       二、Java学习路线图——视频篇   六大阶段 学完后目标 知识点 配套免费资源(视频+笔 记+源码+模板) 密码  第一阶段 Java基础 ...
  • JAVA学习路线图 【黑马版】

    千次阅读 2018-12-12 17:48:41
    使用请点赞和关注,后期还有更多内容分享和...具体内容请点击右侧链接→→: - [ ]JAVA学习路线图【黑马版】 手机版: 六大阶段 学完后目标 知识点 配套免费资源(视频+笔 记+源码+模板) ...
  • 一份Java学习路线

    千次阅读 2014-07-26 19:17:21
    Java学习路线
  • 之前写过很多次关于Java学习指南、Java技术路线图的文章。但是总还是有小伙伴来问我,Java怎么学,项目怎么做,资源怎么找,真是让人头秃。 于是这次黄小斜决定来一...一、Java学习路线图 1 计算机基础 2Java编程...
  • JAVA学习路线(最全)

    万次阅读 多人点赞 2018-09-17 22:37:41
    JAVA学习路线

空空如也

1 2 3 4 5 ... 20
收藏数 6,191,537
精华内容 2,476,614
关键字:

学习