JavaScript 将一个数组的所有记录添加到另一个数组的每条记录中

问题是要求用户将一个数组的所有记录添加到另一个数组的每条记录中。这个问题似乎很难理解和实现代码。简单的意思是给定两个不同值的集合数组，我们需要生成一个组合的新数组，该新生成的数组是这两个数组中存在的每个可能值的集合，比如数组1和数组2。

这个问题的陈述也可以用另一种方式来实现，即给定用户输入的两个数组，找到两个数组的笛卡尔积。

在JavaScript中什么是笛卡尔积

笛卡尔积实际上是数学集合论的一个概念，其中给定两个集合A和B，A * B是所有可能的组合集，其中它的值存在于A或B中，这里问题陈述用用户给定的输入数组替换了状态。

在JavaScript中，代码逻辑将笛卡尔积视为一个问题陈述，其解决方案的基本支柱是遍历每个数组的每个元素，然后将第一个数组的每个元素与第二个数组的每个元素配对。

解决方案在问题陈述方面的可视化如下：

给定两个数组：

const array1 = [ 1, 2 , 3 ];
const array2 = [ 'x' ,'y' , 'z' ] ;

const caretsianProductofArrays = [ [1,'x'] , [1,'y''] , [1,'z'] , [2,'x'] , 
[2,'y'] , [2,'z'] , [3,'x'] , [3,'y'] , [3,'z'] ];

方法- 使用循环

算法的核心逻辑是从给定的两个数组中可能形成每个有序对。

步骤1 ：声明一个名为combineTwoArrayRecords的函数，以array1和array2作为输入。

步骤2 ：声明并初始化结果数组resultArr为空数组。

步骤3 ：我们使用foreach循环遍历数组的元素，该循环使用foreach循环作为回调函数，在外部foreach循环的每次迭代中生成回调foreach的每个可能的对，从而生成数组元素的可能组合。

步骤4 ：为了将数组数组转换为对象数组，我们在每次迭代中通过push方法向其传递键和值参数，使其将两个数组的每个元素的所有可能组合都形成键值对和数组对象的形式。

步骤5 ：一旦所有数组的长度耗尽到javascript的length属性，我们将返回包含两个数组中所有可能组合的元素的结果对象，以键值对的形式。

示例

function combineTwoArrayRecords(arr1 , arr2)
{
   let resultArr =[];
   arr1.forEach(itemArr1 => {
     arr2.forEach(itemArr2 =>{
       resultArr.push({
         'User' : itemArr1 ,
         'City' : itemArr2
       })
     })
   })
   return resultArr;
}

const nameArray = [ "Michael" , "James" ,"Steve"];
const cityArray = [ "NewYork" , "Japan" , "USA" ,"China"]

const finalCombinations = combineTwoArrayRecords( nameArray , cityArray);

console.log(finalCombinations);

输出

[
  { User: 'Michael', City: 'NewYork' },
  { User: 'Michael', City: 'Japan' },
  { User: 'Michael', City: 'USA' },
  { User: 'Michael', City: 'China' },
  { User: 'James', City: 'NewYork' },
  { User: 'James', City: 'Japan' },
  { User: 'James', City: 'USA' },
  { User: 'James', City: 'China' },
  { User: 'Steve', City: 'NewYork' },
  { User: 'Steve', City: 'Japan' },
  { User: 'Steve', City: 'USA' },
  { User: 'Steve', City: 'China' }
]

这是一种使用嵌套循环在javascript中将一个数组的所有记录添加到另一个数组的每个记录中的最简单方法，但是这种算法的时间复杂度很低。

时间和空间复杂度

由于算法中有两个循环，我们经历了一个二次最坏时间复杂度为O(n^2)，但请记住两个数组的长度不相同，即array1的长度为m，array2的长度为n，其中m>n或m<n或m=n。因此，时间复杂性是根据array1和array2的长度而变化的O(mn)。空间复杂度为O(1)，因为没有额外的内存分配。

方法-使用Map和Reduce方法

步骤1 ：声明一个名为combineArrayOfRecords的函数，它以用户提供的数组1和数组2作为输入源。

步骤2 ：返回应用于数组1的reduce函数，使得reduce函数将累加器和当前值作为参数，通过这些参数在调用数组的每个成员上实际执行reduce函数，从而产生一个单一的输出值，即我们需要解决问题陈述的一个可能组合。

步骤3 ：如果没有提供初始值，则参数中的累加器取数组1的第一个值，而当前值取第二个值，其中内部使用map函数应用于数组2，将数组2的每个元素映射到数组1的每个成员上，这被称为将reducer函数形成的键值对形式的用户和城市。

步骤4 ：这是累加器通过spread运算符存储使用reduce和map函数形成的每个可能组合的方式，通过生成每个数组的不同记录来解决问题陈述。

主要代码-使用Map和Reduce方法

示例

function combineArrayOfRecords(arr1,arr2)
{
   return arr1.reduce((accumulator , currentValue)=>

     [...accumulator , ...arr2.map(currentItem=>(

         {
            'User' : currentValue ,
            'City' : currentItem
         }
     ))]


   , [])
}

const nameArray = [ "Michael" , "James" ,"Steve"]
const cityArray = [ "NewYork" , "Japan" , "USA" ,"China"]
const finalArray = combineArrayOfRecords(nameArray , cityArray);
console.log(finalArray);

输出

[
  { User: 'Michael', City: 'NewYork' },
  { User: 'Michael', City: 'Japan' },
  { User: 'Michael', City: 'USA' },
  { User: 'Michael', City: 'China' },
  { User: 'James', City: 'NewYork' },
  { User: 'James', City: 'Japan' },
  { User: 'James', City: 'USA' },
  { User: 'James', City: 'China' },
  { User: 'Steve', City: 'NewYork' },
  { User: 'Steve', City: 'Japan' },
  { User: 'Steve', City: 'USA' },
  { User: 'Steve', City: 'China' }
]

时间和空间复杂度

reduce函数的最小时间复杂度是O(n)，因为在最坏的情况下，array1调用它迭代数组的长度。即使在对array1的每个元素进行每次调用时，还要对数组进行遍历，并调用map方法，时间复杂度为O(n)，两者相加得到O(n) + O(n) = O(n)的时间复杂度。由于没有额外的内存分配，空间复杂度为O(1)。