Heim > Web-Frontend > js-Tutorial > Hauptteil

Detaillierte Erläuterung der Deduplizierungs- und Optimierungsschritte zum Aufbau eines Binärbaum-Arrays mit js

php中世界最好的语言
Freigeben: 2018-05-03 11:09:06
Original
1343 Leute haben es durchsucht

Dieses Mal werde ich Ihnen eine detaillierte Erklärung der Deduplizierungs- und Optimierungsschritte zum Erstellen eines Binärbaum-Arrays mit js geben. Was sind die Vorsichtsmaßnahmen zum Erstellen eines Binärbaum-Arrays mit js zur Deduplizierung und Optimierung? Hier sind praktische Fälle, werfen wir einen Blick darauf.

Vorwort

In diesem Artikel werden hauptsächlich die relevanten Inhalte zum Erstellen eines Binärbaums mit js zur Deduplizierung und Optimierung numerischer Arrays vorgestellt Ihre Referenz. Im Folgenden gibt es nicht viel zu sagen. Schauen wir uns die detaillierte Einführung an.

Gemeinsame zweischichtige Schleife zur Implementierung der Array-Deduplizierung

let arr = [11, 12, 13, 9, 8, 7, 0, 1, 2, 2, 5, 7, 11, 11, 7, 6, 4, 5, 2, 2]
let newArr = []
for (let i = 0; i < arr.length; i++) {
 let unique = true
 for (let j = 0; j < newArr.length; j++) {
  if (newArr[j] === arr[i]) {
   unique = false
   break
  }
 }
 if (unique) {
  newArr.push(arr[i])
 }
}
console.log(newArr)
Nach dem Login kopieren

Erstellen Sie einen Binärbaum zur Implementierung der Deduplizierung (nur anwendbar zu Array vom numerischen Typ )

Konstruieren Sie die zuvor durchlaufenen Elemente in einen Binärbaum. Jeder Knoten im Baum erfüllt: den Wert des linken untergeordneten Knotens< Der Wert des Knotens

Dies optimiert den Prozess der Beurteilung, ob das Element schon einmal aufgetreten ist

Wenn das Element größer als der aktuelle Knoten ist, benötigen Sie nur Um zu beurteilen, ob sich das Element im Knoten befindet, muss es nur im rechten Teilbaum des Knotens angezeigt werden.

Wenn das Element kleiner als der aktuelle Knoten ist, müssen Sie nur beurteilen, ob das Element im Knoten angezeigt wird Linker Teilbaum des Knotens

let arr = [0, 1, 2, 2, 5, 7, 11, 7, 6, 4,5, 2, 2]
class Node {
 constructor(value) {
  this.value = value
  this.left = null
  this.right = null
 }
}
class BinaryTree {
 constructor() {
  this.root = null
  this.arr = []
 }
 insert(value) {
  let node = new Node(value)
  if (!this.root) {
   this.root = node
   this.arr.push(value)
   return this.arr
  }
  let current = this.root
  while (true) {
   if (value > current.value) {
    if (current.right) {
     current = current.right
    } else {
     current.right = node
     this.arr.push(value)
     break
    }
   }
   if (value < current.value) {
    if (current.left) {
     current = current.left
    } else {
     current.left = node
     this.arr.push(value)
     break
    }
   }
   if (value === current.value) {
    break
   }
  }
  return this.arr
 }
}
let binaryTree = new BinaryTree()
for (let i = 0; i < arr.length; i++) {
 binaryTree.insert(arr[i])
}
console.log(binaryTree.arr)
Nach dem Login kopieren

Optimierungsidee eins, maximale und minimale Werte aufzeichnen

Zeichnen Sie die maximalen und minimalen Werte des eingefügten Elements auf Elemente. Wenn es größer als das größte Element oder das kleinste Element kleiner ist, fügen Sie es direkt ein

let arr = [11, 12, 13, 9, 8, 7, 0, 1, 2, 2, 5, 7, 11, 11, 7, 6, 4, 5, 2, 2]
class Node {
 constructor(value) {
  this.value = value
  this.left = null
  this.right = null
 }
}
class BinaryTree {
 constructor() {
  this.root = null
  this.arr = []
  this.max = null
  this.min = null
 }
 insert(value) {
  let node = new Node(value)
  if (!this.root) {
   this.root = node
   this.arr.push(value)
   this.max = value
   this.min = value
   return this.arr
  }
  if (value > this.max) {
   this.arr.push(value)
   this.max = value
   this.findMax().right = node
   return this.arr
  }
  if (value < this.min) {
   this.arr.push(value)
   this.min = value
   this.findMin().left = node
   return this.arr
  }
  let current = this.root
  while (true) {
   if (value > current.value) {
    if (current.right) {
     current = current.right
    } else {
     current.right = node
     this.arr.push(value)
     break
    }
   }
   if (value < current.value) {
    if (current.left) {
     current = current.left
    } else {
     current.left = node
     this.arr.push(value)
     break
    }
   }
   if (value === current.value) {
    break
   }
  }
  return this.arr
 }
 findMax() {
  let current = this.root
  while (current.right) {
   current = current.right
  }
  return current
 }
 findMin() {
  let current = this.root
  while (current.left) {
   current = current.left
  }
  return current
 }
}
let binaryTree = new BinaryTree()
for (let i = 0; i < arr.length; i++) {
 binaryTree.insert(arr[i])
}
console.log(binaryTree.arr)
Nach dem Login kopieren

Optimierungsidee zwei, bauen Sie einen rot-schwarzen Baum

Bauen Sie einen rot-schwarzen Baum und gleichen Sie die Höhe des Baumes aus.

Informationen zum Teil des rot-schwarzen Baums finden Sie in der Einfügung des rot-schwarzen Baums.

let arr = [11, 12, 13, 9, 8, 7, 0, 1, 2, 2, 5, 7, 11, 11, 7, 6, 4, 5, 2, 2]
console.log(Array.from(new Set(arr)))
class Node {
 constructor(value) {
  this.value = value
  this.left = null
  this.right = null
  this.parent = null
  this.color = &#39;red&#39;
 }
}
class RedBlackTree {
 constructor() {
  this.root = null
  this.arr = []
 }
 insert(value) {
  let node = new Node(value)
  if (!this.root) {
   node.color = &#39;black&#39;
   this.root = node
   this.arr.push(value)
   return this
  }
  let cur = this.root
  let inserted = false
  while (true) {
   if (value > cur.value) {
    if (cur.right) {
     cur = cur.right
    } else {
     cur.right = node
     this.arr.push(value)
     node.parent = cur
     inserted = true
     break
    }
   }
   if (value < cur.value) {
    if (cur.left) {
     cur = cur.left
    } else {
     cur.left = node
     this.arr.push(value)
     node.parent = cur
     inserted = true
     break
    }
   }
   if (value === cur.value) {
    break
   }
  }
  // 调整树的结构
  if(inserted){
   this.fixTree(node)
  }
  return this
 }
 fixTree(node) {
  if (!node.parent) {
   node.color = &#39;black&#39;
   this.root = node
   return
  }
  if (node.parent.color === &#39;black&#39;) {
   return
  }
  let son = node
  let father = node.parent
  let grandFather = father.parent
  let directionFtoG = father === grandFather.left ? &#39;left&#39; : &#39;right&#39;
  let uncle = grandFather[directionFtoG === &#39;left&#39; ? &#39;right&#39; : &#39;left&#39;]
  let directionStoF = son === father.left ? &#39;left&#39; : &#39;right&#39;
  if (!uncle || uncle.color === &#39;black&#39;) {
   if (directionFtoG === directionStoF) {
    if (grandFather.parent) {
     grandFather.parent[grandFather.parent.left === grandFather ? &#39;left&#39; : &#39;right&#39;] = father
     father.parent = grandFather.parent
    } else {
     this.root = father
     father.parent = null
    }
    father.color = &#39;black&#39;
    grandFather.color = &#39;red&#39;
    father[father.left === son ? &#39;right&#39; : &#39;left&#39;] && (father[father.left === son ? &#39;right&#39; : &#39;left&#39;].parent = grandFather)
    grandFather[grandFather.left === father ? &#39;left&#39; : &#39;right&#39;] = father[father.left === son ? &#39;right&#39; : &#39;left&#39;]
    father[father.left === son ? &#39;right&#39; : &#39;left&#39;] = grandFather
    grandFather.parent = father
    return
   } else {
    grandFather[directionFtoG] = son
    son.parent = grandFather
    son[directionFtoG] && (son[directionFtoG].parent = father)
    father[directionStoF] = son[directionFtoG]
    father.parent = son
    son[directionFtoG] = father
    this.fixTree(father)
   }
  } else {
   father.color = &#39;black&#39;
   uncle.color = &#39;black&#39;
   grandFather.color = &#39;red&#39;
   this.fixTree(grandFather)
  }
 }
}
let redBlackTree = new RedBlackTree()
for (let i = 0; i < arr.length; i++) {
 redBlackTree.insert(arr[i])
}
console.log(redBlackTree.arr)
Nach dem Login kopieren

Andere Deduplizierungsmethoden

Deduplizierung durch Objekt festlegen

[...new Set(arr)]
Nach dem Login kopieren

Duplikate durch die Methode sort() + reduce() entfernen

Vergleichen Sie nach dem Sortieren benachbarte Elemente, um festzustellen, ob sie gleich sind, und fügen Sie sie dem zurückgegebenen Array hinzu.

Bemerkenswert: Ja, beim Sortieren gibt der Standardwert compare(2, &#39;2&#39;) 0 zurück Reduzieren (), führen Sie einen kongruenten Vergleich

let arr = [0, 1, 2, &#39;2&#39;, 2, 5, 7, 11, 7, 5, 2, &#39;2&#39;, 2]
let newArr = []
arr.sort((a, b) => {
 let res = a - b
 if (res !== 0) {
  return res
 } else {
  if (a === b) {
   return 0
  } else {
   if (typeof a === 'number') {
    return -1
   } else {
    return 1
   }
  }
 }
}).reduce((pre, cur) => {
 if (pre !== cur) {
  newArr.push(cur)
  return cur
 }
 return pre
}, null)
Nach dem Login kopieren

durch <a href="http://www.php.cn/wiki%20/137.html" target="_blank">include<code><a href="http://www.php.cn/wiki/137.html" target="_blank">include</a>s() s durch () + map() Methode zum Entfernen von Duplikaten

let arr = [0, 1, 2, '2', 2, 5, 7, 11, 7, 5, 2, '2', 2]
let newArr = []
arr.map(a => !newArr.includes(a) && newArr.push(a))
Nach dem Login kopieren

By includes() + reduce() Methode zum Entfernen von Duplikaten

let arr = [0, 1, 2, '2', 2, 5, 7, 11, 7, 5, 2, '2', 2]
let newArr = arr.reduce((pre, cur) => {
  !pre.includes(cur) && pre.push(cur)
  return pre
}, [])
Nach dem Login kopieren

Entfernen Sie Duplikate durch Objekt-Schlüssel-Wert-Paare + JSON Objektmethode

let arr = [0, 1, 2, '2', 2, 5, 7, 11, 7, 5, 2, '2', 2]
let obj = {}
arr.map(a => {
  if(!obj[JSON.stringify(a)]){
    obj[JSON.stringify(a)] = 1
  }
})
console.log(Object.keys(obj).map(a => JSON.parse(a)))
Nach dem Login kopieren

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

WeChat-Applet teilt die Seite und springt zurück zur Startseite

ElTableColumn fügt Suchzusammenfassungsfunktion hinzu

jQuery fügt automatisch Ellipsen hinzu, wenn der Eingabetext die angegebene Anzahl von Zeilen überschreitet

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Deduplizierungs- und Optimierungsschritte zum Aufbau eines Binärbaum-Arrays mit js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage
Über uns Haftungsausschluss Sitemap
Chinesische PHP-Website:Online-PHP-Schulung für das Gemeinwohl,Helfen Sie PHP-Lernenden, sich schnell weiterzuentwickeln!