Иерархический массив Преобразование в плоский массив

Question

У меня есть массив

$array = array(
    array(1,2,3), 
    array('bob','bill'), 
    array(4,5,6,7) 
    //can have between 0 and 5 "rows" 
); 

Я хочу, чтобы преобразовать в массив, который выглядит следующим образом ...

[1,bob,4, 1, bob, 5, 1, bob, 6, 1, bob, 7, 1, bill, 4 .... 3, bill, 7] 

Я пытался написать рекурсивный функция для этого, которое выглядит как ...

function GetValues($array, $rowIndex, $valIndex, $values) 
{ 
    if(!isset($array[$rowIndex])) 
    { 
     return $values; 
    } 
    if(!isset($array[$rowIndex][$valIndex])) 
    { 
     return GetValues($array,$rowIndex+1, 0, $values); 
    } 
    $values[] = $array[$rowIndex][$valIndex]; 

    return GetValues($array,$rowIndex, $valIndex+1, $values); 
} 

который только заканчивает переборе массива обычно (печатает 1,2,3, ЛПП, счет, 4,5,6, 7)

Answer 1

$array = array(
    array(1,2,3), 
    array('bob','bill'), 
    array(4,5,6,7) 
); 
function combinations($arrays) { 
    $result[] = array(); 
    foreach ($arrays as $key => $values) { 
     $tmp = array(); 
     foreach ($result as $result_item) { 
      foreach ($values as $value) { 
       $tmp[] = array_merge($result_item, array($key => $value)); 
      } 
     } 
     $result = $tmp; 
    } 

    return $result; 
} 
$combinations_array = combinations($array); 
$flat_string = ''; 
$flat_array = array(); 
foreach($combinations_array as $value){ 
     foreach($value as $v){ 
      $flat_string.=$v.','; 
      $flat_array[]=$v; 
     } 
    } 

echo rtrim($flat_string,','); 
print_r($flat_array); 

Out Помещенный строка: 1, боб, 4,1, боб, 5,1, боб, 6,1, боб, 7,1, счет, 4,1, счет, 5 , 1, счет, 6,1, счет, 7,2, ЛПП, 4,2, ЛПП, 5,2, ЛПП, 6,2, ЛПП, 7,2, счет, 4,2, счет, 5,2 , счет, 6,2, счет, 7,3, ЛПП, 4,3, ЛПП, 5,3, ЛПП, 6,3, ЛПП, 7,3, счет, 4,3, счет, 5,3, счет , 6,3, клюв, 7

Выходной массив:

Array 
(
    [0] => 1 
    [1] => bob 
    [2] => 4 
    [3] => 1 
    [4] => bob 
    [5] => 5 
    [6] => 1 
    [7] => bob 
    [8] => 6 
    [9] => 1 
    [10] => bob 
    [11] => 7 
    [12] => 1 
    [13] => bill 
    [14] => 4 
    [15] => 1 
    [16] => bill 
    [17] => 5 
    [18] => 1 
    [19] => bill 
    [20] => 6 
    [21] => 1 
    [22] => bill 
    [23] => 7 
    [24] => 2 
    [25] => bob 
    [26] => 4 
    [27] => 2 
    [28] => bob 
    [29] => 5 
    [30] => 2 
    [31] => bob 
    [32] => 6 
    [33] => 2 
    [34] => bob 
    [35] => 7 
    [36] => 2 
    [37] => bill 
    [38] => 4 
    [39] => 2 
    [40] => bill 
    [41] => 5 
    [42] => 2 
    [43] => bill 
    [44] => 6 
    [45] => 2 
    [46] => bill 
    [47] => 7 
    [48] => 3 
    [49] => bob 
    [50] => 4 
    [51] => 3 
    [52] => bob 
    [53] => 5 
    [54] => 3 
    [55] => bob 
    [56] => 6 
    [57] => 3 
    [58] => bob 
    [59] => 7 
    [60] => 3 
    [61] => bill 
    [62] => 4 
    [63] => 3 
    [64] => bill 
    [65] => 5 
    [66] => 3 
    [67] => bill 
    [68] => 6 
    [69] => 3 
    [70] => bill 
    [71] => 7 
) 

Answer 2

Проблема, которую вы, скорее всего, не знаете, насколько большой исходный массив. Вы можете записать его рекурсивно, уничтожив массив. В этом примере я переношу первый элемент из исходного массива. Затем, с каждым рекурсивным вызовом, я переношу другой элемент. Я использую цикл for для прохождения значений и возврата того, что я создал.

function flatten($array) 
{ 
    if(sizeof($array)==0) return null; 
    $first = array_shift($array); 
    $ret = array(); 
    foreach($first as $value) 
    { 
     $ret[] = $value; 
     $sub = flatten($array); 
     if($sub != null) 
      $ret = array_merge($ret, $sub); 
    } 
    return $ret; 
}