Yes, nested loops are one way to quickly get a big O notation. Typically (but not always) one loop nested in another will cause O(n²). Think about it, the inner loop is executed i times, for each value of i. The outer loop is executed n times. thus you see a pattern of execution like … Read more
From the API doc ofHashMap: This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets. Since containsKey() is just a get() that throws away the retrieved value, it’s O(1) (assuming the hash function works properly, again).
This does happen in the real world! For example, a famous sorting algorithm is Timsort: Timsort Details of the below implementation: We consider the size of the run as 32 and the input array is divided into sub-array. We one-by-one sort pieces of size equal to run with a simple insertion sort. After sorting individual … Read more
Good question. Actually, I always show these 3 pictures: n = [0; 10] n = [0; 100] n = [0; 1000] So, O(N*log(N)) is far better than O(N^2). It is much closer to O(N) than to O(N^2). But your O(N^2) algorithm is faster for N < 100 in real life. There are a lot of … Read more
Using for _ in itertools.repeat(None, count) do something is the non-obvious way of getting the best of all worlds: tiny constant space requirement, and no new objects created per iteration. Under the covers, the C code for repeat uses a native C integer type (not a Python integer object!) to keep track of the count … Read more
In minimum = head . sort, the sort won’t be done fully, because it won’t be done upfront. The sort will only be done as much as needed to produce the very first element, demanded by head. In e.g. mergesort, at first n numbers of the list will be compared pairwise, then the winners will … Read more
They are not equivalent: sqrt(N) will increase a lot more quickly than log2(N). There is no constant C so that you would have sqrt(N) < C.log(N) for all values of N greater than some minimum value. An easy way to grasp this, is that log2(N) will be a value close to the number of (binary) … Read more
In-order, Pre-order, and Post-order traversals are Depth-First traversals. For a Graph, the complexity of a Depth First Traversal is O(n + m), where n is the number of nodes, and m is the number of edges. Since a Binary Tree is also a Graph, the same applies here. The complexity of each of these Depth-first … Read more
It’s amortized O(1), not O(1). Let’s say the list reserved size is 8 elements and it doubles in size when space runs out. You want to push 50 elements. The first 8 elements push in O(1). The nineth triggers reallocation and 8 copies, followed by an O(1) push. The next 7 push in O(1). The … Read more
An ArrayList in Java is a List that is backed by an array. The get(index) method is a constant time, O(1), operation. The code straight out of the Java library for ArrayList.get(index): public E get(int index) { RangeCheck(index); return (E) elementData[index]; } Basically, it just returns a value straight out of the backing array. (RangeCheck(index)) … Read more