Merge collided bodies as one - algorithm

Question

I'm working on some Physics stuff in Javascript and basically want to handle collided bodies as one.
I've got an array of all the collisions that occur, a collision consists of two bodies, body A and body B.
Let's say six collision occur, collisions between bodies:
X and Y
Y and Z
C and D
E and F
F and H
G and H
Now I want to merge all the bodies that are in some way connected into a single body. I want those merged bodies in a list. For example in this case I'd want a list that looks like this:
X, Y and Z (Because X collided with Y and Y collided with Z)
C and D (Because C collided with D)
E, F, G and H (Because E collided with F, F with H, and G with H)
Now I'm pretty sure there's some algorithm out there that I need, I just don't know where to look and I'm out of ideas to solve this myself.

Answer 1

How would you do this in real life?
I suppose I would read each rule. For each rule, I'd connect the two pieces. What I'd end up with is a collection of blobs. I could then walk each of the graphs to get the list of nodes in each one. Each "connected component" would be a "blob". Formalizing this algorithm a bit might give this:
// make the graph of connected components
nodes = map<symbol, pair<symbol, list<symbol>>>
for each (a, b) in rules do
if nodes[a] is null then nodes[a] = node(a, [b])
else nodes[a].connections.append(b)
if nodes[b] is null then nodes[b] = node(b, [a])
else nodes[b].connections.append(a)
loop
blobs = map<symbol, list<symbol>>
for each (a, b) in rules do
firstNode = nodes[a]
// do a DFS/BFS search starting from firstNode to find
// all nodes in the connected component. whenever you
// follow a link from a node, remove it from the node's
// list of links. this prevents ever searching from that
// node again since we know what component it's in already
// add each node to the list of symbols in blobs[a]
loop
In the first loop, we read each rule once, then do a constant amount of work, so it is O(n) time in the number of rules. It will store two connections for each rule and so is O(n) storage in terms of the number of rules.
In the second loop, we look at each rule and do a DFS or BFS for each rule's LHS symbol. However, note that the searches will only traverse any edge once, and so this is O(n) time in the number of rules. We will end up with some set of blobs the union of whose lists will be the set of symbols which is no more than the number of rules, so it's O(n) storage as well.
So we have an O(n) time, O(n) space complexity algorithm for determining the blobs. Can we do better, asymptotically speaking? Clearly we need to look at all n rules, so the time complexity is optimal. Also note that any solution to this problem must say for each symbol which blob that symbol ends up belonging to, so simply writing the answer down on the output tape takes O(n) space. So this should be optimal as well.

Answer 2

If you have an ADT (in this case a map) that contains all objects and you keep parent id to track object collisions you can handle each collision+merge in constant time.
// setup
var X = {id: 1, name:'X'};
var Y = {id: 2, name:'Y'};
var Z = {id: 3, name:'Z'};
var C = {id: 4, name:'C'};
var D = {id: 5, name:'D'};
var E = {id: 6, name:'E'};
var F = {id: 7, name:'F'};
var G = {id: 8, name:'G'};
var H = {id: 9, name:'H'};
var all = { 1:X, 2:Y, 3:Z, 4:C, 5:D, 6:E, 7:F, 8:G, 9:H };
// method to merge collided objects together
function collision(obj1, obj2) {
var p1 = obj1.parent;
var p2 = obj2.parent;
if(p1 === undefined && p2 === undefined) {
obj1.parent = obj1.id;
obj2.parent = obj1.id;
obj1.name += obj2.name;
delete all[obj2.id];
} else if(p1 !== undefined && p2 === undefined) {
obj2.parent = obj1.parent;
all[obj1.parent].name += obj2.name;
delete all[obj2.id];
} else if(p1 === undefined && p2 !== undefined) {
obj1.parent = obj2.parent;
all[obj2.parent].name += obj1.name;
delete all[obj1.id];
} else if(p1 !== undefined && p2 !== undefined && obj1.parent !== obj2.parent) {
if(all[obj1.parent] !== undefined) {
all[obj1.parent].name += all[obj2.parent].name;
delete all[obj2.parent];
} else if(all[obj2.parent] !== undefined) {
all[obj2.parent].name += all[obj1.parent].name;
delete all[obj1.parent];
}
}
}
// test
console.log(JSON.stringify(all));
collision(X, Y);
collision(Y, Z);
collision(C, D);
collision(E, F);
collision(F, H);
collision(G, H);
console.log(JSON.stringify(all));
collision(X, E);
console.log(JSON.stringify(all));
{"1":{"id":1,"name":"X"},"2":{"id":2,"name":"Y"},"3":{"id":3,"name":"Z"},"4":{"id":4,"name":"C"},"5":{"id":5,"name":"D"},"6":{"id":6,"name":"E"},"7":{"id":7,"name":"F"},"8":{"id":8,"name":"G"},"9":{"id":9,"name":"H"}}
{"1":{"id":1,"name":"XYZ","parent":1},"4":{"id":4,"name":"CD","parent":4},"6":{"id":6,"name":"EFHG","parent":6}}
{"1":{"id":1,"name":"XYZEFHG","parent":1},"4":{"id":4,"name":"CD","parent":4}}