按每个数组中包含的元素对数组数组进行排序

Question

I need to traverse all connected components in a graph. The paths of the graph are stored in arrays like this:

var paths = [
  [5,6],
  [1,2],
  [4,7,5,6],
  [6]
]

Here i see that paths[2]=[4,7,5,6] depends from paths[0]=[5,6] which in turn depends from paths[3]=[6] .

Now, i would need to recursively traverse all paths to check which one is contained in another and process the ones first that could help to solve the other, ie i need to check which arrays are contained in some of the other arrays:

example:

process [6]
process [5,6]
process [4,7,5,6]
process [1,2]

Due to the large amount of elements, i would prefer not to use recursion. Is there a way to sort this list of arrays by the elements in one array contained in every other array, so that i can process them by iteration?

EDIT: I think this could be solved by assigning a weight to each path composed as follows: sum of the nodes contained in each path multiplied by how many times this node is contained in other paths, then sort the paths by length ascending and weight descending - but this is just only my guess...

Answer 1

I guess... if i have understood correctly, you are after dependency sorting. Then i believe a possible way of achieving this job is as follows. This is one way i could have come up with however there might be simpler solutions as well.

We have to form groups of consecutive items those depend on each other (such as [6] , [5,6] and [4,7,5,6] ) and then we will sort them according to their dependencies. I guess sorting among separate groups is not necessary since their items are not correlated (ie [1,2] can come before or after the sorted group with [6] , [5,6] and [4,7,5,6] ).

 var paths = [ [5,6], [1,2], [4,7,5,6], [6] ], lut = paths.reduce((table,path,i) => (path.forEach(n => table[n] = table[n] ? table[n].concat([[i,path.length]]) .sort((a,b) => a[1]-b[1]) : [[i,path.length]]), table),{}), sorted = Object.keys(lut).sort((a,b) => lut[b].length - lut[a].length) .reduce((si,k) => (lut[k].forEach(e => !si.includes(e[0]) && si.push(e[0])),si) ,[]) .map(idx => paths[idx]); console.log(sorted); 

Ok we first from a look up table like object ( lut ) and in this particular case it forms up like

{ '1': [ [ 1, 2 ] ],
  '2': [ [ 1, 2 ] ],
  '4': [ [ 2, 4 ] ],
  '5': [ [ 0, 2 ], [ 2, 4 ] ],
  '6': [ [ 3, 1 ], [ 0, 2 ], [ 2, 4 ] ],
  '7': [ [ 2, 4 ] ] 
}

So we now know that path 6 has the most dependent. '6': [ [ 3, 1 ], [ 0, 2 ], [ 2, 4 ] ], means at paths[3] it is alone; at paths[0] it has a single dependent and at paths[2] it has 3 dependents. So we have sorted according o the number of dependents ( .sort((a,b) => a[1]-b[1]) ). Once we have our table it's only getting them arranged to give us the desired index mapping. The .reduce((si,k) => (lut[k].forEach(e => !si.includes(e[0]) && si.push(e[0])),si) ,[]) line is a little funny. What it does is for each path pushing it's indice into an array "if" it is not already in the array. So we start with the most dependent one (6) and we push 3, 0 and 2. So when the turn of 5 comes we will not push the same indices again.