We can to implement this in Javasсript like:



  1. function printTree(t, index, r, delim) {
  2.     var out = [],
  3.         prefix, res;
  4.     r = r || '';
  5.     delim = delim || ' ';
  6.     index = index || 0;
  7.     if (index < t.length) {
  8.         t = t.map(function(el) {
  9.             return el instanceof Array ? el : [el];
  10.         });
  11.         prefix = r ? r + delim : '';
  12.         for (var i = 0; i < t[index].length; i++) {
  13.             if (t[index][i] instanceof Array) {
  14.                 res = printTree(t[index][i], 0, r, delim);
  15.             } else {
  16.                 res = [prefix + t[index][i]];
  17.             }
  18.             for (var j = 0; j < res.length; j++) {
  19.                 out = out.concat(printTree(t, index + 1, res[j], delim));
  20.             }
  21.         }
  22.     } else {
  23.         return [r];
  24.     }
  25.     return out;
  26. }
  27.  
  28. var tests = [
  29.     [1, 2, 3],
  30.     [1, [2, 3]],
  31.     [
  32.         [1, 2], 3
  33.     ],
  34.     [
  35.         [1, 2],
  36.         [3, 4]
  37.     ],
  38.     [
  39.         [1, 2],
  40.         [3, [4, 5], 6]
  41.     ],
  42.     [1, [2, [3, [4, 5]]]],
  43.     [
  44.         [1, 2],
  45.         [
  46.             [3, [4, 5, 6]], 7
  47.         ]
  48.     ],
  49.     [
  50.         [1, 2],
  51.         [
  52.             [3, [4, 5, 6]], 7
  53.         ], 8
  54.     ],
  55.     [
  56.     	1, 
  57.     	[
  58.     		2, 
  59.     		[
  60.     			3, 
  61.     			[
  62.     				4, 
  63.     				[5, 6]
  64.     			], 
  65.     			7
  66.     		], 
  67.     		8
  68.     	], 
  69.     	9
  70.     ],
  71.     [
  72.     	1, 
  73.     	[
  74.     		2, 
  75.     		[
  76.     			3, 
  77.     			[
  78.     				[
  79.     					4, 
  80.     					[5, 6]
  81.     				]
  82.     			], 
  83.     			7
  84.     		], 
  85.     		8
  86.     	], 
  87.     	9
  88.     ]
  89. ];
  90.  
  91. for (var i = 0; i < tests.length; i++) {
  92.     print(printTree(tests[i]).join('\n'));
  93.     print('\n')
  94. }




As you can see, on each iteration we "increment" accumulator with string, and returns whole string when recursion is over.







You can check it in action at: ideone.com/tP5KTC