本周课程的学习，有两点体会比较深：

多看，多写，多练，养成思维模式，

学会切题，做好便捷处理

好记性不如烂笔头，多在纸上写写画画(为此我专门买了A4纸)

多交流碰撞

这是一个长期的过程，这门课程只是交了你怎么入口，要保持每周刷题的习惯

本周利用业余时间看了课件和视频，还是有很多收获，主要体现在以下2方面：

1. 学习方法很重要，我们需要刻意的练习来提高熟练度。
2. 思维方式很重要，我们要以主干逻辑为主，施行自顶向下的思考模式。

结合自身的实际情况，我也给自己定了目标；每天利用业余时间学习做题两个小时，按照老师教授的五遍刷题法，自顶向下的思考模式，把算法与数据结构的相关概念和基础知识掌握牢固。

训练营目标

职业顶尖水平----对于算法和数据结构理解， 个人目标是让自己的代码能力更强，思维更加清晰，代码更加规范

达成目标的方法

1. Chunk it up 切碎知识点
2. Deliberate Practice 刻意练习
3. Feedback 反馈
   以往的学习过程中经常忽略把知识点碎片化，并且把知识点串联起来。对于学会的知识点没有做到经常练习，输出反馈，导致知识点碎片化，模糊化，并且逐渐遗忘或者理解不深刻。后续需要在这方面进行刻意练习，对自己本次的学习的要求力争达到每堂课自己课后在笔记本上手写摘抄笔记，并且按方格笔记本的方法归纳知识点，提出问题。完成手写版以后，形成电子化的思维导图和知识点，并且输出。由于平时工作较忙，坚持不易，需要时刻提醒自己。

关于数据结构与算法

入学考试成绩很不理想，意料之中，知识点掌握不牢固，并且时隔多年，其中很多知识没有学习过，外加审题不认真，有些自己会的还是做错了。回想到工作中的习惯，代码敲错了可以调试修改，题目错了，就错了。
这些问题反应到工作中，也许你会得到一些新的需求，但是这些需求如果不理解清楚，不与需求方沟通清楚，盲目干活，你的代码速度越快，错误方向越大。事后发现错误，挫伤士气的同时，还有可能为了自己的错误与人争辩，或者情绪受影响。所以认真审题，理解出题人意图，多沟通非常重要

切题四件套

1. Clarification 沟通，审题
2. Possible Solutions 多思考解题思路
3. Coding 多写
4. Test Case 寻找边界条件
   上述个人对于问题的思考，也通过老师的切题四件套方法得到印证。无论是做题还是工作，多沟通，尽可能的寻求各种解决方案和更多的解题思路，并且输出方案，沟通以后再形成算法，最后思考测试用例

五毒神掌

对于Leetcode的学习，平时个人也在Leetcode上做题，对大神们的神奇解法膜拜的同时，一直在思考，为什么大神们这么牛，为什么自己解题这么慢，效率这么低。
学习了五毒神掌以后，知道了其实解题是需要反复的刻意练习，不断的练习就刻意获取更多的灵感，第一遍不会直接看答案，让自己豁然开朗，其实掌握思考方式搭配刻意练习，能够获得更大的提升。

代码环境与指法练习

此部分已经完成，指法部分个别的操作确实用的比较少，最近几天的Coding过程中一直在尝试使用。

时间空间复杂度分析

结合之前自己学习王争老师的算法课程的笔记和老师的视频又过了一遍，知识得到巩固，后续过程中每一步都需要用这些方法来进行思考。

Table of Contents

1. 本周总结
   1. 老师讲了啥
   2. 我学到了啥
   3. 最后

本周总结

老师讲了啥

本周我们上了三课：《数据结构和算法总览》，《训练环境配置，编码技巧和Code Style》以及最后一课《时间复杂度和控件复杂度分析》。
在第一课中老师带领我们从全局着眼，了解了本课程将要讲到的知识点，以及本课程要用的方法论——刻意练习。同时讲到了让我受益匪浅的“切题四件套”以及刷题“无毒神掌”。在第二节中，老师给我们介绍推荐了使用到的工具，不仅如此，还将“渔”给了我们，让我们知道遇到问题改怎么解决。第三课中讲到如何分析一个算法的时间和控件复杂度，以及怎么样的算法是一个好的算法。

我学到了啥

通过本周的三课和一个作业，使我对未来两个月将要学到的东西有了一个清晰的印象。特别琢磨了老师的“刷题法宝”之后，让我对完成课程和精进技术有了十足的信心。
在第二课中老师提到“工欲善其事必先利其器”，现在我对这句话有了新的理解。这句话不仅仅是说我们想把事情做好，首先要由趁手的工具，同时要把我们手头的工具玩明白弄清楚，这样才能使效率最大化的提升。

最后

希望能在接下来的两个月里努力学习，完成课程。

1、数据结构的诞生是为了算法服务的，他们是一应而生。
2、数据结构的深入需要多写多练多看算法题目。
3、多写多练不等于盲目的去练习，从算法与数据接口的关系可以总结，练习也需要相应的学习方法才能相得益彰。
4、师傅领进门、修行靠个人。

预习周总结：

一，数据与算法结构总览

Chunk it up : 切碎知识点，庖丁解牛，并要建立各个知识点的联系，成树状的知识体系
It’s important to view knowledge as a semantic tree. Make sure you understand the fundamental principles ie: the trunk and big branches before you go into the details/leaves or there is nothing for them to hang on.

Deliberately practicing :
注意基本功的训练。因为基本功是区别职业和业余选手的根本。所以要将基本功进行分解训练和反复练习(具体分解见算法和数据结构脑图)。最大的误区是只做一遍。具体来说需要刻意练习过遍数。越是自己薄弱不舒服的地方越要坚强练习。虽然痛苦，却是一个长肌肉的过程。

Feedback :
主动反馈: 看leetcode 排名最高的discussion,看网上高手的算法和视频讲解

被动反馈: code review

2. 切题四件套：

   Clarification

   Possible solution

Compare (time/space)
Optimal
Coding (多写几种解法)

    Test cases

3. 五步刷题法

二，训练准备和复杂度分析

Code style:
以前都是visual studio IDE ctr+k, ctr+l 自动规范代码格式。现在自己手写代码时得刻意去模仿vs的代码格式。这样可以让自己的代码风格更readable,也可以减少自己 对IDE的依赖。

掌握自顶向下的编程方式：
自己在编代码和逻辑比较复杂繁琐的题目时经常因小失大，总觉等漏洞百出总是无法面面俱到。其实联系到前面所说的树状的知识体系，在编程时也要先把思路的主干编好，小的细节可以先用一个未实现的私有方法来表示，等到最后才回去实现。小技巧，在写私有方法时，虽然可以先把实现放在一边，但需要想好并写清楚specification,即其母的，输入参数和输出结果。这样可以保证思路的清晰度和一致性。千万不能说这个细节我没想清楚它用来干嘛的，所以先忽略。一定是先想清楚这快步骤是干嘛的，才有足够的信心来说我待会回来实现它。要不等回来实现后只会一头雾水，如果思路错了回来后更可能否定了自己之前的所有思路。所以就像backtrack一样，每一步的decision都要准确的进行validate.

三，时间空间复杂度：

O ( n! ) > O ( 2 ^n)

总结了下这周视频讲到的点

重要名词

* 递归: recursion
* 深度优先搜索: depth first search(deep first)
* 广度优先搜索: breadth first search
* 动态规划: dynamic programming
* 二分查找: binary search
* 贪心: greedy

切题四件套

* Clarification 确认题目
* Possible solutions 想所有可能的解法
    * compare ( time/space )
    * optimal ( 加强 ) 最优解
* Coding ( 多写 )
* Test cases 测试用例

刷题第一遍

* 5分钟: 读题+思考    最多十五分钟
* 直接看解法:  注意! 多解法, 比较解法优劣
* 背诵、默写好的解法

刷题第二遍 (紧接着第一遍)

* 马上自己写 -> leetcode提交
* 多种解法比较、体会 -> 优化!  每种解法都写

刷题第三遍

* 过了一天后, 再重复做题
* 不同解法的熟练程度 -> 专项练习  

刷题第四遍

* 过了一周: 反复回来练习相同题目
* 继续专项练习 

刷题第五遍

* 面试前一周恢复性训练

学习手册

学习理念

• 让优秀的人一起学习
• 师傅领进门，修行靠个人

学员精选留言

• 稻盛和夫“六项精进”
  • 1、付出不亚于任何人的努力
  • 2、要谦虚，不要骄傲
  • 3、要每天反省
  • 4、活着，就要感谢
  • 5、积善行，思利他
  • 6、忘却感性的烦恼
  • 从今天开始，让我们一起啃下这块硬骨头
• 获得正向的反馈，全神贯注的完成一件事情
• 坚持、不断修正自己的学习方法，更加快速进步
• 既然选择了这条路，跪着也要走下去，为了在算法这条路上越走越远，就必须付出超乎常人的努力，只有这样，才能在这个领域站住脚。坚持走下去！
• 课程结束回顾学习过程，会感激今天付出的所有努力！

课前准备

【关于我】 custer
【关于工作】 持续创业者，创业第四年了，专注于向培训机构提供少儿编程课程及系统支持服务
【工作之外】 学习Go语言和微服务领域知识
【给我 10 分钟，我希望与你分享…】1. 希望以后可以和自己的孩子一起学习数据结构与算法，一起做很多很多个技术玩具(不能称之为产品)

精通一个领域三要素：切碎知识点，刻意练习，反馈
五步刷题法（五毒神掌）：
第一遍： 读题思考五分钟，如果想不出来就直接看解法，比较解法优劣，背诵默写好的解法。
第二遍：马上自己写解法，多种解法比较 体会 优化。
第三遍：过了一天后，再重复做一遍。专项练习。
第四遍：过了一周反复回来练习相同的项目。
第五遍：面试前一周恢复性训练
自己画算法和数据结构脑图，写上自己的熟悉领域跟不熟悉的领域，加强全局性的观察和认识。

Source Code Analysis

The source code analysis is based on JDK 11.

Queue

See full doc. This is the interface which has the following sub interfaces:

• BlockingDeque
• BlockingQueue
• Deque
• TransferQueue
  It's also typically implemented by classes ArrayDeque, ConcurrentLinkedDeque, LinkedList and PriorityQueue. (see full list from the link above)

There are six main methods:

• add - Insert new element, but throws exception when there is no available space.
• offer - Insert new element, return false when there is no available space.
• remove - Remove the head element, but throws exception when the queue is empty.
• poll - Remove the head element, return null if the queue is empty.
• element - retrieve the element, but throws exception when the queue is empty.
• peek - retrieve the element, return null if the queue is empty.

Apart from that, you can also call all the methods of java.util.Collection interface, like 'addAll', 'contains', etc. Because it extends from it.

PriorityQueue

Brief of the class will be skipped as you can refer it from the doc. Highlights from briefs:

• Ordered queue, based on heap.
• All elements are comparable objects.
• Not synchronized. Use PriorityBlockingQueue for thread-safe purpose.
• O(log(n)) complexity for methods offer, poll, remove and add.
  The core method is siftUp which is maintained by heap that gets the O(log(n)) complexity.
  offer method provides auto-grow capacity.
• O(n) complexity for methods remove(Object) and contains.
  The core method is indexOf, which traverses the queue and gets the index of object, which is
  O(n) complexity.
• O(1) complexity for method peek and size.
  returns the first element of array, and gets the O(1) complexity.

Rewrite Deque Test

package week01;

import java.util.Deque;
import java.util.LinkedList;

// Refer https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Deque.html, and see
// 'Comparison of Stack and Deque methods' section.
public class DequeTest {
    public static void main(String[] args) {
        Deque<String> deque = new LinkedList<>();
        deque.addFirst("a");
        deque.addFirst("b");
        deque.addFirst("c");
        System.out.println(deque);

        String str = deque.getFirst();
        System.out.println(str);
        System.out.println(deque);

        while (deque.size() > 0) {
            System.out.println(deque.removeFirst());
        }
        System.out.println(deque);
    }
}

1. Chunk it up 切碎知识点

数据结构：

一维数据结构：  
    基础：数组（Array） 链表（Linked list)  
	高级：栈 stack 队列 queue 双端队列 deque 集合 set 映射 map  
二维数据结构：  
    基础：树 tree 图 graph  
	高级：二叉搜索树 binary search tree  AVL  red-black tree  堆 heap  并查集 disjoint set 字典树 trie 
特殊：
    位运算 Bitwise 布隆过滤器 BloomFilter
	LRU cache

算法：

if else switch  -> branch
for while loop  -> iteration            最终是找重复单元
递归 Recursion

搜索 Search：深度优先 Depth First Search  广度优先 Breadth First Search
动态规划 Dynamic Programming
二分查找 Binary Serch
贪心 Greedy
数学 Math 几何 Geometry

2. Deliberate Practicing 刻意练习

五毒神掌，过遍数，反复练习
练习缺陷、弱点
走出舒适区

3. Feedback 反馈

即时反馈
主动反馈，主动找题 github leetcode
被动反馈，高手指点

切题四件套

1. Clarification 确定理解正确
2. Posible solutions 过一遍所有可能的算法的时空复杂度
3. Coding
4. Test Cases

五毒神掌

1. 五分钟看题，思考解法
   如果想不出直接看解法，并比较各个解法的优劣
   背诵默写好的解法

2. 自己写代码，并提交leetcode，debug
   多种解法比较、体会

3. 一天后重新做

4. 过一周后重新做

5. 面试钱前准备

刻意练习 vscode 快捷键

word 移动： ctrl + <-/->
line 首尾： home end
删除单词： ctrl + backspace
删除光标右侧：ctl + delete

自顶向下coding

跟“岛神”学习使用GitHub提交作业，大神超级耐心~~~~疯狂打call~

作业：绘制自己的数据结构和算法脑图

要求：用脑图的方式把知识的脉络串联起来，不管对于学习新知识还是巩固已有知识，都是一种很好的学习方式。同学们可以将目前自己所掌握的数据结构和算法知识绘制成脑图，在绘制过程中可以查阅资料，补充目前掌握欠缺的部分，找到自己薄弱的地方。后面再通过课程的学习和刻意练习，动态地将自己绘制的脑图逐步补充、完善，从而达到真正的融会贯通。

脑图绘制工具不限。

把思维导图画出来，就像地图一样，假设这是一个旅游的景点地图，收拾好背包，准备上路。
好的工具是成功的一半

老师很用心，跪舔。
五毒神掌，leetcode 五遍刷题；
四脚着地，面试时，四平八稳，面试后，四通八达。（切题四件套）
三足鼎立，算法的基础，分支，循环，递归。
自顶向下。

算法训练营开始了，第一周预习热身，进入学习状态。希望能坚持完成，最终对数据结构与算法的理解能够达到职业顶尖级别。

精通一个领域

1. Chunk it up
   切碎知识点，形成脑图串联
   这次作业是第一次去了解并动手画出一个脑图，发现动手画图的过程中能够理清思路，把知识点串联起来
2. Deliberate Practice
   刻意练习、弱点地方、离开舒适区、枯燥
   回想小学时低年级基础学科（数学）几乎天天都在做运算练习。到大学后内容难了，刻意的针对练习却几乎没有了
3. FeedBack

切题四件套

1. Clarification
2. Possible solutions
   所有可能解法过一遍，比较时、空复杂度
   做算法题最大误区——只做一遍
3. Coding
4. Test cases

五步刷题法

• 第一遍 读题、思考、多解法比较
• 第二遍 自己动手
• 第三遍 一天后，不同解法专项练习
• 第四遍 一周后
• 第五遍 恢复性训练

工具配置

• 工欲善其事必先利其器
• Google
• VSCode
• LeetCode plugin

基本功
我想没有为什么，就是做到这些才能专业

• Code Style
• LeetCode看Disscuss board
• 指法和小操作
• 自顶向下的编程方式
  新闻稿方式，关键逻辑、函数放最上面，细节在下面
  先完成主干，再完善细节

常见的时间、空间复杂度

预习周体会
报名训练营后总觉得离开始还早。
开营初认为这一周时间完成预习绰绰有余，结果在Deadline前手忙脚乱地才完成。
算法小测试的成绩出乎我意料，连蒙带猜多选竟然全对。其实很多名词概念我都无法清楚区分，希望能坚持完成训练营，再回头能一题题分析出名堂。
第一次学习思维导图，第一次动手画
第一次从GitHub上fork到本地，并提交，鼓捣鼓捣还担心不会交作业
第一次装VSCode
感觉自己在过去真是浪费了太多时间
算是仪式感满满的准备了，尽开锣当不了唱戏，希望能坚持并完成训练营

• 什么是数据结构？
• 什么是算法？
• 如何掌握或则熟练算法？
• 如何解一道算法题 ？
• 编程习惯

1. 什么是数据结构 ？
数据结构是计算机存储、组织数据的方式，好的数据结构可以带来更高效的运行或存储效率，数据结构往往和高效的检索算法和索引技术有关。我们可以将数据结构按下面的方式去分类，理解并记忆：
1.1 一维:
基础: 数组 array (string),链表 linked list
高级: 栈 stack, 队列 queue, 双端队列 deque, 集合 set, 映射 map (hash or map), etc

1.2 二维:
基础: 树 tree, 图 graph
高级: 二叉搜索树 binary search tree (red-black tree, AVL), 堆 heap, 并查集 disjoint set, 字典树 Trie, etc.

1.3 特殊:
基础: 位运算 Bitwise, 布隆过滤器 BloomFilter
高级: LRU Cache

2. 什么是算法？ ？
算法（Algorithm）是解决一系列问题问题的指令，系统通过输入，然后计算指令，得到输出结果，不同的算法有可以有不同的计算时间，需要不同的空间，所以一个算法的好坏可以用空间复杂度与时间复杂度来衡量，我们可以通过一下分类来记忆算法，对算法的理解有一个大概的轮廓

• If-else, switch —> branch
• for, while loop —> Iteration
• 递归 Recursion (Divide & Conquer, Backtrace)
• 搜索 Search: 深度优先搜索 Depth first search, 广度优先搜索 Breadth first search, A*, etc
• 动态规划 Dynamic Programming
• 二分查找 Binary Search
• 贪心 Greedy
• 数学 Math , 几何 Geometry


3. 如何掌握或则熟练算法？
五步刷题法：
第一遍：

• 5分钟:读题 + 思考
• 若没有思路解决某个题目或则问题，可直接看解法， 但需要多种解法，并分析优劣
• 背诵，默写优秀的解法

第二遍：
马上自己写，并在 LeetCode 提交
多种解法比较、体会 —> 优化

第三遍：
隔一天，再重复做题
不同解法的熟练程度 —> 专项练习

第四遍：
隔周后，反复回来练习相同题目
第五遍：
隔月后，回来巩固练习过的题目，体会，并与思考如何运用到实际中去

4. 如何解一道算法题？

• 细心审题，反复确认，并记录条件限制
• 尝试用多种方式去解决
• 多coding
• 测试用例

5. 编程习惯
5.1. 养成自顶向下的编程方式， 主方法中为主要枝干（分支方法中具体实现），描述如何去解决一个问题
eg:
function () {
let result1 = doThingOne();
let result2 = doThingTwo();
let finalResult = doFinalThings(result1, result2)
}

5.2. 了解每个数据结构的原理和代码框架
5.3. 回忆每种算法的**和代码模板

Hi各位同学，俗话说“三人行，必有我师”，因此我们鼓励大家在整个学习期间，多多 Review 同班同学的代码并进行点评。在这个过程中：

1. 可能你会从其他同学的代码中学到一个更优的思路
2. 可能你会因为其他同学给你的评论启发新的灵感
3. 可能你的代码会得到大家纷纷的点赞
4. 有时候也可能因为其他小伙伴的一句“学习了”而备受鼓舞

“让优秀的人一起学习”，大家可以在互相 Review 的过程中思考更多、获得更多。因此，请把你的算法题作业链接（你自己仓库的链接就好）回复在下面，这样大家就可以更方便的进行代码 review 啦！

跟帖格式：

学号后三位：
姓名（你在班里的姓名，便于同学可以跟你讨论）：
你的代码链接：

要求

1. 每周从覃超老师布置的题目中，至少完成并提交两道算法题
2. 围绕每周重点学习的算法知识点，撰写一篇有观点和思考的技术文章或总结，切忌流水账。

作业提交 Deadline

2019年10月20日 23:59 （以当地时间为准）
未按时提交作业，会在个人作业总分钟 -3 分

本周作业概述

本周需要完成学习的视频内容：

• 第 3 课 | 数组、链表、跳表
• 第 4 课 | 栈、队列、优先队列、双端队列

以上两课视频后，覃超老师都给出了大家可以练手的算法题。

其中，第 4 课的课后作业（第2节视频后）还包括：

• 用add first或add last这套新的API改写Deque的代码
• 分析Queue和Priority Queue的源码

请大家将此部分作业，放在本周学习总结中一并提交

本周算法习题库：

第三课课后习题：

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
https://leetcode-cn.com/problems/rotate-array/
https://leetcode-cn.com/problems/merge-two-sorted-lists/
https://leetcode-cn.com/problems/merge-sorted-array/
https://leetcode-cn.com/problems/two-sum/
https://leetcode-cn.com/problems/move-zeroes/
https://leetcode-cn.com/problems/plus-one/

第四课课后习题：

https://leetcode.com/problems/design-circular-deque
https://leetcode.com/problems/trapping-rain-water/
用add first或add last这套新的API改写Deque的代码
分析Queue和Priority Queue的源码

改写代码和分析源码这两项作业，需要在你的本周学习总结中一并提交。

为了最大化学习效果，有效掌握整个算法训练营的知识和能力，需要做到：

1.关于预习

每周课程开始之前，需要自己查看课件，明确学习内容以及期望目标，制定明确的学习计划。

2.关于刷题

• 明确刷一道算法题，刷一遍是远远不够的，要通过五毒神掌进行反复练习
• 明确让你觉得不舒服的地方正是需要学习的地方，要把知识切碎了，对自己薄弱的地方进行刻意练习、反复练习
• 明确刷题是有方法的，要通过切题四件套对每一道题目进行认真训练
• 明确反馈是学习的一大助力，要通过Code Review、Discussion学习他人的优秀经验，及时反馈，弥补自己的不足

3.关于工具

• 工欲善其事必先利其器，配备效率最高的工具。
• 刻意练习不止针对刷题、知识，也针对高效实用工具，高效实用工具，是必要的。

我正如老师所说，算法没有少学习，可始终没有成效。
老师的第一节课就使我醍醐灌顶， 不仅仅是在算法上，在其他各方面都足以打通任督二脉。

想成为顶尖职业水平就必须有绝对牢靠的基础，则需要把基础点提炼出来（这是我之前没有的概念），加之刻意练习，最后寻求反馈。

程序猿的职业水平不仅仅体现在算法上，Code Style也可以体现一个程序猿的水平。当然，如果连工具都用不遛那就更谈不上职业了。

老师说的每一个点都在提炼基础点，为后面的学习方向装上了明灯。

在画脑图的时候，对自己的知识体系有了一个大致的认识。对比老师提供的脑图，自己的知识量还是远远不足， 在后面的学习中，我会不断补充完善自己的脑图。

• 五毒神掌
• 切题四件套
• 自顶向下

好的学习方法是成功的一半， 谢谢老师，谢谢极客大学。

研究的内容和对象

• 数据结构
• 算法
• 时间空间复杂度

研究的方法

• 脑图（记录知识脉络）
• 刷题（巩固、加深、理解）
• 总结（提炼）

目标与意义

• 应用于实际工作中
• 提升代码质量
• 提高程序效率

预习周

1. 数据和算法的简单概括
   2.精通学习法
   (1)chunk it up 知识点拆分
   (2)deliberate practicing 刻意练习
   (3)feedback 反馈
   3.切题四件套
   (1)Clarification
   (2)Possible solutions
   • compare (time/space)
   • optimal（加强）
   (3)Coding（多写）
   (4)Test cases
   4.五步刷题法(五毒神掌)
   第一遍:
   • 5分钟：读题 + 思考
   • 直接看解法：注意！多解法，比较解法优劣
   • 背诵、默写好的解法
   第二遍:
   • 马上自己写->LeetCode 提交
   • 多种解法比较、体会 ->优化！
   第三遍:
   • 过了一天后，再重复做题
   • 不同解法的熟练程度->专项练习
   第四遍:
   • 过了一周，反复回来练习相同题目
   第五遍:
   • 面试前一周恢复性训练
   5.训练编程环境，编程技巧和代码规范-工欲善其事必先利其器
   6.时间空间复杂度- 大O

开班典礼感悟

1. 作为coder，基础能力很重要（计算机知识、数据结构、算法等等）
2. 特别好的学习方式 模仿优秀的人，优秀的习惯
3. 规划好 有条不紊的学习（不追求完美主义，不钻牛角尖，一次学习5小时 不如每天都学习1小时）
4. 各种排序算法一定要会（学姐面试经验）
5. 做到优秀，就是需要比别人付出多一点努力
6. 只做一遍等于没做。（学习知识要反复练习）

预习周学习方法总结

这些内容ppt中都有，但是我觉得十分重要，于是自己总结一遍

• 学习前预习和查看基础知识
• 跟着老师思考回答问题
• 按照切题办法完成课后作业

hunk it ip

切碎知识点，让知识点脉络化，理解其中的关联，变成一个脑图，存在大脑中

Deliberate Practicing

刻意练习，过遍数

练习自己的薄弱和缺点

Feedback

• 即时反馈

• 主动型反馈

• 高手代码 (GitHub, LeetCode, etc.)

• code review

切题四件套

• Clarification

• Possible solutions

• compare (time/space)

• optimal（加强）

• Coding（多写）

• Test cases

五步刷题法

刷题第一遍

• 5分钟：读题 + 思考

• 直接看解法：注意！多解法，比较解法优劣

• 背诵、默写好的解法

刷题第二遍

• 马上自己写 —> LeetCode 提交

• 多种解法比较、体会 —> 优化！

刷题第三遍

• 过了一天后，再重复做题

• 不同解法的熟练程度 —> 专项练习

刷题第四遍

• 过了一周：反复回来练习相同题目

刷题第五遍

• 面试前一周恢复性训练

个人总结

1. 学习方法 和 学习经验很重要，需要结合自己的习惯 加以利用
2. 每天坚持
3. 复杂度分析是算法中的一项重点，自己在今后的学习中，需要时时注意，分析每段代码的复杂度

学习总结

解题懵逼的方法： 1. 看题目能不能暴力求解 2. 从最简单的条件开始，比如为0时为1时 3. 找 最近 重复子问题 ☞ 找重复性 （循环、递归、分治等**的应用） 优化**： 1. 空间换时间 2. 对时间复杂度较高的操作替换数据结构以降低时间复杂度

Golang的Priority-Queue实现

https://github.com/custergo/study_algo/tree/master/1.Play-with-Data-Structures/08-Heap-and-Priority-Queue/06-Priority-Queue

• 切碎知识点

  • 思维导图

• 刻意练习

  • "五毒神掌“

• 反馈

• 工欲善其事，必先利其器

• 时间复杂度

  • 大 O 时间复杂度表示法
  • 越高阶复杂度的算法，执行效率越低
  • 最好、最坏、平均情况时间复杂度

• 空间复杂度

预习周笔记

一、期待效果

• 职业顶尖级别 - 对于算法数据结构的理解
• 一线互联网公司面试
• LeetCode 300+ 的积累

二、精通一个领域

• Chunk it up 切碎知识点

  • 庖丁解牛
  • 脉络连接

• Deliberate Practicing 刻意练习

• Feedback 反馈

2.1 Chunk it up 切碎知识点

分解数据结构和算法

数据结构

了解每个数据结构的原理和代码框架

• 一维
  • 基础：数组array(string),链表 linked list
  • 高级：栈Stack，队列 queue，双端队列 deque，集合 set，映射 map(hash or map), etc.
• 二维
  • 基础：树 tree，图 graph
  • 高级：二叉搜索树 binary search tree(red-black tree, AVL), 堆 heap，并查集 disjoint set，字典树 Trie，etc.
• 特殊
  • 位运算 Bitwise，布隆过滤器 BloomFilter
  • LRU Cache

算法

清晰认识每种算法的**和代码模板

• if-else, switch -> branch
• for, while loop -> Iteration
• 递归 Recursion (Divide & Conquer, Backtrace)
• 搜索 Search：深度优先搜索 Depth first search, 广度优先搜索 Breadth first search, A*, etc
• 动态规划 Dynamic Programming
• 二分查找 Binary Search
• 贪心 Greedy
• 数学 Math, 几何 Geometry

2.2 Deliberate Practicing 刻意练习

• 过遍数（五毒神掌）
• 练习缺陷、弱点地方

2.3 Feedback 反馈

• 及时反馈
• 主动型反馈（自己去找）
  • 高手代码（GitHub，LeetCode，etc.）
  • 第一视角直播
• 被动式反馈（高手指点）
  • Code Review

三、切题四件套

3.1 Clarification

确定对题目的正确理解

3.2 Possible solutions

脑海里过一遍所有可能的算法

1. compare (time/space) 对于各种可行算法的时间复杂度和空间复杂度
2. optimal (加强)

3.3 Coding

多写

3.4 Test cases

四、五步刷题法

第一遍

• 5分钟：读题 + 思考
• 直接看解法：多解法，比较解法优劣
• 背诵、默写好的解法

第二遍

• 马上自己写 -> LeetCode 提交
• 多种解法比较、体会 -> 优化！

第三遍

• 一天后重复做题
• 根据不同解法的熟练程度进行专项练习

第四遍

• 一周后反复回来练习相同题目

第五遍

• 面试前一周恢复性训练

五、环境设置和编码技巧

• 工欲善其事，必先利其器。
• 自顶向下的编程方式

总结可能写的比较突兀吧，临时有事周末要飞走，没有办法在周末上传心得体会了。
第一周的时间遵照老师的教学开启了“五毒神掌”的刷题方式，不得不说，不管是在上班的路上，还是在临睡前脑子里面都还有算法题在脑子里面回荡。本以为简单的数据结构自己已经掌握的蛮好了，可是到做题的时候发现对代码的熟识度还没有达到很高，导致自己又开始扒jdk中的源码，挨个属性方法的去查看。在工作中用到了python，这一周明显对方法中的各个数据结构的使用更加小心了。
由于可能事情来的比较急，第一周的心得比较水，后续有时间把自己的研究替换上来，和大家一起分享讨论～

看完覃超老师的视频，主要自我总结了以下几点：
1.不要太相信自己的直觉和能力，一道题目看着会不一定是会写，一道题目写出来也不一定是最优，一道题目这次写的算法优，不代表以后也能写的优，总而言之，多练多思考，真正融入心里才能百战百胜；
2.构建一个思维的脑图是一种很棒的学习方法和思维习惯，这就像人的成长路径一样，一颗树能够面面俱到的包含了身上所有的已知区域和未知区域，希望可以通过这个课程可以慢慢把自己的未知区域填充完整；
3.学习新知识不能执拗，在视频中我很赞赏覃超老师的一段话“如果实在想不出来，就去看答案”，不要太过执着于某些点或者想法，在如今变化巨大快的社会下，只有掌握一个好的学习方法，有机会站在巨人的肩膀上去思考问题、探索问题是一个非常少有的机会，为自己加油，也为身边的小伙伴加油，一起努力达到自己的目标。

• 学习一项技能，首先要先掌握学习的方法，这样才能达到事半功倍的效果
• 如何快速习得一门技能？
  • 切碎知识点
  • 刻意练习
  • 反馈
• 对应到学习数据结构和算法上
  • 思维导图梳理整体脉络，熟悉各模块内容（20%）
  • 刷LeetCode经典题目（一道题至少5遍），刻意练习薄弱的地方（60%，占比最大）
  • 学习大神的解题思路，开阔思路，参与讨论接受review（20%）
• 同样，在刻意练习之前，首先要配置好高效的编程环境

这个课程最触动我的一句话：职业顶尖级别 - 对于算法数据结构的理解。
学习方法总结：
1.自绘 数据结构与算法 脑图
2.每学习一个知识点都去 1的脑图上完善相关分支节点。
3.每个知识点的HomeWork，执行 “五毒神掌”练习法。
4.主动反馈（自己练习的每道题均到LeetCode英文网站上，看排3名的思路和代码）
5.分析每个练习题的算法复杂度（时间和空间）。

本周课程的学习，有两点体会比较深：

第一，做算法题时，如果不会直接看答案。以前我在做题或实际工程中，遇到不会的算法，先是自己想几种解法，之后的要花大量时间试图证明这些解法的正确性和完备性。但是实际上我并不擅长数学证明，每次浪费了很多时间，还常常因为完成不了证明，直接放弃，回归到原始的暴力解法。�应该按照老师说的方法，不会时直接看解法或者搜索解法，逃过证明步骤，直接记住结论，这样效率会更高。

第二，对于IDE的刻意训练。这一点在我之前的工作中一只是忽视的，很少系统的学习IDE的使用方法。本周，我找了Intelij的一个Command+1的用法，在工作中强迫使用，感觉经过一段时间联系以后可以改掉之前一些不好的习惯，提升编码效率。

我将3节课程中讲到的 数据结构和算法、编程风格和算法学习方式、时空复杂度这个三个主题进行了脑图誊抄、和课程摘录整理，制作了一张新的导图

导图：

1、Queue 主要是一个接口， 包含了offer, pool, peek 有返回值无异常处理 ， add, remove ,element 有异常返回。
2、Priority Queue 基于堆实现，且不支持空值。 优先级队列默认使用自然循序， 用户可以通过实现 Comparator 方法自定义优先级顺序。该 实现并不是线程安全 ，如果多线程访问可以使用PriorityBlockingQueue.

Deque 示例代码改写 ：

Deque deque = new LinkedList();

deque.offerLast(a);
deque.offerLast(b);
deque.offerLast(c);
System.out.println(deque);

String r = deque.peekLast();
System.out.println(r);
System.out.println(deque);

while (deque.size() >0 ) {

System.out.println(deque.pollLast());

}

System.out.println(deque);

经过一周的学习,对于数组和链表,栈,队列,双端队列有了更深的了解. 并且通过做题,发现了自己在思维上的一些误区,譬如merge-sorted-array(https://leetcode-cn.com/problems/merge-sorted-array/) 开始的时候就习惯性的从头向尾遍历,但这样做还需要引入另外一个新的数组,因为无法将原有的数据向后移动; 通过看过其他优秀的解法后,才发现可以从尾向头遍历,虽然整体的处理逻辑和最初我想的差不多,但却节省了复制一个数组的开销,大大提高了性能. 以前从未接触过这些题目,通过此次学习才发现原来还有其他更为精妙的思路. 争取以后将这些好的思维融入到工作中,提高自己的工作效率.

建议: 如果老师能够再多介绍一点这些算法再实际中使用的案例就好了.譬如队列/栈等通过在实际工程中何时会用到; 同时这些算法,在应对大数据量的时候,会是如何表现;在设计程序的时候,该如何思考等. 仅仅是讲解算法题,感觉有点单调了.

预习周总结：

一，数据与算法结构总览

Chunk it up : 切碎知识点，庖丁解牛，并要建立各个知识点的联系，成树状的知识体系
It’s important to view knowledge as a semantic tree. Make sure you understand the fundamental principles ie: the trunk and big branches before you go into the details/leaves or there is nothing for them to hang on.

Deliberately practicing :
注意基本功的训练。因为基本功是区别职业和业余选手的根本。所以要将基本功进行分解训练和反复练习(具体分解见算法和数据结构脑图)。最大的误区是只做一遍。具体来说需要刻意练习过遍数。越是自己薄弱不舒服的地方越要坚强练习。虽然痛苦，却是一个长肌肉的过程。

Feedback :
主动反馈: 看leetcode 排名最高的discussion,看网上高手的算法和视频讲解

被动反馈: code review

2. 切题四件套：

   Clarification

   Possible solution

Compare (time/space)
Optimal
Coding (多写几种解法)

    Test cases

3. 五步刷题法

二，训练准备和复杂度分析

Code style:
以前都是visual studio IDE ctr+k, ctr+l 自动规范代码格式。现在自己手写代码时得刻意去模仿vs的代码格式。这样可以让自己的代码风格更readable,也可以减少自己 对IDE的依赖。

掌握自顶向下的编程方式：
自己在编代码和逻辑比较复杂繁琐的题目时经常因小失大，总觉等漏洞百出总是无法面面俱到。其实联系到前面所说的树状的知识体系，在编程时也要先把思路的主干编好，小的细节可以先用一个未实现的私有方法来表示，等到最后才回去实现。小技巧，在写私有方法时，虽然可以先把实现放在一边，但需要想好并写清楚specification,即其母的，输入参数和输出结果。这样可以保证思路的清晰度和一致性。千万不能说这个细节我没想清楚它用来干嘛的，所以先忽略。一定是先想清楚这快步骤是干嘛的，才有足够的信心来说我待会回来实现它。要不等回来实现后只会一头雾水，如果思路错了回来后更可能否定了自己之前的所有思路。所以就像backtrack一样，每一步的decision都要准确的进行validate.

三，时间空间复杂度：

O ( n! ) > O ( 2 ^n)

精通一个领域需要三步：
1、把这个领域的大块知识点分割成小块知识点（chunk it up）
2、对每个小块知识点进行刻意的练习（Deliberate Practicing）
3、在练习的过程中，需要外界的反馈，来加深对知识点的理解（FeedBack）
对数据结构和算法进行 Chunk it up：
1、数据结构：
​ 一维
​ 二维
​ 特殊
​ 2、算法

Deliberate Practicing：
​ 五毒神掌（练习五遍）
​ 练习缺陷，弱点

FeedBack：
​ 及时反馈
​ 主动型反馈（自己去找）：
​ 高手代码（GitHub，LeetCode）
​ 被动式反馈（高手指点）：
​ Code Review

使用五毒神掌练习题目注意事项：
​ 切题四件套：
​ 1. Clarification（读题，审题，弄清题目的含义）
​ 2. Possible Solutions
​ Compare
​ Optimal
​ 3. Coding
​ 4. Test Cases
​ 第一遍：
​ 5分钟：读题+思考
​ 直接看解法：多解法，比较解法优劣
​ 背诵，默写解法
​ 第二遍：
​ 马上自己写 ---> LeetCode提交
​ 多解法比较，体会 ---> 优化
​ 第三遍：
​ 过一天，再重复做题
​ 不同解法的熟练程度 ---> 专项练习
​ 第四遍：
​ 过了一周：反复回来练习相同题目
​ 第五遍：
​ 面试前一周进行恢复性训练
​ 最大误区：只做一遍
养成自顶向下的编程方式（像报纸的排版一样，上面是概括，下方是细节）

要求

1. 每周从覃超老师布置的题目中，至少完成并提交两道算法题
2. 围绕每周重点学习的算法知识点，撰写一篇有观点和思考的技术文章或总结，切忌流水账。

作业提交 Deadline

2019年10月27日 23:59 （以当地时间为准）
未按时提交作业，会在个人作业总分中 -3 分

本周作业概述

本周需要完成学习的视频内容：

• 第 5 课 | 哈希表、映射、集合
• 第 6 课 | 树、图、二叉树、二叉搜索树
• 第 7 课 | 泛型递归、树的递归
• 第 8 课 | 分治、回溯

以上两课视频后，覃超老师都给出了大家可以练手的算法题。

本周算法习题库：

第五课

写一个关于HashMap的小总结
说明：对于不熟悉Java语言的同学，此项作业可选做。
请大家将HashMap的小总结放在本周学习总结中一并提交
https://leetcode-cn.com/problems/valid-anagram/description/
https://leetcode-cn.com/problems/group-anagrams/
https://leetcode-cn.com/problems/two-sum/description/

第六课

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/
https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/
https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/

第七课

https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/
https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
https://leetcode-cn.com/problems/combinations/
https://leetcode-cn.com/problems/permutations/
https://leetcode-cn.com/problems/permutations-ii/

第八课

https://leetcode-cn.com/problems/majority-element/description/
https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/
https://leetcode-cn.com/problems/n-queens/

线上课程
预习 — 基础知识自己预习和查看
互动 — 一起思考、回答问题
练习 — 按照办法切题

精通一个领域
切碎知识点 Chunk it up
庖丁解牛
脉络连接
刻意练习 Deliberate Practicing
基础动作的分解训练和反复练习
五毒神掌(最少刷5遍）
练习缺陷、弱点地方
反馈 Feedback
主动形反馈（自己去找）
高手代码
被动反馈（高手指导 ）

切题四件套
看题
找到所有的解法，比较时间复杂度，寻找最优解
解题
验证

五毒神掌
5分钟读题+思考，不会的就看解法。寻找多解法，比较优劣，，背诵默写好的解法
解题，多解法比较，优化解法
1天以后，重复练习，多练习不熟的解法
1周以后，反复练习
面试前恢复性训练

改写Queue：
Deque deque = new LinkedList();

    deque.addLast("a");
    deque.addLast("b");
    deque.addLast("c");

    System.out.println(deque);

    String str  = deque.getLast();
    System.out.println(str);
    System.out.println(deque);

    while (deque.size()>0) {
        System.out.println(deque.removeLast());
    }
    System.out.println(deque);

PriorityQueue源码分析：
1，首先，我们先写一段代码，方便进行源码简单分析：
PriorityQueue priorityQueue = new PriorityQueue();
priorityQueue.add(1);
priorityQueue.peek();
priorityQueue.poll();
2，构造函数
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
跟进去，我们发现，这是一个数组，默认容量为11。同时可以发现。优先级队列也可以使用传入的Comparator对象做比较器，没有的话，就得传入的对象实现Comparable接口。

3，我们跟一下Add方法：
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
int i = size;
if (i >= queue.length)
grow(i + 1);
size = i + 1;
if (i == 0)
queue[0] = e;
else
siftUp(i, e);
return true;
}
忽略扩容等其他逻辑。我们只看插入数据。发现，如果下角标为0，则添加到数组的第一个元素里，否则，使用siftUp函数添加节点。
private void siftUp(int k, E x) {
if (comparator != null)
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
可以发现，siFtUp函数根据比较器类型走了2个分之，我们只看一个分支即可。
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
int parent = (k - 1) >>> 1;
Object e = queue[parent];
if (key.compareTo((E) e) >= 0)
break;
queue[k] = e;
k = parent;
}
queue[k] = key;
}
以上代码我们可以得知，原来queue数组存储的是用数组表示的小顶堆，第0个元素是最小的。插入新数据的时候 向堆顶堆化。时间复杂度为O(logN)

4，跟一下peek方法
public E peek() {
return (size == 0) ? null : (E) queue[0];
}
peek方法很简单，其实就是返回第0个元素，因为它最小。

5，跟一下poll方法()
public E poll() {
if (size == 0)
return null;
int s = --size;
modCount++;
E result = (E) queue[0];
E x = (E) queue[s];
queue[s] = null;
if (s != 0)
siftDown(0, x);
return result;
}
发现是将size减小。返回第0个元素。最后调用siftDown进行调整。调整的目的就是将剩下元素里最小的放到第0个节点。
private void siftDownComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>)x;
int half = size >>> 1; // loop while a non-leaf
while (k < half) {
int child = (k << 1) + 1; // assume left child is least
Object c = queue[child];
int right = child + 1;
if (right < size &&
((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
c = queue[child = right];
if (key.compareTo((E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = key;
}
从子节点往前逐渐堆化poll时间复杂度。O(logN)。

本周学习总结：
学习数组和队列。
1，本周学习到了一些双指针法的应用。
2，一些技巧：做链表题时带头节点的使用。
3, 分析最小子问题。

标题格式：【学号后三位+week1】（如果是第二周就是week2，以此类推）+文章标题

正文部分，字数不限。

心得&总结

学习方式

内容切碎(chunk it up )

先把内容切碎

着重练习

针对自己薄弱的，不擅长的内容，着重去练习。

切题方式

1. 先详细了解题目
2. 罗列出能想到的所有解题方式，选择最优解(时间复杂度最低)
3. 写代码
4. 使用测试用例进行测试

刷题方式(五毒神掌)

同一题至少做5遍

1. 读题、思考(5-10分钟)
2. 没思路：直接看解法，比较解法的优劣，背诵，默写最优解
   有思路：则自己思考即可
   写代码，然后运行，看结果
3. 一天后再做一次
4. 一周后再做
5. 面试前一周，做做一遍

工具&代码风格

1. 统一代码风格
2. pycharm代码编辑器， mac使用iterm2 + zsh

时间复杂度

一段代码的执行次数
常数执行次数: O(1), 不论是1次，2次，3次都是O(1)
线性执行次数: O(n), 随n的增长同步增长
O(2^n)
O(n^2)
O(n^3)
O(log(n))

1、画了自己的脑图，依靠这个过程，归纳了下自己的算法和数据结构的知识点。需要提升得地方还很多，希望学完之后，能从自己脑海中画出老师给得脑图。
2、跟着老师学习了学习方法。多思考，多切片，多练习。
3、搭建了环境，leetcode刷题。
4、学习了时间复杂度的计算方式 。

对于API ，我们希望函数越多越好，方便使用，但是要注意不同版本之间的写法的不同点
不同的名字，可能是干一样的事情，
掌握多种用法，读别人的代码时，就会容易些。
`
public class DequeDemo {

public static void main(String[] args) {
    Deque<String> deque = new LinkedList<String>();

    deque.addLast("a");
    deque.addLast("b");
    deque.addLast("c");
    System.out.println(deque);

    //peekFirst获取栈首元素后，元素不会出栈
    String str = deque.peekFirst();
    System.out.println(str);
    System.out.println(deque);

    while(deque.size() > 0) {
        //removeFirst获取栈首元素后，元素将会出栈
        System.out.println(deque.removeFirst());
    }
    System.out.println(deque);
}

}`

通过2节的预习课知晓了一下几点内容

1,要精通一项领域的三步:

(1)chunk it up
(2)deliberate practicing
(3)feedback

2,切题四件套

• Clarification

• Possible solutions
    
    • compare (time/space)
    
    • optimal（加强）

• Coding（多写）

• Test cases

3,五步刷题法

第一遍:

• 5分钟：读题 + 思考 

• 直接看解法：注意！多解法，比较解法优劣

• 背诵、默写好的解法

第二遍:

• 马上自己写 —> LeetCode 提交

• 多种解法比较、体会 —> 优化！

第三遍:

• 过了一天后，再重复做题

• 不同解法的熟练程度 —> 专项练习

第四遍:

• 过了一周：反复回来练习相同题目

第五遍:

• 面试前一周恢复性训练

4,在提交作业过程中熟练了过去没怎么接触的github使用方式

5,配合学习王争老师的《数据结构与算法之美》效果更佳~
《数据结构与算法之美》里讲解时空复杂度的内容更为详细，同学们可以配合学习下。

感想心得

• 需要系统了解常用的数据预算法，以点带面，形成体系（例如思维导图）
• 需要系统的刻意练习，有规律进行反复训练，才能熟练运用，进而在解决实际问题，开拓自己技能
• 需要思考，深入解题思考场景，才能在各种解题方法有多方面的深刻体会，
• 工欲善其事，必先利器，实际开发当中，也需要刻意练习工具使用技能，从而提高效率（这个效率提高随着N时间增大，会节省出成倍的时间量）

目标

希望自己深入进去，经过科学的系统训练，把这块知识啃下来，印记心中。希望我从战场中凯旋归来。

预习周学习总结

首先自己参考老师的脑图画了自己掌握的拓扑图，对自己所掌握的知识做了一个系统的总结。
学习了老师的五毒神掌（五遍刷题法）
然后按照老师的建议设置了自己的环境以及工具，并学习了Google的code style。
最后跟着老师系统的温习了算法的基础：复杂度的分析。

用add first或add last这套新的API改写Deque的代码
Deque deque=new LinkedList();
deque.add("u");
deque.addFirst("a");
deque.add("b");
deque.addLast("8");
System.out.println(deque.peek());
System.out.println(deque);
while (deque.size()>0){
System.out.println(deque.removeLast());
}

分析Queue和Priority Queue的源码
Queue是JDK提供的队列顶层接口，
offer(插入元素)
peek(返回队首元素，没有择返回null,不移除元素)
poll(返回队首元素，没有择返回null,移除元素)
remove 返回队首元素,队列为空抛出异常NoSuchElementException,移除元素)
element(返回队首元素,队列为空抛出异常NoSuchElementException,不移除元素)

Priority Queue 无界队列 元素必须是实现Comparable接口，不允许有null元素
这个类是线程不安全的，多线程场景需要使用PriorityBlockingQueue，
在插入元素时，默认会自动排序