Dia 52/2019 - Estruturas de dados em JS: conjuntos

Desafio #92daysofcode que fiz no final de 2019. Nesse artigo temos o dia 52, mostrando o uso de conjuntos.

Um conjunto é uma estrutura de dados que pode armazenar qualquer número de valores exclusivos em qualquer ordem que você desejar. Os conjuntos são diferentes dos arrays, no sentido em que apenas permitem valores únicos e não repetidos.

Geralmente é usada para testar se os elementos pertencem ao conjunto de valores. Em vez de conter apenas elementos, os Sets são mais usados ​​para executar operações em vários valores de uma só vez com métodos como união, interseção, etc.

Código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
class Set {
constructor() {
this.items = {};
}

add(element) {
if (!this.has(element)) {
this.items[element] = element;
return true;
}
return false;
}

delete(element) {
if (this.has(element)) {
delete this.items[element];
return true;
}
return false;
}

has(element) {
return Object.prototype.hasOwnProperty.call(this.items, element);
}

values() {
return Object.values(this.items);
}

union(otherSet) {
const unionSet = new Set();
this.values().forEach(value => unionSet.add(value));
otherSet.values().forEach(value => unionSet.add(value));
return unionSet;
}

intersection(otherSet) {
const intersectionSet = new Set();
const values = this.values();
const otherValues = otherSet.values();
let biggerSet = values;
let smallerSet = otherValues;
if (otherValues.length - values.length > 0) {
biggerSet = otherValues;
smallerSet = values;
}
smallerSet.forEach(value => {
if (biggerSet.includes(value)) {
intersectionSet.add(value);
}
});
return intersectionSet;
}

difference(otherSet) {
const differenceSet = new Set();
this.values().forEach(value => {
if (!otherSet.has(value)) {
differenceSet.add(value);
}
});
return differenceSet;
}

isSubsetOf(otherSet) {
if (this.size() > otherSet.size()) {
return false;
}
let isSubset = true;
this.values().every(value => {
if (!otherSet.has(value)) {
isSubset = false;
return false;
}
return true;
});
return isSubset;
}

isEmpty() {
return this.size() === 0;
}

size() {
return Object.keys(this.items).length;
}

clear() {
this.items = {};
}

toString() {
if (this.isEmpty()) {
return '';
}
const values = this.values();
let objString = `${values[0]}`;
for (let i = 1; i < values.length; i++) {
objString = `${objString},${values[i].toString()}`;
}
return objString;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
* Set
***********************************/
const set = new Set();

set.add(5);
set.add(6);

console.log(set.values());
// [ 5, 6 ]
console.log(set.has(5));
// true
console.log(set.size());
// 2

set.delete(5);
set.delete(6);
console.log(set.values());
// []


// Union
const setA = new Set();
const setB = new Set();

setA.add(1);
setA.add(2);
setA.add(3);

setB.add(3);
setB.add(4);
setB.add(5);
setB.add(6);

const unionAB = setA.union(setB);
console.log(unionAB.values());
// [1, 2, 3, 4, 5, 6]

// Intersection
const setC = new Set();
const setD = new Set();

setC.add(1);
setC.add(2);
setC.add(3);

setD.add(2);
setD.add(3);
setD.add(4);

const intersectionCD = setC.intersection(setD);
console.log(intersectionCD.values());
// [2, 3]

// Difference
const setE = new Set();
const setF = new Set();

setE.add(1);
setE.add(2);
setE.add(3);

setF.add(3);
setF.add(4);
setF.add(5);

const differenceEF = setE.difference(setF);
console.log(differenceEF.values());
// [1, 2]

// Subset
const setG = new Set();
const setH = new Set();
const setI = new Set();

setG.add(1);
setG.add(2);

setH.add(1);
setH.add(2);
setH.add(3);

setI.add(2);
setI.add(3);
setI.add(4);

console.log(setG.isSubsetOf(setH));
// true
console.log(setG.isSubsetOf(setI));
// false

Conclusão

A postagem original pode ser vista no meu Instagram e o código está acessível no meu Github.

Relacionados

Ao fechar este aviso ou continuar navegando no site Nerd Calistênico, você aceita o uso de cookies.

Este site usa cookies para assegurar a melhor experiência para os nossos usuários. Consulte nossa política de privacidade.

Uma nova versão está disponível. Clique aqui para atualizar.