CareerCup | Cracking The Coding Interview学习记录（C语言实现）

Many hardware systems have memory mapped registers, places where they store or read data. On small embedded direct-to-hardware systems it's common that those registers are placed in fixed locations, i.e. addresses.

What the macro does is basically allow access in a nicer way to such a location, instead of having to write all the casting and dereferencing each and every time.

More specifically, on the location of ADDRESS (0x2000) there seems to be stored a pointer to a structure of type VEC.

With (unsigned int*)ADDRESS the macro pretends that the value of ADDRESS is really a pointer to unsigned int. The macro then dereference that pointer, to get the value stored in memory at ADDRESS. Lastly, this value is then converted to a pointer to VEC.

Since you're already using heapq, you might as well use the nsmallest function instead of reinventing it:

I think you are misunderstanding the question. The algorithm never takes into account how many of each type of plank you have, only that you have various lengths to choose from. So if you call the function:

You are asking about the space complexity of compressBetter, which includes a call to countCompression, but also performs additional work.

While the space complexity of countCompression is indeed O(1), compressBetter has linear space complexity (i.e. O(N)) in the worst case (where no two consecutive characters of the input String are equal), since it produces a StringBuffer of 2N characters in that case.

You are right, in the worst case this is not O(n^2).

The author obviously assumed that list from map> would contain only few members; it is the assumption similar to the one that we use when we state that the complexity of find operation of a hash table is O(1). Recall, a hash table whose collision resolution is based on separate chaining has a constant complexity of find operation on average, but in case when many elements hash to the same value it can degrade to a linear complexity.

Implementation-wise, notice that map map> needs to be a hash table (i.e. std::unordered_map in C++, HashMap in Java), not std::map (or TreeMap in Java) because with std::map just the find operation is O(logn).

Here is a synchronized instance method:

It takes O(n) time to build the heap, and it requires O(n) extra space.

Finding the kth item is O(k log n) Each call to minheap.dequeue requires O(log n), and you're making k calls.

This approach works if you have enough memory to hold everything in memory. If you don't have enough memory, say you're doing this with two absolutely huge files, then the process is slightly different. See Time complexity of Kth smallest using Heap.