pythonds | Data Structures package for Problem | Learning library

Your code is actually O(nlogn) (average case) and not O(n^2).

Take a look on all(x<=y for y in alist), and recall that to yield False, it is enough that one element is bigger than x, no need to go through all values of alist.

Assume your list is shuffled randomly (and uniformly), and let's examine how many elements needs to be traversed:

You are correct that the runtime of the code that you've posted here is O(n²), not O(n), for precisely the reason that you've indicated.

Conceptually, the algorithm you're implementing goes like this:

• Maintain a collection of all the items seen so far.
• For each item in the list:
  • If that item is in the collection, report a duplicate exists.
  • Otherwise, add it to the collection.
• Report that there are no duplicates.

The reason the code you've posted here is slow is because the cost of checking whether a duplicate exists is O(n) when using a list to track the items seen so far. In fact, if you're using a list of the existing elements, what you're doing is essentially equivalent to just checking the previous elements of the array to see if any of them are equal!

You can speed this up by switching your implementation so that you use a set to track prior elements rather than a list. Sets have (expected) O(1) lookups and insertions, so this will make your code run in (expected) O(1) time.

Replace if token in "0123456789" (checks if token is a substring of "0123456789") with if token.isdigit() (checks if token consists of decimal digits).

Each call to tree remembers where it is. You are correct that the first thing to happen is a chain of forward and right turns until tree (0,t) is called. That call doesn't satisfy the if test, so does nothing. However, that does not affect any other tree call. So, back in tree(15,t), execution continues with line 6, and similarly for all the other tree calls.

As an exercise, you might try pasting a copy of tree each place it is called, and filling in the numbers for branchLen. Each time tree is called, that is effectively what happens.

Imagine branchLen were part of the function name, rather than a parameter. You would have a family of functions tree75(t), tree60, ... tree0. tree75() would be:

Recursion is something that is hard to grasp when starting out with programming. One of the things that you have to realize is that, if you properly have set up base cases (eg. if self.left, if self.right, etc), you can use the function that you are working on as if it is already working.

Let's think about an example of counting all the nodes in a tree with the function countNodes(): Say we have node x that is somewhere in the tree. When x is called to count all of the nodes of its subtree, how does it do that? Remember how I said that we have to pretend the function countNodes() exists and that it already works? Well, let's do just that. X needs to count itself because it is a node. Therefore the count is 1 so far. After it counted itself, it has to count all the nodes on the left and all the nodes on the right. So to count the nodes in a tree starting at any node x, we call countNodes() for the left and countNodes() for the right.

So the code would look like this:

The – characters in your third call:

This is a time trial, testing how fast findmin() is. That's best done with randomised data, to avoid pathological cases. The list comprehension produces the test data. The 100000 is just an upper bound for the random values in that list, high enough to ensure that even for a list with 10k integers there is a nice spread of values.

Note that it is better to use the timeit module to execute time trials.

Slicing shouldn't affect the time complexity at all in terms of it's order of magnitude. The constant factor is another discussion.

The key part of understanding how the time complexity is unchanged is here: