2018阿里文学春招面试题

有序二叉树的中序列表（非递归写法）

我能想到的非递归写法就是自己用栈，实现上有两种方式：

• 在一个栈里面存放两种类型的元素
• 用两个栈，一个栈放结点、一个栈放数字

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。然后对于第二个文件中的每个字符串，计算哈希，判断第一个文件中是否包含。

转载于:https://www.cnblogs.com/weiyinfu/p/8577002.html