关于从二叉树复制/获取节点的问题

Question

question(language used - js) - when you copy a node from the binary tree, are the whole branches below that node (you know binary tree node has properties left and right , below them, are more nodes.) also get copied inside the variable? Well... node is an object in the binary tree...and objects are reference values , so I am guessing that the same node of the tree is enqueued there, instead of copy of that node .

I am trying to do breadthFirstSearch in the binary tree, where I have to put the node of the tree in the queue . I want to know that, when I enqueue the node of the binary tree in queue , is the copy of that specific node along with its keys or properties (as we know) gets added to the queue or only reference to that node is added? Because if that specific node is copied, and the tree has 1000s of nodes in it, then the whole branch below that node might get copied too(since I don't know if this actually happens or not)....which is very very bad for performance and memory. If it's only referenced to that node, then it's completely fine as I am not copying the whole branch of the tree.

Answer 1

JavaScript assigns objects and arrays by reference, which means a given object or array can be assigned to any number of variables without duplicating it. Besides, objects and arrays are mutable , which means you can modify their contents after they have been created.

For instance:

a = [1,2,3];     // a is a reference to a freshly created array
b = a;           // b is a second reference to the same array
a.pop();         // a is used to remove the last element of the underlying array
console.log (b); // b is also affected

output:

Array [ 1, 2 ] // through `a` we modified the contents of `b`.

The main advantage of mutability is efficiency, as you pointed out. On the other hand, working with mutable objects is tricky, as you are left in charge of guaranteeing the consistency of your references (in layman's terms, you are constantly at risk of inadvertently clobbering the contents of some 'b' through some 'a').
Since JavaScript has a very limited notion of variable typing , there is no simple way to tell which identifier(s) allow to access and modify a given piece of data at some point.
Defining a notion of equality is also difficult: are we talking about equality of references (a and b referencing the same underlying object) or equality of contents (a and b referencing two distinct objects that happen to hold identical data)?
This pitfall is the source of countless puzzling bugs.
To make matters worse, built-in methods offer a mix of approaches. For instance, some chainable Array methods ( filter , map , reduce , find ) return new arrays, others ( pop / push , shift / unshift , splice , sort ) modify the array in place.

JavaScript is an old language which evolved through 6 versions while maintaining upward compatibility, ending up with a collection of mechanisms that are very difficult to specify in a rigorous, deterministic way. This is why the official specification of the version implemented in current browsers (ECMA 6.0) is, unfortunately, anything but educational material.
I doubt a language learner would get much benefit from reading it beyond the initialoverview , which doesn't dwell into details.
Unless you want to specialize in JS and tackle the spec yourself, you'll have to rely on gloss by bloggers, like this one or perhaps this one .