Saya memiliki array objek yang mungkin terlihat seperti ini:

{name: "A", parent: null},
{name: "B", parent: "A"},
{name: "C", parent: "B"},
{name: "D", parent: "B"},
{name: "E", parent: "A"},

Ini dia dalam hierarki pohon:

-A
    -B
        -C
        -D
    -E   

Saya mencoba untuk menghapus semua item dari array dengan nama katakanlah "B" (ini juga harus menghapus anak-anaknya, jadi dalam hal ini item "C" dan "D", namun saya baru mengenal rekursi dan saya tidak dapat membuat ini bekerja sendiri, dapatkah seseorang menunjukkan kepada saya cara optimal untuk melakukan ini?

Terima kasih kepada siapa pun yang bersedia membantu sebelumnya

1
Goubermouche 7 Juni 2021, 18:43

4 jawaban

Jawaban Terbaik
var array_of_object = [
{name: "A", parent: null},
{name: "B", parent: "A"},
{name: "C", parent: "B"},
{name: "D", parent: "B"},
{name: "E", parent: "A"},
];


//returns array with updated value.
function deleteElementIncludingItsChildren(children, OriginalArray){
  return OriginalArray.filter(function(element){
    //console.log(element)
      if(element.name == children || element.parent == children) return false;
      else return element;
  });
}

console.log(deleteElementIncludingItsChildren("B", array_of_object))

Pembaruan: Untuk menghapus simpul tertentu dan semua simpul turunannya

var arr = [
{name: "A", parent: null},
{name: "B", parent: "A"},
{name: "C", parent: "B"},
{name: "D", parent: "B"},
{name: "E", parent: "A"},
];


function rm(node){
  var tmp = [];
  for(var i = 0; i<arr.length; i++){
    if(node == arr[i].parent)
      tmp.push(arr[i].name);
    if(node==arr[i].name){
      arr.splice(i, 1);
      i--;
    }
  }
  if(tmp.length !==0){
    tmp.forEach(function(elem){
        rm(elem);
    }); 
  }
}

rm("B")
console.log(arr)
2
Muhammad Saquib Shaikh 7 Juni 2021, 19:34

Salah satu cara untuk menyelesaikan ini:

Lakukan traversal depth-first dari grafik dan catat / buat ancestry dari setiap elemen. Jika Anda memeriksa simpul daun dan memiliki B sebagai leluhur atau B itu sendiri, ia harus pergi.

Depth-first: setiap kali Anda melihat elemen anak, ulangi fungsi / algoritme untuk semua anak tersebut. leaf-node: objek yang tidak memiliki anak.

Bagaimana membangun hubungan orang tua anak?

Saat Anda memproses semua elemen, masukkan setiap elemen yang belum pernah Anda lihat sebelumnya ke dalam kamus (alias hashmap, set, atau objek biasa di JS) menggunakan nama objek sebagai kunci kamus. Saat Anda menemukan sesuatu yang memiliki induk tertentu, cukup periksa apakah Anda sudah memiliki objek itu di kamus, dan tambahkan elemen saat ini sebagai anak.

Pendekatan ini mungkin intensif memori jika pohonnya sangat besar sehingga Anda mungkin ingin membatasi diri Anda hanya memiliki satu referensi ke objek induk dari objek anak alih-alih setiap orang tua menunjuk ke semua anaknya.

0
Ярослав Рахматуллин 7 Juni 2021, 16:29

Cara menghapus semua anak bersarang

function deleteAll (obj , arr){

function DeleteNode (obj){
  let no = [];
  for(let i = 0 ;i < obj.length ; i++){
    
    for(let j = 0 ;j < arr.length ; j++){

      if(arr[j].parent === obj[i]){
        no.push(arr[j].name);
        
      }
          if(obj[i] === arr[j].name){
      arr.splice(j,1);
      j--
    }
  }
  
  }
  if(no.length > 0){
    DeleteNode(no , arr)
  } 
}

DeleteNode(obj)
  return arr ;
}

// Question 
const arr = [{name: "A", parent: null},
{name: "B", parent: "A"},
{name: "C", parent: "B"},
{name: "D", parent: "B"},
{name: "E", parent: "A"}];
console.log(deleteAll (["B"] , arr))

Cara Membuat simpul

const arr = [{name: "A", parent: null},
{name: "B", parent: "A"},
{name: "C", parent: "B"},
{name: "D", parent: "B"},
{name: "E", parent: "A"}];

//first create a parent oblect 
function createTree (arr){
let parent = arr.filter((el)=>{return el.parent === null});
let children = arr.filter((el)=>{return el.parent !== null});

let tree = {};

//start



children.forEach((c)=>{
  let parent = c.name ;
  
   let step = [];
let responceFindParent = {}
function find(parent,arr){
  let a= null;
  arr.forEach((el)=>{
    if(el.name === parent){
      a= el
    } 
  })

  if(a.parent === null){
   
    step.push(a.name);
     let r ={el:a , step:step}
     responceFindParent = r
    return  ;
  }else {
    step.push(a.name)
    find(a.parent , arr)
  }
}


find(parent,arr)



let stepArr = responceFindParent.step.reverse();



function insert (tree){
  let b = stepArr[0]
  if(!(stepArr[0] in tree)){
    tree[stepArr[0]] = {}
  }
  stepArr.splice(0,1)
  
  if(stepArr . length > 0){
    insert(tree[b])
  }
}
insert (tree)
//end
  
  
})

return tree
  
}

console.log(createTree (arr))
1
Jagadish Lenka 7 Juni 2021, 19:06

Salah satu cara untuk menulis ini adalah dengan melapisinya di atas fungsi lain yang mengumpulkan daftar node yang menangkap hierarki turunan. Itu adalah rekursi langsung, dan kemudian fungsi utamanya hanyalah pemfilteran:

const desc = (target, xs, node = xs .find (({name}) => name == target)) => node ? [
  node, 
  ... xs .filter (({parent}) => parent == node .name) .flatMap (({name}) => desc (name, xs))
] : []


const removeHier = (target, xs, h = desc (target, xs)) =>
  xs .filter (x => ! h.includes (x))

const records = [{name: "A", parent: null}, {name: "B", parent: "A"}, {name: "C", parent: "B"}, {name: "D", parent: "B"}, {name: "E", parent: "A"}, {name: "F", parent: "D"}]

console .log (removeHier ('B', records))
1
Scott Sauyet 7 Juni 2021, 18:17