Typescript Algorithm - Node Tree: A unique approach combining algorithmic concepts and

Question

Typescript Algorithm - Node Tree: A unique approach combining algorithmic concepts and

I am dealing with a json data in raw format that is unsorted. Here is a snippet of the data:

[
  {
    "level": 1,
    "id": 34,
    "name": "example-name",
    "father_id": 10
  },
  ...
]

My goal is to organize this data in a specific way as shown below:

...

In order to achieve this transformation efficiently, I have implemented the following solution in typescript:

    const families: { parent: Treeview; children: Treeview[] }[] = []

    arrayTreeViews.forEach(node => {
      ...
    })

I am seeking advice on whether this is the most efficient way to accomplish this task in typescript.

Thank you for any help or suggestions!

EDIT :

[Message deleted because it was the wrong solution]

EDIT 2 : Solution found : so same question as earlier ? Is it the best way / most efficient way to do it ? Thanks for your help / advice

    const rootLevel: { parent: Treeview; children: Treeview[] }[] = []
    const subLevel: Treeview[] = []
    const lowerLevel: Treeview[] = []

    arrayTreeViews.forEach(node => {
      ...
    })

    subLevel.forEach(node => {
      ...
    res.json(rootLevel)

typescript algorithm tree

Answer 1

Answer №1

Edit: Due to the change in the question, a new answer had to be crafted

const findChildren = (tree: Treeview[], node: Treeview) =>
  tree.filter(
    (treeNode) =>
      treeNode.level === node.level - 1 && treeNode.father_id === node.id
  );

const findGrandchildren = (tree: Treeview[], node: Treeview) =>
  findChildren(tree, node).flatMap((child) => findChildren(tree, child));

const families = arrayTreeViews
  .filter((view) => view.level === 5)
  .map((view) => ({
    parent: view,
    children: findGrandchildren(arrayTreeViews, view),
  }));

Original Answer:

In this scenario, I would opt for a recursive approach:

const getRelation = (
  tree: Treeview[],
  lowerLevelBound: number,
  level: number,
  fatherId?: number
) => {
  // Locate nodes with the specified level
  const currentLevelNodes = tree.filter(
    (node) =>
      node.level === level &&
      // If fatherId is not null, filter nodes with the desired father_id
      (fatherId == null ? true : node.father_id === fatherId)
  );

  // Exit the algorithm when reaching the lower level bound
  if (level === lowerLevelBound) return currentLevelNodes;

  return currentLevelNodes.map((node) => ({
    parent: node,
    children: getRelation(tree, lowerLevelBound, level - 1, node.id),
  }));
};

const lowerLevelBound = 3;
const upperLevelBound = 5;

const families = getRelation(arrayTreeViews, lowerLevelBound, upperLevelBound);

This method involves filtering nodes of level 5 and recursively establishing parent-child relationships.

Answer 2

Edit: Due to the change in the question, a new answer had to be crafted

const findChildren = (tree: Treeview[], node: Treeview) =>
  tree.filter(
    (treeNode) =>
      treeNode.level === node.level - 1 && treeNode.father_id === node.id
  );

const findGrandchildren = (tree: Treeview[], node: Treeview) =>
  findChildren(tree, node).flatMap((child) => findChildren(tree, child));

const families = arrayTreeViews
  .filter((view) => view.level === 5)
  .map((view) => ({
    parent: view,
    children: findGrandchildren(arrayTreeViews, view),
  }));

Original Answer:

In this scenario, I would opt for a recursive approach:

const getRelation = (
  tree: Treeview[],
  lowerLevelBound: number,
  level: number,
  fatherId?: number
) => {
  // Locate nodes with the specified level
  const currentLevelNodes = tree.filter(
    (node) =>
      node.level === level &&
      // If fatherId is not null, filter nodes with the desired father_id
      (fatherId == null ? true : node.father_id === fatherId)
  );

  // Exit the algorithm when reaching the lower level bound
  if (level === lowerLevelBound) return currentLevelNodes;

  return currentLevelNodes.map((node) => ({
    parent: node,
    children: getRelation(tree, lowerLevelBound, level - 1, node.id),
  }));
};

const lowerLevelBound = 3;
const upperLevelBound = 5;

const families = getRelation(arrayTreeViews, lowerLevelBound, upperLevelBound);

This method involves filtering nodes of level 5 and recursively establishing parent-child relationships.

Typescript Algorithm - Node Tree: A unique approach combining algorithmic concepts and

Answer №1

Similar questions

Come back to Angular 2 on your return function

How to efficiently upload multiple files simultaneously in Angular 10 and .NET Core 5 by utilizing a JSON object

Tips on modifying the selected type key name through Pick?

What is the best way to retrieve the name of a static method within a class?

Discover the elements within an array that appear an odd number of times

Is it necessary to explicitly specify VOID when rejecting an empty Promise?

IntelliJ does not provide alerts for return type inconsistencies in TypeScript

Defining a JSON file interface in Angular to populate a dropdown box with dependencies

Retrieve the value of the specific element I have entered in the ngFor loop

Handling JSON data with Reactive Extensions in JavaScript

What data structure is used to store HTML elements in TypeScript?

Issue with Dates in Typescript array elements

When navigating using the next and back buttons, the active state in Angular is automatically removed

There is a type error in the dynamic assignment in TypeScript. I have various data that need to be fetched from one another

A step-by-step guide to showcasing dates in HTML with Angular

Get the @types definition installed from a forked repository

Guide on validating multiple preselected checkboxes using Angular 8 reactive forms

"Enhancing User Experience with Angular 2: Customizing Component Selection and Sty

Improving a lengthy TypeScript function through refactoring

The module named "domhandler" does not have an exported member called 'DomElement'. Perhaps you meant to use 'import DomElement from "domhandler"' instead?