有状态的计算：每时每刻都存在一个状态，  eg，天猫的成交额每时每刻。

文件和数据库：  关系型数据库存储大量的描述性词语文件。  eg：key，  szie，  path，

 

单机服务器的优点：易于维护，没有网络故障，本地保存，

缺点：szie不够大，安全性容错性低，机器挂了，整个服务寄了

 

应用服务和数据服务分离：分成3个服务器，应用，文件，数据库服务器。  

 

提高了负载能力，和容灾能力。

问题：重复访问的话有重复的请求，都要数据库找path，然后文件服务器进行拼接文件片段返回目的文件。  每次操作都要同样进行，导致速度降低。

因此用到缓存，加快访问速度。  本地缓存和分布式缓存。 前者速度快，容量有限。 后者无限容量。

eg。病毒检测结果也可以存到缓存里，不用重复检测同样的地方。

 

负载均衡调节器，常用Nginx。

 

数据库服务器：主从。  从进行读，主进行写，然后主从复制。

 

CDN，内容分发网络，根据用户地址调配距离最近的服务器提高响应速度。

 

 

 

 

 

• transcation driven

 

事务驱动，eg：  打车软件，外卖软件，  有不同的模块“pay， order。。。”都是跟client进行联系。  两两之间也有rest api等进行联系（用户看不到）

 

CAP原理：consistent， availability，partition tolerance。

不同服务器中一致性，可获得性，一直有响应，  某台机器挂掉，剩下的机器也能用。

 

3个之中只能有2个：  CP：金融系统，强一致性， A不行因为要所有机器奔跑起来检车一致后才能响应。

 

AP： 某些机器挂了，可以先提供本地副本，所以牺牲了一致性。eg：买东西：看的时候有库存，但付款发现没有库存，

 

transaction：  事务性应用，买东西：order，inventory，payment，三则同时成功或者同时失败。

 

但是缺点是eg：  实时流计算：每秒有很多请求，不同请求，不能完成数据量非常大的应用，无法进行数据聚集（付款方式，付款人名字。。。）。

 

• event-driven 驱动

是从event log里面，不需要知道很多的信息：姓名，付款方式etc。  

现在是event trigger action 来write到log，然后产生其他的application

 

OLAP：  online analytical  processing。

 

eg：8/1  8/30的数据汇总分析。

如果定义状态，每天就可以知道每天的数据分析和任务操作，这样9/1就可以直接方便知道

 

 

 

regular expression

 

 

script和非script区别

：脚本编译和运行一起，跑一行一行

。  c++等先编译在运行

 

 

extraction-based summarization算法

abstracion-based summarization

text-rank

youtube 字幕api

BERT

07： ATTention 论文

getgpt

theb

test_chat_completion.py.  stream:flase

duplicate 副本

 aurora 30秒还是会造成一小部分数据缺失

 

SWF。simple。work。flow

 

横向发展：多买机器，。纵向发展、单个机器rong liang

事务机制：同时成功或者fail， 比如说银行转帐

 

 

N o s q l

dynamoDB

S3

react :HTML,Javascript,菜鸟教程

• 进阶链表
• 进阶树
• 进阶图

 

• 进阶链表

双向链表，

例题 430  .   dfs即可

 

异或链表

 

• 进阶树

segement  tree

，  节点里面能存储区间

 

303.  问题在于如果调用很多次怎么办，可以用新的存储空间来存储，

 

Trie： 字典树

 

平衡树

 

N 叉树

 

B树 

 

红黑树

maimimum moving avarage:

 

maimimum moving max:

:可以一用heap么。不可以，因为不知道pop的是不是头

：可以用sorted stack

：思路：，squential,,,每到一个ele时，有可能时后面max，所以先判断前面《的话，删掉然后加上本个ele，》的话直接加上，因为stack村的是有可能是max的东西。  如果move 后out of window，先删除对应操作，这样stack顶永远是max当前window。   

这样用的就是deque，或者double linklist，

out of window 的时候要注意判断头部是不是out？ index stack:记录index，，然后j-i>=k，就是out  of window

 

dfs  stack的模板：

DFS(s,g):

   stack s,

   end constraint g,

  initilaize s:  push first node to s and visited hashet, parent hashmap.

  while(stack not empty:){

            pop node;

           if(cur==G) return 

           for (each neighburs not visited){

                 add neighvbut to visited

                add cur as parent of n

               push n onto stack

 

 

 

 

 

• 图论

1.Maze  ,  2D array,  赵路径

例题：maze II。

 

使用的三个数据结构：“hash set, bisited”"hahmap,path"  "stack或者queue"

 

C++中可以用vector<bool>也可以待变visited

看题目要求是不是要path，如果去找neighbour，  

 

Maze中可以用i,j+-1,或者用一个direction矩阵代表更多方向，然后for循环去迭代方向

 

2. 2D array   all points

 

flood fill.    填色

 

思路：single point dfs/bfs都可以，  时间complexity都一样  |V|+|E|.

dfs  的recursion的代码量简洁。

 

 

例题：number of island。

思路，for矩阵，然后dfs开始，碰到1就边0，然后整体计算number

，all points 的dfs就是for single point的dfs

   

3。 friend circles,  邻接矩阵，像但由于是一个对角线的all points

可以用dfs找path，如果能有一条path，说明一个circle，没有说明第二个circle

for  i  是代表人，利用visted代表circle，dfs之后count++就是circle的数量

 

 

4.  例题：pacific atlantic water flow.

还可以用dp的结果，避免重复计算

，可以：aLL points+DP

DP里面不同的值来代表不同的意思

还要回溯，底部true，回溯回去也要true，一路的retrun

selected point:

 

 

5. non 2D array   

 

例题：word ladder

 

思路：每个word是一个vertex，

可以用stack。

要解决的问题：neighbour，hashset，hahmap，start

这里难点在于如何判断neighbour，

 

思路，可以对于当前单词进行每个位置的字母改变，然后find 字典里是否有出现。

 

BFS可以求最短路径

• sliding window

属于2 pointer的子集，都是从前往后走

例题：remove duplicated from sorted array

思路：end往后走直到最后一个different。然后start是第一个diff， 所以in place的算法是吧dif的ele move到start，start+1.

so  start： is the first distinct的position

end是来判断，if dif的话就跟start换位置，if equal则end+1

 

思路：hashset可以用，o(n)和o(n)

duplicates可以用hashtable

例题：如果diuplicate的出现次数k，

 

思路：那么判断start的前面有几个，或者判断end-2和end是否一样或者j-i>=2

 

例题：remove element:（inplace）

start是第一个1的位置，然后end是non-1，然后swap，然后i+1，j都要加1，

所以一开始的start是先找到对应1（要先for），也可以不用

for(int i,j;i<len&j<len;j+1){ if (nums[i]!=1) start+=1}

 

例题：  maximum average subarray.

start 是maxim的start。  end++，一个global max，然后更新start。end往前数，然后maximum可以减去头+尾。单个for就可以

思路：也可以累加，然后减去前面k的元素当前的和，然后就是当前的k个和

例题：sliding  window 3

 

思路：rolling hash,利用hashcode计算，而且可以偷懒，类似于上面的去头加尾

 

 

例题：subarrayproduct less than k

start和end,end先移动到最小不满足，然后startmove到满足，这其中每一个sub都是满足的

但是计算的是number，而不是每一个subarray，所以j-i+1是多的validwindow，计算

 

例题： sliding window 2：

 

例题：minimum size subarray sum

 

思路：start，end中间的和，global存储当前的最短，if sum>k,则start+1. 然后继续end+1判断。  start<end肯定

for内嵌while （i），但是i和j相对独立，所以时间复杂度是O（n）

 

例题：sliding window IV

 

例题：longest substring without repeating characters

 

 

区分subsequence和esubarray

遇到duplicate，repeateing，exist，unique都可以用hashmap来解决

 

例题：47 permutation 2：

input 有重复，有一个i-1的non-visited判断

 

例题：131，palindrome  partition,实际上是个组合问题，可以用组合模板，先判断前面的substring的是不是palidrome，然后对于后面的substring进行dfs。

优化：dp的memorization将已经pali的存起来

 

例题：44  .1h

 

• Trie字典树

add and search words

复杂度：O(M)就是最长单词长度，space复杂度：字母表长度*key——length（比如说一个char）*key个数

例题：add and search words

要在对应word的结尾标记一个证明是一个word。

trie是用hashmap实现的

 

例题：auto-complete system: 

 

例题：word search 2.   212.因为input是字符串，所以可以用trie来节省一部分时间，

 

回溯的时候要标记回来，visited.true. dfs(),

visited=false

 

 

trie:

class TrieNode{TrieNode[] next= new TriNode[26],   String word}，要标记当前是不是一个word，这就是flag，可以灵活变通，也可以把当前的词存进去

 

 

notability

例题329.1h17min

 

 

valid  括号问题 例题

背包问题

例题：301

 

DFS，去重复剪纸

BFS?

 

经典：number of island

 

例题：827

making a large island

复杂度：n2,当前点

例题：312

 

例题：  子问题互相影响，dp[i][k-1]

dp[k+1][j]，定义是两边不能炸

 

• DFS&BFS

tree上边的tranversla和divi&&conquer就是DFS

 

 

BFS，binarty tree level-order tranversal一层一层的走就是

图和tree： tree,没有cyce，dfs不会重复，图可能有环，可能死循环如果不记录的话

 

 

where you can search:tree，graph，Combination of Linear structures(array,string, number)

 

LTC 102: binary tree level order Traversal

.BFS用到了queue，FIFO 

stack可以实现DFS，不过先right child然后leftchild，这样可以保证print先left在右，因为stack的先入后出

BFS有模板

 

1h27  例题： 200 number_of island，可以使用DFS，或者queue的BFS

 

1h40  例题：78subsets。  sort，避免重复的number。

使用递归实现combination，复杂度exponential

• combinatoin

 

所有combination的题目有一个模板2h06

先sort！！！

result。add中 new arraylist(subset)?deep copy

startindex看看是否可以服用，可以复用，i不变否则i+1

例题：90subset2.  2h09， 加上一句判断现在和前者是否一样，并且不能越界。

这样就不用单独新建一个vecotr去重了

 

例题：39  combination sum 

40Com sum2.  右duplicate

216  com sum3.  size=k的sum=target

 

helper必须传的参数，startindex，原始array，每层的solution，总的result

 

 

• 排列，有顺序有模板

46.permutation。2h31min

所有的数都要被选

permutation 2例题，

 

 

 

• DP 问题

算法原理：

1. 可以表示成离散状态的相并列和矩阵形式，每个元素代表子问题最优解。子问题不依赖更大的子问题
2. 最终最优解是多个子问题的最优解来确定（多个状态同时），如果一个状态就是greedy
3. index最小的子问题解已知
4. 状态转移方程
5. 两个方向：“top-down”来分析问题然后bottom-up来优化问题/
6. top-down一般用递归来解决，bottome-up一般是iteration来解决

算法复杂度：

1. time complexity：某些子问题解应用不止一次，所以memorizaition来节省空间
2. space complexity：“某些解只用几次，因此不必在存储”

例题：longest in creaseing subsquence 

 

greedy，使用的话要证明一下多个状态可以用一个状态解释

 

例题：  wiggle subsqueece

 

例题：背包问题

 

例题：96  unique binary search tree

numtrees(n-2)*num(1)+.... numtree(1)*nums(n-2)， 左右子树排列数，因为bst型确定了，数也就确定了

 

例题：括号问题，和上面类似

 

 

例题：edit 。。。。  状态转移方程。 1h23 min

例题： pattern  matching  ：44  wildcard mathcing

 

 

例题：permutations for di sequence

• 贪心算法和DP

贪心算法：

定义：选择的贪心策略必须具有无后效应，寄某个状态之前的过程不会影响以后的状态，只与当前状态有关。

需要判断一下当前的最优解是不是最终的最优解。

 

最优子结构：当问题的最优解包含子问题的最优解的时候

 

局限性：

1. 不能保证最后的结果一定是最佳的。
2. 不能有来求最大或最小解问题
3. 只能求满足某些约束条件的可行解的范围

上节课的dikistra，prim，krukal算法都是贪心算法。

上述算法也都有一些限制条件，就是为了约束最后的最优解的

 

大部分例题都能有DP解

例题：455： assign cookies。40min

 小给小，大给大，可以sort后双指针遍历人和饼干，

122：Best time to but and Sell stockII

53：

134：gas

55： jump game。 只是求哪里开始可以完成目的可以贪心，但是求最小步骤不能用贪心算法。

 

总结：贪心算法主要是针对一维问题，不需要独立，DP是前后有关系，需要记录

 

 

• 动态规划

讲一个问题拆分成几个子问题，分别求解子问题。

步骤：

1. 划分阶段，有序或者可排序（无后序性）
2. 选择状态（无后行）
3. 确定状态转移方程（根据上一阶段状态到处本阶段方程），确定了决策，状态转移方程也就出来了
4. 写出规划方程，只需要写iterative的，不要写recursive。

 

重点：初始状态，和状态转移方程。

基本要素：

1. 重叠子问题：用到之前很多数的结果，比如fibncci。
2. 最优子结构
3. 无后效性，保证之前的状态都已经更新完了才能拿来用，不能够用完这个数据后这个数据还在更新。 循环的顺序和倒序等等。

 

要学会问题归类：尤其是DP问题。例如二维DP，写两层循环。。

一般是最大利润或者最小误差等

例题：198：house robber。

初始条件：最大财务=0.

状态转移方程：每次到房子的时候利用和前面房子的关系，限制条件：不能连续抢。一般来说最后求最大财务数，每一步也要求最大财务书。

对每个房子状态两个：抢或者不抢，强的话：i-2的财务+当前财务。 不强的话：i-1的财务。

一般不用矩阵，因为只跟前一个或两个有关系。直接用几个变量表示就行。 矩阵的话一般是跟前n个有关。

 

 

• 卖股票系列：

状态转移，当前状态买，卖，不做。

初始值：一般来说是最大利润，

然后加上边界调节。有可能要加矩阵的维度，eg.cooldown

例题集合：1h24min

121.。。。。。。

 

 

贪心算法和动态规划的关系：

相同点

1. 都是一种递推算法
2. 均有局部最优解来推导全局最优解

 

不同点：

• 贪心算法（了解即可，自己做的时候看懂就好）因为要证明最优解还需要时间而且可能会错

每一步的贪心决策都无法改变，之前的最优解不做保留，每一步的最优解一定包括上一步的最优解

 

• 动态规划

（只要掌握动态规划就好，）

 

 

• 区间调度问题

最多区间调度问题，可以通过贪心算法1h48min

最大区间：只能用DP

 

例题：56 merge intervals. 2h07min

435

452

252

715 Hard

 

背包问题（leetcode 一般只有01背包和完全背包问题）。

2h17min，记得V的循环顺序

 

lintcode有很多例题

 

 

例题：25min

 insert Delete GetRandom.  类似API的设计

getRondom的话可以用math.random的方法。

hashmap，+array_list. 

但还有问题，重复加入怎么办，可以用val:list<indexs>

通常design的题要用更多的data structure去实现

 

例题 ：Longest Duplicate substring.47min

我的一点想法：既然重复，那么可以直接双pointer，看字母是否重复，有重复的话，计算substring长度，然后两个起点开始substring check就可以。但是abacabac的话不太实用。

hahsset的用较大一点的质数

nlogn算法。 比如说（0，5）（1，6），（2，7）这些遍历，如果没有就说明siez太大，然后检测size/2，检查（0，2）（1，3），。。。如果有的话，检查上稍大一点，（0，3），（1，4）.。

 

 

hashmap和hashset的区别，有collision？

 

 

• Treemap

 

Treemap红黑树，可以让key按照顺序排列，hahsmap不行 。用的是BST

C++有么？？？？map好像就是。Hashmap的好像是unorder_map的实现

 

complete tree： 所有层数除了最后装满，最后层数尽可能向左靠。（底层实现heap的一个用法）

 

 

例题：longest continuous subarray with absolute diff less than or equal to limit

 

brute force:for for确定subarray，内部还得两两对比，或者最大值或者最小值

优化：slidingwindow+treemap找最值（logn）如果>limit，移动左窗口，并且treemap.remove（num[left]）

而且treemap{val:{indexs可能重复}}，index要去掉最前面的，不存index的话找不到谁最先。比如remove 2:[2,3,5]，要是i=2的会把3和5的去掉，这样就导致后面的误判。

也可以用stack或者queue去优化，比如用global的量去存max差别？

 

例题：1h53min Data Stream as Disjoint intervals.

treemap ，找最值，最小的最大数和最小的最大数2h10min. key:value 就是low bound和high  bound,注意相连的合并情况 [1,2]和[4,5]插入3就变成[1,5]。

• HashMap和Hashtable的区别

Map interface.

Allow NULL(key);

unsynchronized.

not ordered。 eg:  2%16=2.  1%16=1，先存进去的数不一定排在前面。

底层都是array

 

• Hashfunction

选择质数，不然可能有公约数导致hash confliction。 

 

有hash confilct的话：

Separete chaining.可以用链表（linklist）连接起来所有同hash value的node。（主要记忆即可）。优化方向还可以是BST（访问时间logn）

或者Linear probing：当前confict，找到下一个，直到找到空位。 但是可能效率比较低。

Double Hashing: 发现conflict， 用secondary hash、

 

• rehash，根据load effector。

 

常见题型

1. sliding window
2. 利用hash思想去重，赵duplicate，0(1)时间查找
3. 有关cache的设计题

 

解题思路，一开始没想法先找brute force的复杂度，然后想办法优化。

例题： contain Duplicates. 利用hashmap（num[i],i），然后用一个pointer代表尾部， find有无相同，然后判断index是不是前面k长度以内的。 也可以put value的时候判断之前最近的index是哪个，然后更新掉value，index的pair

也可以排序好，然后用list《node》存储index和value，然后for去判断相邻的==value的index在不在范围内

 

例题48min：longest substring without repeating characters.   

可以用two pointer做法，然后hashmap存Slow和fast中间的字母判重复，然后重复了之后slow直接移动到fast的位置。不用慢慢移动。

 

 

例题：1h2min。 shortest substring contains the all given characters.

brute force。

而且这里hashpmap不能存index，因为"abbbc"，s就不能直接跳了，要一点点移动。f是未满足sunstring的时候移动，s是满足的时候移动。

检查hash是否符合的可以用for loop。 也可以用一个global variable match=n； hashmap里面存需要出现的count，出现一次hash里面对应元素-1. 然后match+1.也可以表示是否符合标准，这样就不用for遍历hash了

 

 

例题1h38min： repeated DNA sequences（）可以直接把所有10位长度substing存到hash，然后后面判断有没有出现过

还可以用bitmap，A：00，C：01，G:10:,D:11.  hashvalue作为key也可以，substring作为value

 

 

例题：LRU cache：hashmap

linkedlist只能表示加进cache的顺序，但是get（1）不能反映到linklist里面，

queue不行因为移动的不一定是开头和末尾，中间的无法改变。

思路2h17min处：hash存key，node，node是新class

• stack&queue
• binary tree&binary search tree

stack FILO，先进后出，可以用array implement

queue FIFO,先进先出，可以用linked list implement

Stack：应用：树上的递归DFS改写为iteration

Queue：应用：1.BFS   2. Moving average

 

Moving average. LC 346. Moving Average from Data Stream.   可以用moving window的题目

 

• 二叉树

单纯的二叉树，一父节点最多两个子节点，没有大小要求。link list也算是一个二叉树。

 

Balanced binary tree：对任一节点来说左右子树的高度差不超过一。

 

二叉搜索树：左边所有节点<=中间<右边所有节点，平均O(logn)，看看是不是balanced。

heap不能进行搜索的操作，只能保证插入删除元素时 logn。

 

 

• 二叉树

二叉树的遍历：可以用recursive

先序，中序，后序遍历。

叶节点的时候return；

preorder先序遍历：中左右

add;  traverse left; traverse right

inorder中序遍历：左中右。

traverse left;    add;    traverse right;

postOrder后序遍历：左右中 

traverse left; traverse right; add;

可以 go through一些树的list

 

• 遍历法（traversal）vs分治法

遍历法：依次遍历所有节点，遍历中做记录，对节点进行操作。每个结点的最大深度是上一次最大深度和当前深度的最大值，递归时当前深度+1。 可以用全局变量。 而且可能需要另加一个helper function来记录遍历中的cur_深度

 

分治法：先让左右子树去解决同样的问题，然后得到结果后在整合为整棵树的结果.一个结点的最大深度=左右儿子最大深度+1

 

例题：LC104. Maximum depth of binary tree.

 

 

例题：lc110： balanced binary tree。 细节，子树汇报的时候可以不只汇报height，还可以汇报boolean的balanced，或者用height-1来表示unbalance。因为，最下面子树不balance但是root仍有可能会判断为balance。

recursive经常写helper function，因为i可能return的value或者input可能不一样。

 

用stack表示inorder tranversal。without recursion。有个网站写了逻辑。

 

 

例题：LC173Binary search Tree iterator. 1h41min处

Lc98 validate BST。 1h42min。  可以用stack 来iterate tree，因为iprin出来的值一定是从小到大（BST）。

也可以用recursion来判断

BST上面的inorder tanversal一定是从小到大

 

 

LC938 range sum of BST. 可以用DFS和全局变量，recursive implement ation 。 2h00min

 

LC114. faltten binary tree to lined list. 2h4min. 遍历法可以，分治法，从下往上

 

作业：binary tree paths。

 

 

• 图 graph
• 图的基本概念
• 分类存储
• 遍历
• 最短路径算法
• 最小生成树
• 例题讲解（对于面试很复杂，所以题量少，）

 

 

• 图论

1. 图的组成。顶点+边

vertex：度degree（与他连接的点的个数之和）入度（所有接入该点的边数之和）和出度（outdegree）

边（edge）

 

• 图的分类

有向图和无向图。

有权图（每条边具有一定的权重（weight））和无权图（无权重或者权=1）。

有环图（如果遍历图的顶点，某个顶点可以被访问超过一次）和无环图（tree）。 （这是有向图的分类）

连通图（任意两个顶点都是连通）和非连通图（存在两个顶点不连通）和完全图（所有顶点和其他顶点是连通的）

 

• 图的存储方式

n个顶点的图有一个n*n大小的邻接矩阵，

一个无权图中1代表两点联通，0代表不连通

有权图中每个元素代表权重，0代表不相连。

无向图中，邻接矩阵关于对角线相等。

 

稠密图适合邻接矩阵，稀疏图适合邻接链表

 

邻接链表：每一个点存储一个链表指向所有与该店直接相连的点。 （增加或者删除复杂度更小）

有权图中链表中的元素值对应着权重

 

 

• 图的遍历

操作有+-vertex。

DFS:访问顶点v，依次v未被访问的邻接点出发，深度优先遍历，直至途中和v有路径相同的顶点都被访问。使用stack

若此时仍有顶点未被访问，则重新开始DFS

 

BFS：使用queue。从队列中取出一个节点然后直接将所有未检验子节点push到queue中。

可以用来解决最短路径的问题。但是需要存储的信息量很大。 

对于稀疏图来说，DFS容易陷进去最长的一支分路。

但是每一层数量过多，BFS也容易耗时。

 

总体来说，倾向于dfs，内存小，解决问题更多一点

 

例题：lc133. clone graph。42min处 

 

• 最短路径算法。
• dijistra算法

适用于非负权值的单源最短路径，斐波那契堆。

使用BFS。

 

• bellman-ford算法

无负权回路（一个回路的权值相加为负）的图每对节点之间的单源最短路径，并能检测负圈。

• floyd算法

权值有负的单源最短路径，但不能有负圈回路

• SPFA算法

有负权值，且欸有负圈的图的单源最短路径。

 

 

LC743 network delay time 1h53min，直接可以用dikistra

Lc787。bellman-ford或者BFS。kstop可以直接停

 

 

• 最小生成树。
• kruskal算法，prim算法

kruskal算法，

 

 

 

 

 

 

Lc873.length of longest fibonacci subsequence

 

back_trakcing   and recurrsive

dynamic programming:得到一个递归表达式

 

 

36：29 dp做法

 

作业：Lc1414. find the minimum number of fibonacci numbers whose sum is k

 

 

recursion 在 merging two sorted list里面怎么用。lc21

 

Lc82 removeduplicates from sorted list II  10min.  在53min处用递归，

Lc 658 Find K closet elements.可以一用heapsort，，

 

Lc 347 top K frequent element;

 

• quick select

 

Lc215   kth element in an array  可以用heap。也可以quick select

 

Lc973 k closet points to origin

 

LC56  merge interval  例题讲解， stack是啥啊，要先sort

Lc1288 remove covered intervals例题1：30min

lc252 meeting room 1h40min处例题

 

• binary search 

在一个已经排好序的数组上,O(logn )复杂度

先找mid=start+end。 array[mid]=val1,然后判断target，val1<target，就向右找，小于则向左找。重复上述过程， mid2=(end+mid)/2只取整数。

 

写一些函数的时候，先判断input是不是null或length==0？

某些情况下比如while(start+1<end)的话要单独判断end和start是不是target

为什么不是start<end退出，比如下面的例子，找最后一个出现的位置。【2，2】

while（start<end）{

   mid=(0+1)/2=0;

if (mid==target){  start =mid;}

}

应该用相邻或相等退出，即start+1<end;

求最后出现的位置： if找到了就向右找，

而且也要先判断end==target

第一个出现的位置，if找到了就向左找。

而且要先判断start==target。

 

而且mid= start+（end-start）/2 更不容易overflow，算是一个小的优化

 

模板：

while (start+1< end){

          mid=start+(end-start)/2;

         if(num[mid]==target)  {return mid}

         else if(  >){  end=mid}

         else{   start=mid }

        if start==target 

       if end==target.

}

 

 

推荐写一些子 函数维持宏观框架

 

 

例题： find K closet elements

思路： 可以先bSearch找到target，然后双指针两边走

先看输出类型，新建好。

然后先写出思路， 然后把子程序的接口写出来，定义出来，input和output，然后写出来子函数的作用：output是什么

 

 

• Heap

大顶堆和小顶堆，min-heap和max-heap。

每一个node满足：father>=childs (max)

                           father<=childs(min)

左右没有关系

 

binary heap representation:

  现在node为A【i】，

Arr[(i-1)/2] is the parent node.

Arr[2i+1] is the left child

Arr[2i+2] is the right child

 

复杂度：getMini() :对于Min-heap是一个O(1)

extractMin(): remove the root ，O（logn）

insert(): O(logn)

delete(): O(logn)

 

 

• 重点！！！！！
• top K的题右3solution

1. sort O(nlogn) 不是很好
2. quick select. (on avarge O(n))，有时候快有时候慢。要求是要进行该方法，必须已经拿到全部的数据，万一新来的data，只能重新来一遍
3. Heap O(nlogk)，只需要size 为k的heap， insert 每一次都是logk，然后比n次，现实生活中k远小于n。更适合Stream data，可以适用于新来的data，新来一个数是O(logk) 

例题：Kth largest element要用min-heap,因为和root比较，小的就不用insert，大的菜肴insert进去，因为，heap里面村的是k个最大的，

步骤：先建立一个k size的heap，直接加进去，然后对比,如果大于，则pop root之后push（元素 ）