चलने के मार्ग को रिकर्सिव करें और चलने के पथ को प्रिंट करें

Question

क्या कोई मुझे किसी कोड या निर्देशों के साथ दोबारा चलने के तरीके में मदद कर सकता है और आखिरी तत्व तक पहुंचने पर पूरा पथ प्रिंट कर सकता है? एक साधारण गूंज काम करेगी क्योंकि मैं कोड को अन्य किसी भी फ़ंक्शन में अनुकूलित कर दूंगा जो मैं विकसित कर रहा हूं।

समारोह सरणी आयाम लगाने की है क्योंकि इस परम पारित हो जाएगा की जरूरत नहीं है:

उदाहरण:

$depth = 8; 

$array[1][3][5][6][9][5][8][9]; 

समारोह 8 तत्व यह है कि यह करने के लिए सभी पथ प्रिंट reachs जब:

//print path 
'1 -> 3 -> 5 -> 6 -> 9 -> 5 -> 8 -> 9' 

• जैसा कि मैंने कहा, केवल इस प्रारूप में मुद्रण कारण मैं लूंगा काम करेंगे कोड को किसी अन्य फ़ंक्शन में लागू करें।

• सरणी कुंजी के समान मूल्य हो सकता है। स्पष्ट रूप से संपूर्ण arary के लिए एक ही अनुक्रम में एक ही मूल्य नहीं है।

अपडेट किया गया:

वॉक रिकर्सिवली काम करते हैं:

$someArray[1][2][3] = 'end'; 
$someArray[1][2][6] = 'end'; 
$someArray[1][3][6] = 'end'; 
$someArray[4][3][7] = 'end'; 

function listArrayRecursive(&$array_name, $ident = 0){ 
    if (is_array($array_name)){ 
     foreach ($array_name as $k => &$v){ 
      if (is_array($v)){ 
       for ($i=0; $i < $ident * 10; $i++){ echo "&nbsp;"; } 
       echo $k . " : " . "<br>"; 
       listArrayRecursive($v, $ident + 1); 
      }else{ 
       for ($i=0; $i < $ident * 10; $i++){ echo "&nbsp;"; } 
       echo $k . " : " . $v . "<br>"; 
      } 
     } 
    }else{ 
     echo "Variable = " . $array_name; 
    } 
} 

listArrayRecursive($someArray); 

प्रिंट होगा:

1 : 
     2 : 
       3 : end 
       6 : end 
     3 : 
       6 : end 
4 : 
     3 : 
       7 : end 

अब, मैं भी सरणी के रास्ते हर मुद्रित कर सकते हैं यह अंत तक पहुंचता है? उदाहरण के लिए:

1 : 
     2 : 
       3 : end : path -> 1,2,3 
       6 : end : path -> 1,2,6 
     3 : 
       6 : end : path -> 1,3,6 
4 : 
     3 : 
       7 : end : path -> 4,3,7 

संपादित कोड तीसरे PARAM जोड़ना पथ को रिकॉर्ड करने:

$someArray[1][2][3] = 'end'; 
$someArray[1][2][6] = 'end'; 
$someArray[1][3][6] = 'end'; 
$someArray[4][3][7] = 'end'; 
$someArray[3][2] = 'end'; 

function listArrayRecursive(&$array_name, $ident = 0, $path = null){ 
    foreach ($array_name as $k => &$v){ 
     if (is_array($v)){ 
      for ($i=0; $i < $ident * 10; $i++){ echo "&nbsp;"; } 
      echo $k . " : " . "<br>"; 
      $path .= $k . ', '; 
      listArrayRecursive($v, $ident + 1, $path); 
     }else{ 
      for ($i=0; $i < $ident * 10; $i++){ echo "&nbsp;"; } 
      echo $k . " : " . $v . ' - path -> ' . $path . "<br>"; 
     } 
    } 
} 

listArrayRecursive($someArray); 

प्रिंट होगा:

1 : 
      2 : 
        3 : end - path -> 1, 2, 
        6 : end - path -> 1, 2, 
      3 : 
        6 : end - path -> 1, 2, 3, 
4 : 
      3 : 
        7 : end - path -> 1, 4, 3, 
3 : 
      2 : end - path -> 1, 4, 3, 

Answer 1

आप एरे के माध्यम से रिकर्सिंग से कड़ी मेहनत करने के लिए RecursiveIteratorIterator (docs) नियोजित कर सकते हैं।

function listArrayRecursive($someArray) { 
    $iterator = new RecursiveIteratorIterator(new RecursiveArrayIterator($someArray), RecursiveIteratorIterator::SELF_FIRST); 
    foreach ($iterator as $k => $v) { 
     $indent = str_repeat(' ', 10 * $iterator->getDepth()); 
     // Not at end: show key only 
     if ($iterator->hasChildren()) { 
      echo "$indent$k :<br>"; 
     // At end: show key, value and path 
     } else { 
      for ($p = array(), $i = 0, $z = $iterator->getDepth(); $i <= $z; $i++) { 
       $p[] = $iterator->getSubIterator($i)->key(); 
      } 
      $path = implode(',', $p); 
      echo "$indent$k : $v : path -> $path<br>"; 
     } 
    } 
} 

Answer 2

यह उदाहरण आपको जानकारी देना है, हल करने के लिए नहीं वास्तविक कार्य

function recursiveSearch($array,$search){ 
    foreach($array as $key=>$val){ 
     if($val==$search)return $key; 
     $x=recursiveSearch($array[$key],$search); 
     if($x)return $key.' -> '.$x; 
    } 
} 

echo recursiveSearch($array,'search'); 

यदि कोई मिलान नहीं मिला है, तो शून्य वापस आ गया है।

Answer 3

$a= array(1,2,3,4,5,6); 
$val = end($a); 
print_array($a,$val); 
function print_array(&$arr, $val) 
{ 
    if ($val === false) 
     return; 

    $curr = prev($arr); 
    print_array($arr,$curr); 
    echo $val; 
} 

Answer 4

आप एक तीसरा पैरामीटर जोड़ सकते हैं जिसमें स्ट्रिंग के रूप में वास्तविक पथ है। अंत में आप इसे आउटपुट कर सकते हैं।

Answer 5

मैं सिर्फ एक समारोह है कि थोड़ा आसान पाशन पुनरावर्ती बनाता लिखा है: इसी array_walk_recursive लिए लेकिन कुछ अतिरिक्त कार्यक्षमता के साथ

public static function walk($array, $callback, $custom = null, $recursive = false, $info = []) 
{ 
    $r = $recursive; 
    if (gettype($r) === 'integer') { 
     $r--; 
    } 
    $info['depth'] = empty($info)?1:$info['depth'] + 1; 
    $info['count'] = count($array); 
    $info['i'] = 1; 
    foreach($array as $k => $v) { 
     if (is_array($v) && $r > 0) { 
      $array[$k] = static::walk($v, $callback, $custom, $r, $info); 
     } else { 
      $array[$k] = $callback($v, $k, $custom, $info); 
     } 
     $info['i'] ++; 
    } 
    return $array; 
} 

public static function walkable($v, $k, $custom, $info) 
{ 
    if (is_string($v)) { 
     return $v." [ custom: {$custom['key']} ] [ level: ".$info['depth'].' | No '.$info['i'].' of '.$info['count']." ]"; 
    } 
    return $v; 
} 

तो जैसे कहा जाता है:

$result = Namespace\ClassName::walk($array, ['Namespace\ClassName', 'walkable'], ['key'=>'value'], true); 

को पुनरावर्ती स्थापना झूठी केवल पहले स्तर का मूल्यांकन करेगा।

सत्य पर रिकर्सिव सेट करना पूरे सरणी को पार करने का कारण बनता है।

एक पूर्णांक में रिकर्सिव सेट करने से यह केवल उस गहराई तक पहुंच जाएगा।

चलने योग्य कार्यों को संदर्भित किया जा सकता है या कॉलबैक को अज्ञात फ़ंक्शन के रूप में पास किया जा सकता है।

(अपेक्षाएं: मूल्य, कुंजी, कस्टम, जानकारी) लौटाया गया मूल्य वर्तमान मान को प्रतिस्थापित करता है।

कस्टम डेटा पास किया जा सकता है और आपके लिए कुछ अतिरिक्त जानकारी प्रदान की जाती है।

यदि आपको अतिरिक्त जानकारी की आवश्यकता है तो आप पैदल कार्य पर विस्तार कर सकते हैं।

Answer 6

मुझे भी इसी तरह की समस्या थी। यहां एक गहराई-पहला खोज-आश समाधान है (कोई पथ गहराई शामिल नहीं है, यह सरणी के बहुत अंत तक पहुंचता है)। 'अगर' बयान टिप्पणी करता है, तो यू मूल्य में शामिल नहीं करना चाहता:

$output = array(); 
retrievePath($someArray, $output); 

function retrievePath($someArray, array &$pathKeeper) 
{ 
    if(!is_array($someArray)){ // $someArray == "end" 
     $element = array_pop($pathKeeper) ?? '';// if the array is empty pop returns null, we don't want that 
     array_push($pathKeeper, $element . '->'. $someArray); 
    } else{ 
     end($someArray);//we want to get the last element from the array so we move the internal pointer to it's end 
     $endElKey = key($someArray);//take the key where the pointer is 
     reset($someArray); 
     foreach($someArray as $key=>$value){ 
      $element = array_pop($pathKeeper); 
      array_push($pathKeeper, $element === null ? $key : $element . '->' . $key);// we don't want '->' at the beginning 
      retrievePath($value, $pathKeeper); 
      if($key != $endElKey) //we check whether this is not the last loop 
       array_push($pathKeeper, $element); 
     } 
    } 
} 

Answer 7

<?php 
function printListRecursive($a, $var='', $i = 0) { 
    if (!is_array($a)) { 
     $var .= $a; 
     return $var; 
    } 
    $string = ""; 
    foreach ($a as $k => $value) { 
     $string .= str_repeat("&nbsp;&nbsp;", $i) .' - '. $k . ':'; 
     if (!is_array($value)) { 
      $string .= $value . '<br />'; 
     } else { 
      $string .= '<br />'; 
      $string .= printListRecursive($value, $var, $i + 1); 
     } 
    } 
    return $string; 
} 
$test_array = [ 
    'America' => [ 
     'Argentina' => 'Buenos Aires', 
     'Peru' => 'Lima' 
    ], 
    'Europe' => [ 
     'Ireland' => 'Dublin', 
     'France' => 'Paris', 
     'Italy' => 'Rome' 
    ] 
]; 
$result = printListRecursive($test_array); 
echo $result; 
?> 

Check code here