Heim > Artikel > Web-Frontend > js-Deduplizierung und Optimierung numerischer Arrays
Dieses Mal werde ich Ihnen js zum Deduplizieren und Optimieren numerischer Arrays vorstellen. Was sind die Vorsichtsmaßnahmen für js zum Deduplizieren und Optimieren numerischer Arrays?
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)
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 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 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. Andere Deduplizierungsmethoden Deduplizierung durch Objekt festlegen Duplikate durch die Methode 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 durch By Entfernen Sie Duplikate durch Objekt-Schlüssel-Wert-Paare + JSON Objektmethode 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: Angular verwendet ng-click, um mehrere Parameter gleichzeitig hochzuladen Das obige ist der detaillierte Inhalt vonjs-Deduplizierung und Optimierung numerischer Arrays. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!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)
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)
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 = 'red'
}
}
class RedBlackTree {
constructor() {
this.root = null
this.arr = []
}
insert(value) {
let node = new Node(value)
if (!this.root) {
node.color = 'black'
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 = 'black'
this.root = node
return
}
if (node.parent.color === 'black') {
return
}
let son = node
let father = node.parent
let grandFather = father.parent
let directionFtoG = father === grandFather.left ? 'left' : 'right'
let uncle = grandFather[directionFtoG === 'left' ? 'right' : 'left']
let directionStoF = son === father.left ? 'left' : 'right'
if (!uncle || uncle.color === 'black') {
if (directionFtoG === directionStoF) {
if (grandFather.parent) {
grandFather.parent[grandFather.parent.left === grandFather ? 'left' : 'right'] = father
father.parent = grandFather.parent
} else {
this.root = father
father.parent = null
}
father.color = 'black'
grandFather.color = 'red'
father[father.left === son ? 'right' : 'left'] && (father[father.left === son ? 'right' : 'left'].parent = grandFather)
grandFather[grandFather.left === father ? 'left' : 'right'] = father[father.left === son ? 'right' : 'left']
father[father.left === son ? 'right' : 'left'] = 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 = 'black'
uncle.color = 'black'
grandFather.color = 'red'
this.fixTree(grandFather)
}
}
}
let redBlackTree = new RedBlackTree()
for (let i = 0; i < arr.length; i++) {
redBlackTree.insert(arr[i])
}
console.log(redBlackTree.arr)
[...new Set(arr)]
sort()
+ reduce()
entfernencompare(2, '2')
0 zurück Reduzieren (), führen Sie einen kongruenten Vergleich let arr = [0, 1, 2, '2', 2, 5, 7, 11, 7, 5, 2, '2', 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)
<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 Duplikatenlet 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))
includes()
+ reduce()
Methode zum Entfernen von Duplikatenlet 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
}, [])
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)))