Merging list with common elements

Here is another approach using "Matrix" and "igraph" packages.

First, we need to extract the information of which elements are connected. Using sparse matrices can, potetially, save a lot memory usage:

library(Matrix)
i = rep(1:length(mylist), lengths(mylist)) 
j = factor(unlist(mylist))
tab = sparseMatrix(i = i, j = as.integer(j), x = TRUE, dimnames = list(NULL, levels(j)))
#as.matrix(tab)  ## just to print colnames
#         7    10    11    12    13    15    16    17   211   215   216   225   446   469
#[1,]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
#[2,] FALSE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE  TRUE
#[3,] FALSE  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
#[4,] FALSE FALSE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE
#[5,] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
#[6,] FALSE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE FALSE  TRUE  TRUE FALSE FALSE

Find if each element is connected to each other:

connects = tcrossprod(tab, boolArith = TRUE)
#connects
#6 x 6 sparse Matrix of class "lsCMatrix"
#                
#[1,] | . . . . .
#[2,] . | | | . .
#[3,] . | | | . .
#[4,] . | | | . .
#[5,] . . . . | |
#[6,] . . . . | |

Then, using graphs, we can group the indices of "mylist":

library(igraph)
# 'graph_from_adjacency_matrix' seems to not work with the "connects" object directly. 
# An alternative to coercing "connects" here would be to build it as 'tcrossprod(tab) > 0'

group = clusters(graph_from_adjacency_matrix(as(connects, "lsCMatrix")))$membership
#group
#[1] 1 2 2 2 3 3

And, finally, concatenate:

tapply(mylist, group, function(x) sort(unique(unlist(x))))
#$`1`
#[1] 7
#
#$`2`
#[1]  10  11  12  13 211 215 446 469
#
#$`3`
#[1]  15  16  17 216 225

tapply(1:length(mylist), group, toString)
#        1         2         3 
#      "1" "2, 3, 4"    "5, 6" 

Not happy with the solution but this I think gives the answer. There is still scope of improvement :

unique(sapply(lst, function(x) 
       unique(unlist(lst[sapply(lst, function(y) 
                         any(x %in% y))]))))


#[[1]]
#[1] 7

#[[2]]
#[1]  10  11  12 211 446 469  13 215

#[[3]]
#[1]  15  16  17 216 225

This is basically double loop to check if any of the list element is present in any another list. If you find any such element then merge them together taking only unique values out of them.

data

lst <- list(7, c(10 ,11 ,12, 211, 446, 469), c(10, 11, 12, 13),c(11 ,12, 13 ,215), 
               c(15, 16), c(15, 17 ,216 ,225))

Here's a recursive function that accomplishes the task (although right now it generates a bunch of warnings).

mylist <- list(7, c(10, 11, 12, 211, 446, 469), c(10, 11, 12, 13), c(11, 12, 13, 215), c(15, 16), c(15, 17, 216, 225))

commonElements = function(l,o=list(l[[1]])){
  if(length(l) == 0){return(o)}
  match = which(unlist(lapply(lapply(o,intersect,l[[1]]),any)))
  if(length(match) == 0) o[[length(o)+1]] = l[[1]]
  if(length(match) == 1) o[[match]] = unique(c(o[[match]],l[[1]]))
  if(length(match) > 1){
    o[[match[1]]] = unique(unlist(o[match]))
    p[rev(match)[-1]] = NULL
  }
  l[[1]] = NULL
  commonElements(l,o)
}

commonElements(mylist)

Basically, pass in a list and instantiate the output, o, with the first element of l. Then check each value of l against every group in o, if it matches nothing, make a new element in o, if it matches one, keep the unique set and if it matches more than 1, concatenate the groups in o and drop the extras.

Here's a purrr-based approach:

library(purrr)

mylist <- list(7, 
               c(10, 11, 12, 211, 446, 469), 
               c(10, 11, 12, 13), 
               c(11, 12, 13, 215), 
               c(15, 16), 
               c(15, 17, 216, 225))

result <- mylist %>% 
    # check whether any numbers of an element are in any of the elements
    map(~map_lgl(mylist, compose(any, `%in%`), .x)) %>% 
    unique() %>%    # drop duplicated groups
    map(~reduce(mylist[.x], union))    # subset lst by group and collapse subgroups

str(result)
#> List of 3
#>  $ : num 7
#>  $ : num [1:8] 10 11 12 211 446 469 13 215
#>  $ : num [1:5] 15 16 17 216 225

The logic here is similar to Ronak's answer; I just find this easier to read. If you like, you could write the last line as map(~unique(flatten_dbl(mylist[.x]))) or split it into map(~mylist[.x]) %>% simplify_all() %>% map(unique).

For the indices of which element is aggregated to which group, just call which on the elements used for subsetting:

mylist %>% 
    map(~map_lgl(mylist, compose(any, `%in%`), .x)) %>% 
    unique() %>% 
    map(which) %>% 
    str()
#> List of 3
#>  $ : int 1
#>  $ : int [1:3] 2 3 4
#>  $ : int [1:2] 5 6

An alternative logic for the whole thing is to make the list nested instead of the calls, which means the self-join is up front (with cross2), there's no subsetting later, and most of the functions are just set operations:

mylist %>% 
    map(cross2, mylist) %>% 
    modify_depth(2, reduce, ~if(length(intersect(.x, .y)) > 0) sort(union(.x, .y))) %>% 
    map(reduce, union) %>% 
    unique()

or using cross2's .filter parameter,

mylist %>% 
    map(cross2, mylist, ~length(intersect(.x, .y)) == 0) %>% 
    map(compose(sort, unique, unlist)) %>% 
    unique()

which could be condensed to

mylist %>% 
    map(function(element) sort(unique(unlist(cross2(element, mylist, ~length(intersect(.x, .y)) == 0))))) %>%
    unique()

These approaches don't drop duplicate groups until the end, though, so they're likely less efficient.