Question

我一直在研究一个玻璃门的问题，这个问题是在我应该去的公司的一次公司采访中被问到的。问题是：

如果您拥有所有交易的公司，并且实时投入来自哪家公司正在进行交易以及交易量是多少，您如何维护数据，以便您可以执行前10名的操作以最有效率的股票交易公司

我想到了同样的解决方案。虽然我不确定它是否是有效的：你如何维护二进制搜索树。对于每个插入，您插入公司名称和交易的股票数量。

我的树的基本节点是：

class Node
{
String key; // company name
int volume; // volume
Node leftNode;
Node rightNode;
}

因此，在每个新插入时，我将继续插入树中。在最终检索时，我可以运行以下代码，直到全局计数达到10。

traversal(Node a)
{
 if(a!=null)
  {
   traverse(a.getRightNode());
   System.out.println(a.getKey()+a.getValue());
   traverse(a.getLeftNode());
  }
}

您对此解决方案有何看法？

Answer 1

您可以使用最小二进制堆数据结构来执行此操作，其中您维护一个大小为10的堆，并在每次拥有一个比top更大的新公司并将新公司插入堆中时删除顶部元素。目前堆中的所有元素都是目前排名前十的公司。

注意：在开始时添加所有前10家公司。

Answer 2

嗯，这里有权衡。您将需要选择您喜欢的内容 - 高效查找（获得最高K）或有效插入。看起来，你不能两者兼得。

您可以使用两个数据结构进行O(logN)插入和查找：

Map<String,Node> - 在公司名称中映射第二个数据结构中的节点。这将是一个特里或self balancing tree。
Map<Integer,String> - 从卷映射到公司名称。这可以是一个地图（基于哈希/树），也可以是heap，因为我们有直接节点的链接，我们实际上可以在需要时有效地删除节点。

可以在O(logN)中的第二个数据结构上获得前10个，并且插入每个元素需要按字符串查找 - O(|S| * logN)（您可以使用trie来获取O（ | S |）here） - 而不是修改第二个树 - O(logN)

使用O(|S|+logN)复杂度的特里总计获得前K和插入。

如果插入的数据数量是getTopK()操作数的指数 - 最好只保留HashMap<String,Integer>并在新数据到达时修改它，并且当你得到findTopK()时 - 按照this thread中的描述 - 使用selection algorithm或堆来在O（N）中执行。

这会导致O(|S|)插入（平均），O(N + |S|)获得最高K.

|S|是输入/结果字符串出现的长度。
此答案假定每家公司可以多次出现 输入流。

Answer 3

这个问题与另一个question非常相似，但几乎没有什么扭曲。首先，如果有人问我这个问题，我会问很多问题。我提前知道公司名称吗？什么是公司？他们的号码有上限吗？您的意思是时间效率或内存消耗效率还是两者兼而有之？什么是交易和顶级公司要求的比例？它没有指定，但我会假设大量的交易，并按需或在某个时间间隔显示前十名。如果在每次交易到达之后请求前十名，即使比{10}更大的N，堆将是无用的，并且整个算法可以更简单。我也假设时间效率。然后内存效率受CPU缓存行为的限制，所以我们不应该浪费它。

所以我们将顶部N存储在一些结构中，这将给我最少的成员快速。这对于大N显然是堆。我可以使用任何堆实现，即使是那些执行错误IncKey和Merge操作的堆实现，或者根本没有它们。我只需要Insert，Peek和Remove次操作。 10号是非常小的，我甚至不需要堆，特别是在具有良好编译器的编译语言中。我可以使用有序数组或列表甚至无序数组。因此，在我将提到堆波纹的每个地方，您可以使用有序或无序的数组或列表。只有顶级N中较大的N才需要堆。

就是这样，我们会在插入堆中时存储热门N公司name及其volume。

然后我们需要在某些K / V存储中跟踪公司交易volume。密钥是name。用于此目的的K / V存储可以是hashmap，trie或Judy。如果我们提前知道公司名称会很好。它将允许我们为hashmap计算完美哈希或构造最佳trie。否则，如果我们知道上限公司编号，那么选择好的哈希长度和桶数就会很好。否则我们将不得不制作可调整大小的哈希或使用Judy。动态K / V的实现并不比hashmap或Judy更好。所有这些K / V存储都具有O(k)访问复杂性，其中k是Key的长度，在这种情况下为name。在每个地方，我将提到下面的hashmap，你可以使用Judy或trie。只有在事先知道所有公司名称并且您可以定制超快速优化代码时，您才可以使用trie。

因此，我们将商店公司name作为密钥并交易volume到目前为止，flag表示在堆中存储在hashmap中。

所以这里有算法。我们将拥有包含堆的状态，堆中的公司数和hashmap。对于每个到达的公司mane和volume，我们将在hashmap中增加volume。然后，如果堆中的公司小于N（10），我们将把这个公司name和volume从hashmap添加到堆中（如果还没有）（根据flag并设置此标志）在hashmap中）。否则，如果堆已满并且当前公司不在堆中，我们将查看堆，如果当前公司到目前为止（在hashmap中）交易的volume少于堆中的公司，我们可以完成此交易并继续下一步。否则我们必须首先更新堆中的公司。虽然堆顶部的公司（意味着至少volume）在堆中的volume小于当前的堆，而且与hashmap中的不同，我们将更新此volume。它可以通过从堆中删除并插入正确的值来完成。然后再次检查堆顶部等等。请注意，我们不需要更新堆中的所有公司，甚至不需要更新所有不是最新的顶级堆公司。它非常懒惰。如果当前公司仍然比堆顶部更大volume，我们将从堆中删除公司并插入当前公司并更新hashmap中的标志。这就是全部。

简要概括：

存储由N订购并包含公司volume或直接索引到hashmap的前name公司的最小堆
volume可能已过期
将公司name作为关键字和最新volume的hashmap以及表示堆成员为值的标志
首先更新hashmap中的当前公司volume并记住
如果少于当前交易的公司
如果仍然小于当前公司，则删除堆顶部并在堆中添加当前的

此算法获得的优势是，交易volume只能是正数，因此堆中的volume只能小于正确的值，并且如果堆的顶部具有来自所有堆的最小值且仍然小于正确的价值，仍然比hasmap中的任何公司都要大，一切都很完美。否则我们必须将所有公司存储在堆中，使用max heap而不是min heap，实现IncKey并对所有交易执行此操作，并在hashmap中保留对堆的反向引用，一切都复杂得多。

处理新的交易时间复杂性很好O(1)。 O(1)是哈希映射查找，O(1)在堆中是Peek。堆中的Insert和Delete分摊为O（1）或O(logN)，其中N是常量，所以仍为O(1)。堆中的更新数为O(N)，因此O(1)。当公司编号的上限（开头提到的哈希图大小问题）时，您还可以计算处理时间的上限，因此通过良好的实现，您可以实时考虑它。请记住，更简单的解决方案（作为有序或无序列表，更新所有Top成员等）可以为小N的编译代码带来更好的性能，特别是在现代HW上。

这个算法即使在函数式语言中也能很好地实现，除了没有纯函数哈希表但是trie应该有O（1）行为或者会有一些不纯的模块。例如，使用有序列表作为哈希映射的堆和字典的Erlang实现。（我最喜欢的功能堆是配对堆，但对于10来说它是矫枉过正的。）

-module(top10trade).

-record(top10, {
    n = 0,
    heap = [],
    map = dict:new()
    }).

-define(N, 10).

-export([new/0, trade/2, top/1, apply_list/2]).

new() ->
  #top10{}.

trade({Name, Volume}, #top10{n = N, map = Map} = State)
    % heap is not full
    when N < ?N ->
  case dict:find(Name, Map) of
    % it's already in heap so update hashmap only
    {ok, {V, true}} ->
      State#top10{map = dict:store(Name, {V+Volume, true}, Map)};
    % otherwise insert to heap
    error ->
      State#top10{
        n = N+1,
        heap = insert({Volume, Name}, State#top10.heap),
        map = dict:store(Name, {Volume, true}, Map)
        }
  end;

% heap is full
trade({Name, Volume}, #top10{n = ?N, map = Map} = State) ->
  % look-up in hashmap
  {NewVolume, InHeap} = NewVal = case dict:find(Name, Map) of
    {ok, {V, In}} -> {V+Volume, In};
    error -> {Volume, false}
  end,
  if InHeap ->
      State#top10{map = dict:store(Name, NewVal, Map)};
    true ->  % current company is not in heap so peek in heap and try update
      update(NewVolume, Name, peek(State#top10.heap), State)
  end.

update(Volume, Name, {TopVal, _}, #top10{map = Map} = State)
    % Current Volume is smaller than heap Top so store only in hashmap
    when Volume < TopVal ->
  State#top10{map = dict:store(Name, {Volume, flase}, Map)};
update(Volume, Name, {TopVal, TopName}, #top10{heap = Heap, map = Map} = State) ->
  case dict:fetch(TopName, Map) of
    % heap top is up-to-date and still less than current
    {TopVal, true} ->
      State#top10{
        % store current to heap
        heap = insert({Volume, Name}, delete(Heap)),
        map = dict:store( % update current and former heap top records in hashmap
          Name, {Volume, true},
          dict:store(TopName, {TopVal, false}, Map)
          )
        };
    % heap needs update
    {NewVal, true} ->
      NewHeap = insert({NewVal, TopName}, delete(Heap)),
      update(Volume, Name, peek(NewHeap), State#top10{heap = NewHeap})
  end.

top(#top10{heap = Heap, map = Map}) ->
  % fetch up-to-date volumes from hashmap
  % (in impure language updating heap would be nice)
  [ {Name, element(1, dict:fetch(Name, Map))}
   || {_, Name} <- lists:reverse(to_list(Heap)) ].

apply_list(L, State) ->
  lists:foldl(fun apply/2, State, L).

apply(top, State) ->
  io:format("Top 10: ~p~n", [top(State)]),
  State;
apply({_, _} = T, State) ->
  trade(T, State).

%%%% Heap as ordered list

insert(X, []) -> [X];
insert(X, [H|_] = L) when X < H -> [X|L];
insert(X, [H|T]) -> [H|insert(X, T)].

-compile({inline, [delete/1, peek/1, to_list/1]}).

delete(L) -> tl(L).

peek(L) -> hd(L).

to_list(L) -> L.

它每秒执行不错的600k交易。根据公司数量的不同，我预计C实现中每秒会有数百万。更多公司意味着更快的K / V查找和更新。

找出交易量最大的前10家公司

3 个答案: