有序二叉树的中序列表（非递归写法）
我能想到的非递归写法就是自己用栈，实现上有两种方式：
- 在一个栈里面存放两种类型的元素
- 用两个栈，一个栈放结点、一个栈放数字
sta=new Stack()
sta.push(tree)
while sta.notEmpty:
now=sta.pop()
if typeof now == Node:
if now.right:sta.push(now.right)
sta.push(now.value)
if now.left:sta.push(now.left)
else:
print(now.value)
leetcode上面有这道题：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/description/
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
ans=[]
if not root:return ans
a=[root]
while len(a):
now=a.pop()
if type(now)==TreeNode:
if now.right:
a.append(now.right)
a.append(now.val)
if now.left:
a.append(now.left)
else:
ans.append(now)
return ans
最长连续序列
给定一个int数组，求数组中最长的连续单元。
如：[1,2,7,8,5,9,-2,3,4],答案是5，因为包含1，2，3，4，5是最长的。
要求O（N）时间复杂度，空间复杂度不限。
解：用两个哈希表beg和end，分别表示片段的开头和结尾。从左到右扫描数组，对于元素x，考虑它的两种情况：
- 它可以拼接到上一个片段
- 它可以拼接到下一个片段
这两个条件的取值有00，01，10，11四种情况，分四种情况讨论，拼接片段即可。
class Node:
int beg
int end
beg=dict()
end=dict()
for i in a:
if i+1 in beg and i-1 in end:
prev=end[i-1]
next=beg[i+1]
node.beg=prev.beg
node.end=next.end
del beg[i+1]
del end[i-1]
beg[prev.beg]=node
end[next.end]=node
elif i+1 in beg:
node=beg[i+1]
node.beg=i
del beg[i+1]
beg[i]=node
elif i-1 in end:
node=end[i-1]
del end[i-1]
end[i]=node
node.end=i
else:
node=Node(i,i)
beg[i]=node
end[i]=node
ans=0
for i in beg.values:
ans=max(ans,i.end-i.beg+1)
print(ans)
大文件求交集
有两个大文件，每个文件都包含50亿个字符串，每个字符串都是64B，求这两个大文件的交集。
解：用类似布隆过滤器的东西来判断是否包含某个字符串。布隆过滤器其实就是哈希，用一个bit表示是否包含。
首先对于第一个文件，开辟一个大数组（包含100亿个bit），对于文件中的每个字符串，计算哈希值，将对应位置成1。然后对于第二个文件中的每个字符串，计算哈希，判断第一个文件中是否包含。