路线_路线规划 - CSDN
精华内容
参与话题
  • 说实话,对于学习路线这种文章我一般是不写的,大家看我的文章也知道,我是很少写建议别人怎么样怎么样的文章,更多的是,写自己的真实经历,然后供大家去参考,这样子,我内心也比较踏实,也不怕误导他人。...

    说实话,对于学习路线这种文章我一般是不写的,大家看我的文章也知道,我是很少写建议别人怎么样怎么样的文章,更多的是,写自己的真实经历,然后供大家去参考,这样子,我内心也比较踏实,也不怕误导他人。

    但是,最近好多人问我学习路线,而且很多大一大二的,说自己很迷茫,看到我那篇 普普通通,我的三年大学 之后很受激励,觉得自己也能行,(是的,别太浪,你一定能行)希望我能给他个学习路线,说实话,几乎每天都有问这种问题的,鉴于此,我就来写一篇适合普通大众的学习路线,就从大一入学那一刻开始入门说起,虽然不一定适合你,但或许能给没有明确目标的人带来一些学习的方向,那么这篇文章,我就觉得值了。

    **注意:**这篇文章不是让你成为大神的,学完也不是多厉害,而是,给处于大学迷茫、不知道学啥的你,一个学习的方向,无论你是否是科班。不过我相信,当你学完了这些,你应该会有自己的学习方向了。

    一、选择一门语言入门编程的世界

    1、入门语言的选择

    学习编程的第一件事,我觉得就是选择一门语言,不过能选择的语言实在是太多了,不知道如何选择的,可以选如下一门比较热门,也是 90% 人的选择的语言入门。分别是 C 语言PythonJava

    那应该选哪一门呢?说实话,我觉得选哪一门都问题不大,因为等你成功入门之后,你大概率还会学习其他语言,那么我这里建议跟着学校的课程来选,因为大一基本也都会开设一门编程语言,我们学习当时开设的是 C 语言

    那么问题来了,根据读者的反馈,其实还要部分学校大一是没有开设这些语言的,而且学那些网页设计这类的语言,那该咋办?答是我这里建议你仍然选择一门语言来学习,由于你不是跟着学校的课程走的,那么我这里建议你选择 C 语言

    说实话,我觉得不论你是学哪一门语言的,如果有时间,都应该了解、学习下 C 语言,我觉得,你只要会了 C 语言,那么你入门其他语言分分钟,但会了其他语言,入门 C 语言可能会被虐。学习 C 语言,真的让人学习到挺多知识的,所以你不知道学习哪一门语言,这里我建议学习 C 吧,以后参加打ACM之类的比赛了,也一般用 C/C++。

    2、书籍以及视频的介绍

    这一个星期,我至少被 15 个人问过学习 C 语言要用哪一本呀?用什么编译器啊?反正我是被问哭了,不过当年我也有这样的疑问,所以就都耐心回答了。所以这里介绍下一些书籍和视频,虽然不是最好的,但我觉得还可以。这里我就以 C/Python/Java 为例子来介绍。

    后面我也会出一篇汇总各类工具的文章。现在已经收集了几十个常用开发工具了,不过可没有提供破解教材哈,百度一搜一大堆破解教程或者序列码。估计在过一个星期,我就会整理出来的了

    (1)、C语言

    书籍推荐:书籍可以看《C语言程序设计》,谭浩强写的,适合入门学习,也是我第一本看的书。进阶可以看《C 和指针》。

    视频推荐:可以看郝斌录制的视频,在 b 站搜索 C 语言就出来了,叫做《郝斌 C 语言自学教程》。说实话,对于新手,我觉得看视频还是比较不错的,可以少掉很多坑,不然你搞编译环境都搞死。

    这里工具我就不介绍了,一般书籍和视频都会手把手交你们用哪个编译器。我当时用的是 codeblocksvs6

    (2)Java

    书籍推荐:《Java核心卷1》,这个算是入门书籍吧,入门书籍我看的不多,暂时介绍这一本,因为没看过的一般我不介绍,大家可以去网上搜索。

    视频推荐:这里推荐 【尚学堂】Java300集,作者是 高琪 录制的,b 站搜索就可以了。讲的是真的好,入门的话,感觉看前面 100 集就可以了。进阶可以看《Java编程思想》,这本书也很好,解决了我很多疑惑。、

    Java 编译器推荐用 IntelliJ IDEA,自己百度去搜索。

    (3)Python

    书籍推荐:这里推荐《Python编程:从入门到实践》。

    视频推荐:我看过小甲鱼是视频,还不错,如果大家要看小甲鱼的视频的话,书籍可以顺便来他的配套书籍吧。视频叫《[小甲鱼]零基础入门学习Python》,b 站搜索就可以了。书籍也是也是《[小甲鱼]零基础入门学习Python》。

    开发工具我当时是用 pycharm

    问题来了,很多人问,应该掌握到哪个程度才算可以呢?

    说实话,我也不大清楚,,我觉得书中说的,90% 理解就可以了,注意,是理解,具体怎么写,忘记了问题不大。总之,当然是学的深点比较好了。

    文章首发于公众号『苦逼的码农』,更多经常文章欢迎搜索关注,已有150多篇原创,公众号回复『电子书』送你一份精选电子书

    二、数据结构与算法

    大学第一学期你入门了某种语言之后,就要开始学习数据结构与算法L。当然,不一定是第一学期,对于非科班的也一样,也是建议这个学习顺序。当然,你有自己的目标,完全可以按照自己的来。

    我的文章是主写数据结构与算法的,我秋招也是靠着这个优势拿到 offer 的,所以我认为数据结构与算法是非常非常重要的,可能你会听到工作都基本没用到这些知识啊,或者库函数都帮我们封装好了啊,我们干嘛要学。

    如果你这样想的,那你就错了。对于想要找工作的来说,这方面的知识是必考的,所以你得学;对于已经工作的来说,这方面的知识,可以让你学习到很多设计思想,所谓 数据结构 + 算法 = 程序,而且你学了这个,你会发现学习其他知识,上手的特别快。综上,数据结构与算法必学。

    好吧,上面扯了这么多,就是告诉你,数据结构与算法的重要性,好了,下面我介绍下入门数据结构必学的有哪些,不过你跟着书本的学习顺序来就是了。

    1、基础数据结构的学习

    1、时间复杂度、空间复杂度

    2、链表、队列、栈

    3、树(二叉树,查找二叉树、AVL树,红黑树等)

    4、图(图有好多种算法,深度/广度搜索,最短路径、最小生存树等)

    如果你是科班的,那么这些我觉得你大一第二学期都学完是最好的了,没学完也问题不大,有些人可能是先教《离散数学》这本课,为数据结构与算法做铺垫。

    书籍推荐:《大话数据结构》、《数据结构与算法分析:C语言描述版》,学哪一本?都可以,问题不大,我当时学的是第二本。大家记得根据自己的语言去学,我上面列举的,都是用 c 语言来实现的。

    视频:我只看过《小甲鱼的数据结构与算法》视频,你们自己看着办吧。

    2、算法的学习

    在大一大二,真心建议你们把算法基本功打好,后面就真的没啥时间刷题之类的了,因为无论你以后要学习哪个方向的,算法都是实用的,会一些算法,说话也都自信了。算法的学习,刷题是必须的了,但不建议盲目刷题,而是先学习一些算法思想,在找对应的题刷,要学的主要有:

    1、十大排序算法

    2、递归、贪心、回溯、动态规划、枚举等

    推荐书籍:《阿哈算法》、《算法设计与分析基础》适合入门;《算法第四版》、《算法导论》、《编程之美》适合进阶

    视频:这种还是挺建议看书,我没看过视频,,这里就不介绍了。

    具体可以看我之前的文章:程序员必须掌握的算法有哪些?谈谈这这几年学过的算法

    3、保持算法的学习

    算法的学习,真的是靠积累的,而刷题是必须的。而且学校都会举办一些比赛,这里还是比较建议大家去参见的,这样也能让你更加有激情着去学习。当然,每年都会有很多 ACM 编程大赛,要不要参加呢?这个看你了,也不是说参加就一定好,看你自己吧,具体可以参考我之前一篇文章说的: 普普通通,我的三年大学

    大家可以在 leetcode 长期保持刷题,一天一两道,或者一个星期三四道都行。

    文章首发于公众号『帅地玩编程』,更多经常文章欢迎搜索关注,已有150多篇原创,公众号回复『电子书』送你一份精选电子书

    三、选择一门语言深入学习

    刚才我选了选择一门语言来入门,之后你可能还会学习其他语言。我当时 C 语言入门,后面深入学习 Java。

    你可以学习过很多种语言,但你一定要有一门拿的出手的语言,所以把上面的学习了之后,这个时候你可能是大二,最多大三,那你就应该选择一门语言来深入学习了,一般可选的有四门:C++JavaPythonGo,如果你想从事后端开发岗位 ,那么 C++,Java和Go相信是大多数人的选择,其中我觉得选择 Java 的人数是最多的。Go 是最近才火起的语言,也是个不错的选择。

    那么问题来了,该选哪一门呢?入门你以后想从事游戏之类的开发,那么建议选择 C++,或者你以后比较想去腾讯字节跳动这些的,可能选择 C++ 会好一点。如果你想从事Web网站开发的,或者未来想去阿里巴巴、美团这些的,那么 Java 会好点,Go 和 Python呢?其实我也不是很懂,哈哈哈哈。不过我听说,对于一些不是很大型的网站之类的,都会用 Python 或者 Go 之类的快速开发。

    大家如果是面向公司编程的,可以去看看哪些公司的技术栈,来选。当然,无论你选哪一门,只要你有实力,哪个公司都会收你,只是有可能到时候要转语言,我现在好像是需要从 Java 转向 Go,不过语言只是一门工具,把基础共通的知识学好,转语言都问题不大。

    四、以Java为主的后端开发学习路线

    由于我是深入学习 Java 的,那我就介绍下 Java 的学习以及书籍的推荐吧,其他语言我觉得也类似。我大二开始学习 Java 的,还是看了挺多知识。入门的就不介绍了,上面介绍过。下面说的基本是深入学习必须理解的了。

    1、Java进阶必学

    集合模块:主要是包括各种常用集合:例如 Set(包括HashSet,TreeSet), Map(包括 HashMap,HashTable),List(包括ArrayList,LinkedList)等等,上面列举的都得学习它的源码

    多线程:synchronize,volatile,线程池,并发包(如lock等等),太多了,学了你们自然知道,我也不说的太详细了。推荐看《Java 并发编程艺术》+《Java编发编程实战》。

    各种文件流:file,inputStream,outputStream等等,反正就是各种文件流,看书时你们自然会看到,不详细介绍。

    虚拟机:虚拟机是必须学习的了,重点是GC部分,推荐看《深入理解Java虚拟机:JVM 高级特性与最佳实践》,一本就差不多够了,多看四五遍就行了。

    其他:还有很多,如反射,注解,异常等。

    2、JavaWeb 入门

    学了上面那么多,啥程序、网站也没写出来,有点难受?没事,这个时候,我们就要开始撸网站了,如果是以 Java 作为开发语言的,那么 JavaWeb 是必须学的了。这个时候你可以入门学习下这些(注意,不用深入,快速找个视频入门就可以了)

    1、mysql、html+css+js 、 tomcat、xml等。推荐看视频,自己去搜索 JavaWeb的视频,那么哪里不会补哪里,这些知识,几个小时就可以入门一门的了。

    2、servlet+jsp 系列。

    不建议直接学习框架,也是应该先学习 servlet,这些底层才是最重要滴。

    3、三大框架

    Servlet 写太麻烦了,只有认真学过 servlet 的人才能吹框架的好处,所以先学 servlet 在来学习框架,主要有三大框架:Spring + SpringMVC + Mybatis。

    其实 SpringMVC 也是属于 Spring 吧,MVC 只是一种思想,这里学习顺序是先建议学习 Spring,直接看视频入门学习就可以了,后面在买书。视频还是那句话,B 站搜索。黑马的讲的不错,我当时也是看黑马的。

    3、中间件的学习

    必须中间件:redis,其他我也没学过,这学过这一门,Redis 感觉人人都得学啊,推荐书籍《Redis 设计与实现》、《Redis开发与运维》。我先看后者,感觉后者适合入门,然后在看前者的。

    由于我这篇文章是给一个大致的学习方向的,我就不说的太详细了,不然得单独来一篇《Java学习路线》了。

    对于 Java 的学习,我觉得你会了上面这些,我觉得可以去尝试找实习了,应该也能找的到,大二大三去体验一波学习还是挺好的。

    文章首发于公众号『帅地玩编程』,更多经常文章欢迎搜索关注,已有150多篇原创,公众号回复『电子书』送你一份精选电子书

    五、计算机基础的学习

    看过我文章的都知道,我一直强大计算机基础的重要性,所以这里必须列举要学的有哪些。刚才说了选择一门语言深入,你在深入学习的过程中,肯定也在学习学校开设的专业课,包括:计算机网络 + 操作系统 + 数据库 + 汇编 + 计算机组成原理 + 编译原理 等等。

    而这些,我认为是非常重要的,对于秋招的同学来说,只要你会这些,就算你是深入学习 Java的,然后你去应聘 C++ 岗,我觉得也问题不大,你和面试官说我不会 C++ 就可以了,大不了到时候转岗。我虽然是 Java 技术栈的,但是我面的公司,都不是 Java 技术栈的,例如 小米,Shopee,字节跳动,腾讯等。但是,这些都问题不大,你只要会这些基础 + 算法,而且,在秋招,特别是对于一些大公司,关于语言的,其实问的也不是很多,基础问的特别多,所以你会基础,面试会占很多优势。下面按照学习的优先级,给这些课程排个序。

    其实给他们排优先级是不大好的,这样给他们排,感觉容易被大佬喷,不过没办法,对于小白来说,我还是想排以下顺序

    1、计算机网络 + 操作系统

    2、数据库 + 计算机组成原理(数据库相应你们可能已经先学过 MySQL 了)

    3、汇编 + 编译原理

    不过,如果你们还是在校的大一大二,那么可以根据你们课程的学习顺序来,但是,我建议有时间的可以提前学,不一定要等到学校教了才学,反正大部分老师讲的很一般,但时候你学过的话,可以当做复习,或者学其他。

    书籍推荐

    《计算机网络自顶向下》、《图解 http》、《深入理解计算机操作系统》、《汇编语言》(王爽写的)。具体要掌握到哪个程度可以看我之前的文章了。

    【吐血整理】那些让你起飞的计算机基础知识:学什么,怎么学?

    之前写过很多文章,所以这里不写的太具体了,具体的可以看我之前写过的文章。

    六、总结

    我觉得对于大学四年来学,上面这些是最核心的,也是必须学的。但是仅仅是上面这些还是不够的,上面的这些一两年就可以学完的。所以你还有很多其他时间,那么你可以学一些自己感兴趣的,多折腾,多豆鼓,而我上面学的,希望你都学。你也可以看我大学学过的一些核心基础知识:

    我的经历/成长/经验

    前两年都在折腾,特别是第一年,但是,我始终一直学习那些比较核心的课程。再次强调,这篇文章不是让你成为大神的,学完也不是多厉害,而是,给处于大学迷茫、不知道学啥的你,一个方向,无论你是否是科班,如标题所说,普普/大众。不过我相信,当你学完了这些,你应该会有自己的学习方向了。

    最后,是希望各位还在校的学生,大一可以好好浪,但也要保持应有的学习时间,之后,就好好学习吧。不管你是名校还是非名校,我觉得你在只要这几年认真学,进大公司的几率,真的非常大,这绝对不是鸡汤。

    上面设计到的工具以及书籍,我都提供了,可以在我的公众号『苦逼的码农』,回复『福利』即可获取。

    另外,帅地把公众号的精华文章整理成了一本电子书,共 630页!目录如下

    在这里插入图片描述

    现在免费送给大家,在我的公众号帅地玩编程回复程序员内功修炼即可获取。

    推荐阅读

    大学四年,小白一路走来,分享一波我是如何学习、提高自己的算法
    大学四年自学走来,这些私藏的实用工具/学习网站我贡献出来了

    最后,给大家推荐一个 github,在这个github,有很多不错的电子书,并且分类整理了,或许你需要的可以在这里找到哦。点击前往Github

    有收获?希望老铁们来个三连击,给更多的人看到这篇文章

    1、给俺点个赞呗,可以让更多的人看到这篇文章,顺便激励下我,嘻嘻。

    2、老铁们,关注我的原创微信公众号「帅地玩编程」,专注于写算法 + 计算机基础知识(计算机网络+ 操作系统+数据库+Linux)。

    保存让你看完有所收获,不信你打我。。了。

    展开全文
  • 技术路线和管理路线

    千次阅读 2016-11-25 14:41:24
    技术路线和管理路线始终是每个程序员纠结的问题,也是各大论坛经常被辩论的问题。 然而一个有趣的现象是,在现实生活中,人们多愿意承认自己不精通某项技术,却很少有人愿意承认自己不能做管理。技术方面有问题多...

    技术路线和管理路线始终是每个程序员纠结的问题,也是各大论坛经常被辩论的问题。

    然而一个有趣的现象是,在现实生活中,人们多愿意承认自己不精通某项技术,却很少有人愿意承认自己不能做管理。技术方面有问题多能够校正自我,而管理方面有了问题却总认为是对方的错,总之领导怨员工,员工怨领导,闹得不可开交。

    在中国传统的官本位的思想中,不能不说管理路线占了绝对性的优势,尤其是在稳定的外企,管好管坏极难衡量的情况下。

    做技术苦啊,相比于管理路线,有如下的弱势:

    首先,IT业的技术变化太快,弄的技术人员疲于奔命。年轻人可以每天晚上几个小时的看新技术的书籍,而年纪偏大的你上有老下有小,做饭,洗衣,陪老婆,照顾老人小孩,逛超市,每天能有一个小时的学习时间十分不易了。如果是你已经很熟悉的领域,你自然可以用较少的时间就能达到年轻人较长时间看完的东西(理想状态下),然而公司的项目所用的技术方向可不是随你心愿的。如果你是一个Java高手,碰巧公司买的一个第三方的库是用C++写的,需要对其进行封装,如此艰巨的任务,工程师中你的薪水最高,你不入地狱谁入地狱啊。你总不能说:我只负责Java的部分,C++的别来找我吧。

    也许你经常听领导说:“编程主要靠思想,语言和平台无所谓”。然而如果你跳槽的时候,却经常听到面试官这样说:“好像你没有太多这方面的经验嘛”,你却不能以我很有编程的思想来回答。此矛盾之处着实使人困惑许久。技术路线还是分很多的方向的,正如武林有很多的门派。语言,操作系统等属于内功,然而只有内功却不足以行走江湖,必须还要有一定的套路,如Debug tool,profile tool,出现问题后的分析办法,编程时候的各种习惯,一些非常管用的技巧等,都是因语言和平台不同而不同。虽然对于初级的工程师来说,这些不是很重要,然而工作三年五年之后,是否能够熟练运用这些套路来准确的定位问题和解决问题,却是区别你是初级工程师,还是高级工程师的一个标志。当然当你在上升到项目经理的时候,又可以只谈编程思想的时候了。一句实话,一个要饭的不要因为听富人说吃青菜养生就见肉也不吃。周易中,同样在乾卦,同样元亨利贞,初九则应潜龙勿用,九五则可飞龙在天了,不同的位,同样的话,意义不同。

    其次,没有优先知情权。当任务到来的时候,美国那面的老大一般是先发邮件给项目经理的。项目经理会进行一系列统筹考虑后再选择发给那些人。作为同项目经理同一级别的技术人员,是否提前或同时,甚至晚于与其他技术人员收到邮件,取决于你技术外的能力(你的reputation, 你和项目经理的关系等)。上面的文章也说过了,在外企,邮件是一门很大的学问,也决定了从属关系。把本来你擅长的任务先发邮件给他人,从而变成了他人的任务,也不是不可能的事情。当然当美国老板过来的时候,陪同和展示成果的,也多是管理人员的事情,虽然里面全是你的心血。

    其三,没有资源支配权。项目经理一般可以支配多种资源的,如买硬件,Team building的经费,培训的机会等。但是相同级别的技术人员却没有。

    其四,没有绩效评定权。任何员工的绩效都是基本由其report得顶头上司起决定作用的。相同级别的技术人员可能会有一些评价做参考,但是你不会知道和你平级甚至下级的薪水和绩效。

    最后,没有人事任免权。一个员工是否能够进某个项目组,也基本是项目经理起决定作用的。一般的外企都会有推荐的制度,而通常会发现一般状况下(被推荐人不是明显的差),管理路线的人推荐到其他组的人比较容易录取(同组推荐没有推荐费啊)。大家总要多少照顾个面子嘛,万一哪天要向对方的组推荐自己的人呢?

    基于上述几点,经济基础决定上层建筑,你也就怪不得基层员工对你仅仅是因为技术而产生的尊敬,而对manager则是因为既威且信而产生的敬畏了。也许其实是你的建议是正确的,大家却都同意按照manager的来做;也许你一把年纪还要和年轻人因一个小小的设计争得面红耳赤,而他在manager面前总是yes, ok, i am 100% agree;也许你因一项新技术不很精通而被新人鄙视;也许就没有也许。

    当前的中国是浮躁的,以上的原因造成大批大批的人涌入管理路线的独木桥,也造成了一些不合格的管理者走上了管理岗位。也许有这样的现象,明明在国外仅够做高级工程师的在中国做了Team lead,却在和普通工程师争功劳;在国外仅够做Team lead的,在中国做了manager,却不能很好的领导多层化的组织结构。

    这种情况是悲剧的,却不仅仅在软件业,包括高校(系主任更容易拿项目),包括医院(院长更容易申请经费),包括研究所。

    这也是为什么总有转管理,转售前,转销售,甚至转其他行业的论调的原因了。

    其实技术路线也有它的好处,你可以埋头认认真真研究自己感兴趣的技术,两耳不闻窗外事。而由于一直没有放下技术,跳槽也相对容易的多,毕竟在中国,号称会管理一个团队的一抓一大把,而真的很有经验的技术人员却不是很多。

    作为软件工程师,我们应该找到一条属于我们自己的路。



    让我们来看上述三条曲线,是随着时间的推移,收入的变化。

    很不幸,技术人员的收入曲线基本成C曲线状,也即刚开始收人较高,也能较快增加,后面随着时间的推移,收人增长略显平缓。

    这主要是技术更新迅速的结果,设想从工作开始,就接触某项技术和某项框架,逐渐的掌握直到精通,到了十年的时候,正是规模效应开始体现的时候,可惜,此框架已经不流行了,已经淘汰了,行业中已经使用另一种语言或者框架了。也许你会说,以我十年的经验,对于新的框架也会更好的掌握。是的,我承认,然而由于框架的更新,你所谓的更好的程度,相对于刚接触新框架两三年的人来讲,公司不足以付给你另外7年经验所应给的薪水,毕竟,你也不是很熟。所以C曲线的形态显示出来了,由于技术的更新,你所得到的薪水增长远远低于你的经验所应该带来的薪水增长。

    原因就在于:不易积累。

    积累,尤其是对我们普通人来讲,是非常重要的,是最后成功的重要途径。当我们看《大家》栏目的时候,其实我们可以看出,这些成功人士基本上分两种,一种是天才,很年轻就能够取得很伟大的成就,当然我们不可能是这种人。另一种是泰斗,即靠多年的积累而取得的最后的成就,比如2008年获中国国家最高科学技术奖的吴征镒院士,被称为中国植物的“活词典”。虽然我们不期望能够成为大家,但是他们的精神和经验却能给我们启迪。像植物,或者是医生,是相对比较容易积累的行业,吴老可以在90高龄,如数家珍的说着自己年轻的时候积累下来的各种植物的知识。而工作十年的软件工程师,却难以启齿十年前的语言和框架,那已经out了。

    这也是为什么很多销售的同学最后薪水会越做增长越快的原因。比如他们培养一个客户能得来收入1000元,随着客户的不断积累,手中有20个客户就有20000元。而软件工程师,看了10本fortran的书,得到一份1000元的工作,后来又读了10本Java的书,再加上经验,可能得到1500元的工作。

    所以,我们也要学会积累,争取从C曲线变成B曲线,使得我们积累的经验能够带来相应的薪水。所以本人窃以为(仅供参考,自己的路还是要自己走),有至于从事技术的软件工程师,尽量选择一些可以积累,相对稳定的方向,如Linxu内核,windows driver等,相信一个做了10年的Linux kernel工程师,绝不是一个可以读几本书就能够赶上的人。而很多流行的上层框架,如SSH等,如果你熟悉了它们的每一行代码,当Web开发开始使用其他框架的时候,岂不悲剧。(没别的以上,也希望SSH青春常在)

    然而如果在事业的后期,想成就A曲线,就不是容易的事了。

    当你想以较少的经验积累获得较高的收入,则必须要有放大器的作用,这种放大器我们经常能够接触的到,即营销。

    很多研发人员十分鄙视管理和销售,营销。然而我认为,我们可以不从事管理和销售工作,然而我们最好了解一些人与人之间的交流规则,而非天天埋头于人与机器的交流规则。

    可以举几个例子,比如我们卖烤鸭,当我们做的不好吃的时候(技术不好),一只烤鸭卖5块钱,慢慢的我们有经验了,能烤出好吃的烤鸭了,也就能够卖10块钱,再加上好吃的调料,良好的环境,最多也就一只20元,到头了。而全聚德的烤鸭198元一只。

    再比如,普通包子铺的包子5毛一个,你如果能够做的好吃1块一个,也就差不多了,而天津狗不理包子一个10多块,20多块。

    这就是营销的作用,这就是品牌的力量。

    也就可以理解为什么李开复要给大学生写信了,从而创新工厂即便比原来薪水少,即便每周工作60小时,也有大批程序员欣然而往。也就可以理解各个公司的老总总是不定时的出现在电视上,不断重复着自己成功的故事。

    程序员不应该老待在自己的圈子里面,埋头做着自己的事情,而是要想办法扩大自己的影响力,多交朋友,多参加技术会议,多参加各种聚会。

    有很多人抱怨,刚毕业就要工作经验,诸葛亮没有工作经验,不也成功就业了吗?《三国演义》中是这样描述诸葛亮的"或驾小舟游于江湖之中,或访僧道于山岭之上,或寻朋友于村落之间,或乐琴棋于洞府之内,往来莫测,不知去所"。这那是隐居啊,不出茅庐而名声在外,工作也是至交徐庶鼎力推荐的,卧龙先生可不仅仅是束发读史书啊。

    总而言之,窃以为,做一个程序员,一要钻下去,积累技术,二要跳出来,影响世界(虽然只是一点点)。


    展开全文
  • 大数据学习路线(完整详细版)

    万次阅读 2019-01-22 11:46:07
    java(Java se,javaweb) Linux(shell,高并发架构,lucene,solr) Hadoop(Hadoop,HDFS,Mapreduce,yarn,hive,hbase,sqoop,zookeeper,flume) 机器学习(R,mahout) Storm(Storm,kafka,redis) ...Spark(scala,spark,spark ...

     

    java(Java se,javaweb)

    Linux(shell,高并发架构,lucene,solr)

    Hadoop(Hadoop,HDFS,Mapreduce,yarn,hive,hbase,sqoop,zookeeper,flume)

    机器学习(R,mahout)

    Storm(Storm,kafka,redis)

    Spark(scala,spark,spark core,spark sql,spark streaming,spark mllib,spark graphx)

    Python(python,spark python)

    云计算平台(docker,kvm,openstack)

    名词解释

    对于小白学习大数据需要注意的点有很多,但无论如何,既然你选择了进入大数据行业,那么便只顾风雨兼程。正所谓不忘初心、方得始终,学习大数据你最需要的还是一颗持之以恒的心。

    一、Linux

    lucene: 全文检索引擎的架构

     

    solr: 基于lucene的全文搜索服务器,实现了可配置、可扩展并对查询性能进行了优化,并且提供了一个完善的功能管理界面。

     


    今天为大家整理了部分大数据学习教程与大家共享,每个人可以根据自己的需要来选择,需要的小伙伴可以+下学习资料分享裙 199加上427最后是210数字连起来就是了。
     

    二、Hadoop

    HDFS: 分布式存储系统,包含NameNode,DataNode。NameNode:元数据,DataNode。DataNode:存数数据。

    yarn: 可以理解为MapReduce的协调机制,本质就是Hadoop的处理分析机制,分为ResourceManager NodeManager。

    MapReduce: 软件框架,编写程序。

    Hive: 数据仓库 可以用SQL查询,可以运行Map/Reduce程序。用来计算趋势或者网站日志,不应用于实时查询,需要很长时间返回结果。

    HBase: 数据库。非常适合用来做大数据的实时查询。Facebook用Hbase存储消息数据并进行消息实时的分析

    ZooKeeper: 针对大型分布式的可靠性协调系统。Hadoop的分布式同步等靠Zookeeper实现,例如多个NameNode,active standby切换。

    Sqoop: 数据库相互转移,关系型数据库和HDFS相互转移

    Mahout: 可扩展的机器学习和数据挖掘库。用来做推荐挖掘,聚集,分类,频繁项集挖掘。

    Chukwa: 开源收集系统,监视大型分布式系统,建立在HDFS和Map/Reduce框架之上。显示、监视、分析结果。

    Ambari: 用于配置、管理和监视Hadoop集群,基于Web,界面友好。

    二、Cloudera

    Cloudera Manager: 管理 监控 诊断 集成

    Cloudera CDH:(Cloudera's Distribution,including Apache Hadoop) Cloudera对Hadoop做了相应的改变,发行版本称为CDH。

    Cloudera Flume: 日志收集系统,支持在日志系统中定制各类数据发送方,用来收集数据。

    Cloudera Impala: 对存储在Apache Hadoop的HDFS,HBase的数据提供直接查询互动的SQL。

    Cloudera hue: web管理器,包括hue ui,hui server,hui db。hue提供所有CDH组件的shell界面的接口,可以在hue编写mr。

    三、机器学习/R

    R: 用于统计分析、绘图的语言和操作环境,目前有Hadoop-R

    mahout: 提供可扩展的机器学习领域经典算法的实现,包括聚类、分类、推荐过滤、频繁子项挖掘等,且可通过Hadoop扩展到云中。

    四、storm

    Storm: 分布式,容错的实时流式计算系统,可以用作实时分析,在线机器学习,信息流处理,连续性计算,分布式RPC,实时处理消息并更新数据库。

    Kafka: 高吞吐量的分布式发布订阅消息系统,可以处理消费者规模的网站中的所有动作流数据(浏览,搜索等)。相对Hadoop的日志数据和离线分析,可以实现实时处理。目前通过Hadoop的并行加载机制来统一线上和离线的消息处理

    Redis: 由c语言编写,支持网络、可基于内存亦可持久化的日志型、key-value型数据库。

    五、Spark

    Scala: 一种类似java的完全面向对象的编程语言。

    jblas: 一个快速的线性代数库(JAVA)。基于BLAS与LAPACK,矩阵计算实际的行业标准,并使用先进的基础设施等所有的计算程序的ATLAS艺术的实现,使其非常快。

    Spark: Spark是在Scala语言中实现的类似于Hadoop MapReduce的通用并行框架,除了Hadoop MapReduce所具有的优点,但不同于MapReduce的是job中间输出结果可以保存在内存中,从而不需要读写HDFS,因此Spark能更好的适用于数据挖掘与机器学习等需要迭代的MapReduce算法。可以和Hadoop文件系统并行运作,用过Mesos的第三方集群框架可以支持此行为。

    Spark SQL: 作为Apache Spark大数据框架的一部分,可用于结构化数据处理并可以执行类似SQL的Spark数据查询

    Spark Streaming:一种构建在Spark上的实时计算框架,扩展了Spark处理大数据流式数据的能力。

    Spark MLlib: MLlib是Spark是常用的机器学习算法的实现库,目前(2014.05)支持二元分类,回归,聚类以及协同过滤。同时也包括一个底层的梯度下降优化基础算法。MLlib以来jblas线性代数库,jblas本身以来远程的Fortran程序。

    Spark GraphX: GraphX是Spark中用于图和图并行计算的API,可以在Spark之上提供一站式数据解决方案,可以方便且高效地完成图计算的一整套流水作业。

    Fortran: 最早出现的计算机高级程序设计语言,广泛应用于科学和工程计算领域。

    BLAS: 基础线性代数子程序库,拥有大量已经编写好的关于线性代数运算的程序。

    LAPACK: 著名的公开软件,包含了求解科学与工程计算中最常见的数值线性代数问题,如求解线性方程组、线性最小二乘问题、特征值问题和奇异值问题等。

    ATLAS: BLAS线性算法库的优化版本。

    Spark Python: Spark是由scala语言编写的,但是为了推广和兼容,提供了java和python接口。

    六、Python

    Python: 一种面向对象的、解释型计算机程序设计语言。

    七、云计算平台

    Docker: 开源的应用容器引擎

    kvm: (Keyboard Video Mouse)

    openstack:  开源的云计算管理平台项目



     

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

    万次阅读 多人点赞 2020-08-06 10:27:23
    java详细路线: 原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? ...

     

     

    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

    展开全文
  • Java学习路线(完整详细版)超详细

    万次阅读 多人点赞 2020-04-27 22:30:23
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • 乘车路线

    2017-08-07 16:01:30
    乘车路线(roads.exe 1s ) 编号为1.. N的N座城镇用若干仅供单向行驶的道路相连,每条道路上均有两个参数:道路长度(length)和在该条道路上行驶的费用(cost)。BOB准备从城镇1出发到达城镇N,但他目前只有W的钱,...
  • C语言学习路线

    2020-08-05 13:33:41
    C语言是当代人学习及生活中的必备基础知识,应用十分广泛,下面为大家带来C语言基础知识梳理总结,C语言零基础入门绝对不是天方夜谭! 1、环境篇(ubuntu 系统安装 及环境调试) 学习内容:ubuntu 虚拟机安装以及...
  • 易云智慧生态电商模块介绍

    万次阅读 2019-08-23 18:45:51
  • iOS完整学习路线

    万次阅读 多人点赞 2013-11-29 22:36:39
    今晚特地花时间整理出了iOS的完整学习路线图,希望对大家有帮助
  • Java学习路线图(完整详细2020版)

    万次阅读 多人点赞 2020-05-30 22:14:33
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • 微服务的技术架构路线

    千次阅读 2018-03-20 16:31:03
    各大产品模块基本遵循了一致的技术实现路线,即前后端分离技术。后端服务底层基于Dubbo微服务框架和主备MySQL数据库,由Provider层提供RPC服务,Controller对外暴露Restful API,两者通过分布式部署和多活机制保证各...
  • 技术路线模版

    万次阅读 2012-06-25 18:46:51
    (一)先看看什么是技术路线 百度文库的定义:  技术路线一般是指研究的准备,启动,进行,再重复,取得成果的过程。 维基百科的定义:  技术路线(technology roadmap)是使用特定技术方案帮助达到短期或者...
  • 如何在谷歌地球上绘制路线

    万次阅读 2014-12-31 18:29:19
    在属性框里定义路线名称、线条颜色和宽度等。定义后,把属性框移到一边,不要关闭。点击起点,然后按住鼠标左键不放,顺路线滑动,一条路线就显示在你面前。也可以在路线上连续点击左键,形成路线。点击右键一次,...
  • 送给大家一套完整的web前端开发学习路线

    万次阅读 多人点赞 2018-11-21 15:19:58
    本文来源:千锋web前端开发 近几年IT业可谓是发展火热,而且新生了很多的职业。在这众多的新生职业中备受瞩目的当属web前端工程师了,web前端在IT行业真正受到...好的学习方法和掌握好正确的学习路线可以让我们的...
  • Go语言完整的学习路线

    万次阅读 2018-12-03 11:46:14
    Go语言完整的学习路线图 作为Go语言的学习爱好者,可以结合这张路线图看看Go 入门指南 Github 上《The Way to Go》中文译本的镜像 也可以下载:PDF、MOBI、EPUB https://github.com/Unknwon/the-way-to-go_ZH_CN ...
  • 我总结的c#学习路线

    万次阅读 2014-08-21 01:03:20
    c# 入门:vc#2012从入门到精通 进阶:clr via c#   asp.net 入门:asp.net 4揭秘   html&&css 入门:head first html & css 第2版   css ...入门&&进阶:js权威指南
  • 深度学习入门及深度学习学习路线

    万次阅读 多人点赞 2017-08-30 15:18:01
    最近一段老师逼着搞论文,都没啥时间刷题和更新博客了。前段时间无意间看到一些深度学习方面的资料,个人觉得写的实在是太精彩了,必须得推荐给他大家。目前只更新了7篇博客,里面包含了原理(即数学推导)和实践...
  • 不少人对自己的学习路线表示迷茫,接下来教你使用GitHub来寻找自己的学习路线,不过有时候需要科学上网,不然大部分图片是无法显示的,这个是一个比较清晰的前后端学习路线,笔者转载在这, 那么如何查找自己的学习...
  • 给你一份完整的Web前端学习路线

    万次阅读 多人点赞 2019-04-12 21:31:57
    随着Web2.0思想的日益普及,...Web前端学习路线图,希望对初学者有帮助。 1.Javascript 语言 全栈开发中,用的编程语言就是 javascript 2.HTML5 标签和 DOM 这是前端最核心技术,为之后学习各种开发框架,打下...
  • 如图所示:   步骤: 1.打开APP:百度地图,登陆 2.点解左上角的头像 ...高德地图驾驶路线记录 记录驾驶路线 地图导航自动播放驾驶路线 高德地图怎么记录走过的路线 高德地图记录路线 百度新版地...
1 2 3 4 5 ... 20
收藏数 262,163
精华内容 104,865
关键字:

路线