CSS或JQuery修复网站布局中的侧边栏(CSS or JQuery Fixed sidebar in website layout)

 我相信以下是最佳解决方案，至少是基于时间/空间的复杂性： 
 
 第1步：将整数存储在哈希映射中，该哈希映射将整数保存为键，并将其显示为值的次数。 这通常是一个O（n）操作，散列表中元素的插入/更新应该是平均的恒定时间。 如果发现一个整数出现两次以上，则实际上不需要进一步增加使用次数（如果不想）。 
 
 步骤2：对整数进行第二遍。 在哈希映射中查找每一个，第一个出现计数为1的是您正在查找的那个（即第一个出现的整数）。 这也是O（n） ，使得整个过程O（n） 。 
 
 针对特殊情况的一些可能的优化： 
 
 优化答：可以使用简单的数组而不是哈希表。 这保证了O（1），即使在最坏的情况下，也可以计算特定整数的出现次数以及查找其出现次数。 此外，这增强了实时性能，因为散列算法不需要执行。 由于可能较差的参考位置（即较大的稀疏表，而哈希表实现具有合理的负载因子），可能会有一个命中。 然而，这将是整数排序的非常特殊的情况，并且可以通过散列表的散列函数来缓解，所述散列函数根据传入整数（即，以开始的参考的较差局部性）产生伪随机存储桶布置。 
 
 数组中的每个字节将表示由该字节的索引表示的整数的计数（最多255）。 这只有在最低整数和最高整数（即有效整数域的基数）之间的差异足够小以使该数组适合内存时才可能。 特定整数数组中的索引将是其值减去数据集中存在的最小整数。 
 
 例如，在具有64位操作系统的现代硬件上，可以分配一个4GB阵列来处理整个32位整数域。 更大的阵列可以设想有足够的内存。 
 
 在处理之前必须知道最小和最大的整数，或者使用minmax算法通过数据进行另一个线性通过以找出这些信息。 
 
 优化B：您可以进一步优化优化A ，每个整数使用至多2位（一位指示存在，另一位指示多重性）。 这将允许每个字节表示四个整数，扩展数组实现以处理给定数量的可用内存的更大整数域。 可以在这里播放更多的位游戏来进一步压缩表示，但是它们只支持特殊的数据输入，因此不能推荐用于大多数情况。 

I believe that the following would be the optimal solution, at least based on time / space complexity:
 
Step 1: Store the integers in a hash map, which holds the integer as a key and the count of the number of times it appears as the value. This is generally an O(n) operation and the insertion / updating of elements in the hash table should be constant time, on the average. If an integer is found to appear more than twice, you really don't have to increment the usage count further (if you don't want to).
 
Step 2: Perform a second pass over the integers. Look each up in the hash map and the first one with an appearance count of one is the one you were looking for (i.e., the first single appearing integer). This is also O(n), making the entire process O(n).
 
Some possible optimizations for special cases:
 
Optimization A: It may be possible to use a simple array instead of a hash table. This guarantees O(1) even in the worst case for counting the number of occurrences of a particular integer as well as the lookup of its appearance count. Also, this enhances real time performance, since the hash algorithm does not need to be executed. There may be a hit due to potentially poorer locality of reference (i.e., a larger sparse table vs. the hash table implementation with a reasonable load factor). However, this would be for very special cases of integer orderings and may be mitigated by the hash table's hash function producing pseudorandom bucket placements based on the incoming integers (i.e., poor locality of reference to begin with).
 
Each byte in the array would represent the count (up to 255) for the integer represented by the index of that byte. This would only be possible if the difference between the lowest integer and the highest (i.e., the cardinality of the domain of valid integers) was small enough such that this array would fit into memory. The index in the array of a particular integer would be its value minus the smallest integer present in the data set.
 
For example on modern hardware with a 64-bit OS, it is quite conceivable that a 4GB array can be allocated which can handle the entire domain of 32-bit integers. Even larger arrays are conceivable with sufficient memory.
 
The smallest and largest integers would have to be known before processing, or another linear pass through the data using the minmax algorithm to find out this information would be required. 
 
Optimization B: You could optimize Optimization A further, by using at most 2 bits per integer (One bit indicates presence and the other indicates multiplicity). This would allow for the representation of four integers per byte, extending the array implementation to handle a larger domain of integers for a given amount of available memory. More bit games could be played here to compress the representation further, but they would only support special cases of data coming in and therefore cannot be recommended for the still mostly general case.