binary-tree | javascript实现二叉树，包括二叉树的构建，中序遍历，先序遍历，后续遍历，查找等功能

Is it because I have structured the function to not take a list as an input?

No. This may be confusing, but on LeetCode the raw list representation of the input is translated to an instance of TreeNode before your function is called. So you should never have to deal with this list structure. It is merely the common input format that LeetCode uses across the different programming languages. But the conversion to the target language's data structure is done for you before your implementation is called.

Your code produces an error on the first call of queue.append because of this line:

But why does offerFirst / pollLast also work?

Because the "start" and "end" of the queue are really just arbitrary decided.

You can call the first element the "start" and the last element the "end". In that case, offerLast enqueues, and pollFirst dequeues.

Since array deques are linear data structures, you can "flip it around" and say, I'll call the first element the "end" of the queue, and the last element the "start" of the queue. If you think like this, then you would enqueue by calling offerFirst and dequeue by pollLast.

Another way to explain this is to show that these are just two perspectives:

Let's say we are at standing at two ends of the deque. We both think that the element closest to us is the "first element" of the deque.

You are almost there.

First, since you have put the print_tree under your class you should put self as the first parameter.

The most "erlangish" way would be to pass the global maximum as a second parameter, and return it along with the local maximum:

The builtin Python set is almost certainly going to be the most efficient device you can use. (Sure, you could roll out cute things such as a DAG of your "vocabulary", but this is going to be much, much slower).

So, convert your list into a set (preferably built once if multiple tests are to be made) and test for membership:

It looks like you have a tree defined in a heap structure.

You cannot really use this array structure for representing a tree if the number of children of a node is variable ("3 or more"). It is intended for trees that are complete:

• Each node has either k children or none, with the exception of one node, which may have any number of children between 1 and k (which are leaves).
• All the levels of the tree are completely filled
• Except maybe the last level which may be incomplete, but all the leaf nodes in that level should be at the left side of that level. The rightmost leaf of this bottom level is a child of the exceptional node mentioned in the first bullet point.

So if your tree follows those rules, then you still need to make some adaptations to your code, as it still refers to the case where k is 2 (binary tree).

From a comment in your code it seems that you don't store a value for the root of the tree (as you call 9 a child), so that the value at index 0 is a child of the root, not the root itself.

• The formula to know the height of the tree is: 1 + _⌊log_k(n+1)_⌋. The addition of 1 to n is to account for the missing root value.
• The number of children of a node is not dependent on height, but on k (which you should define, possibly as a constant). So your for loop should run k times.
• The index of the child is not nodeIndex * 2 + i, but nodeIndex * k + i

The problem is that in the final loop in main, you don't add children to the queue, like you do in similar loops in burnTheNodes.

You should really continue the process as long as there are entries in the queue, and keep adding entries as long as the extracted node has children.

The mistake is that the logic that is done in "init" should be done for every use-case (reinitializing self.vertList), not just once at the beginning.

Change:

When you send a number to a function and change it within the function, it is only changed within that function -