# Methods to set the order in subnodes of a tree construction?

### What’s the order of a tree?

The association or positioning of a tree construction’s nodes and subnodes in relation to at least one one other is known as the tree construction’s “order.” The popular order of every node’s subnodes will be decided by a selected function or attribute of every node, comparable to a quantity or textual content.

We are able to type a tree construction’s nodes and subnodes relying on this property and current them in a significant trend that highlights the connections between nodes by adjusting the tree construction’s order. This makes it less complicated to see the connections between the tree’s nodes and spot any patterns or hierarchies within the information.

### Methods to set the order in a tree?

Subnodes in a tree construction will be organized in any order by specifying an attribute in every node that corresponds to the popular association of its subnodes. This attribute, which is used for comparability, might be both a string or a numerical worth. As soon as the order attribute is specified, a sorting algorithm could also be used to type the subnodes relying on their order attribute. Built-in sorting features or customized sorting features that examine the subnodes’ order attributes can be utilized to perform the algorithm. The tree construction will be organized and displayed in a significant trend that exhibits the hyperlinks between nodes by defining the order of the subnodes.

Instance: To set the order of subnodes in a tree construction, we have to outline an attribute within the node object that represents the order of the subnodes. Then, you need to use a sorting algorithm to type the subnodes primarily based on the order attribute.

Method: Observe the beneath steps to set the order in a tree:

• Outline a node object with a subnode property that incorporates an array of subnodes. Every subnode object incorporates a reputation property and an order property that represents the specified order of the subnode inside the father or mother node.
• To type the subnodes primarily based on the order property, we use the kind() methodology of the array object, passing in a comparability operate that compares the order property of every subnode. This types the subnodes in ascending order of the order property.
• Print the sorted subnodes by iterating over the subnode array and accessing the identify property of every subnode.

Right here is an instance implementation in JavaScript:

## Javascript

 `var` `node = {` `  ``identify: ``"Node A"``,` `  ``subnodes: [` `    ``{ name: ``"Node A.2"``, order: 2 },` `    ``{ name: ``"Node A.3"``, order: 3 },` `    ``{ name: ``"Node A.1"``, order: 1 }` `  ``]` `};` ` `  `node.subnodes.type(``operate``(a, b) {` `  ``return` `a.order - b.order;` `});` ` `  `for` `(``var` `i = 0; i < node.subnodes.size; i++) {` `  ``console.log(node.subnodes[i].identify);` `}`
Output

```Node A.1
Node A.2
Node A.3```

Time Complexity: O(n*logn)
Auxiliary Area: O(1)