Рекурсивный поиск элемента в массиве

Question

Как найти элемент в массиве с помощью рекурсии? Например нам приходит массив, мы не знаем его вложенность и длину. Как это реализовать на функциях.

Задача -> нужно собрать все подходящие элементы, а не вернуть первую найденную.

Проблема -> не знаю как передать новый вложенный массив к функции и завершить функцию когда мы дошли до конца массива.

Вот начало, не знаю правильно ли.

let arr = [
    1,
    [1, 2, 3, 4, 5],
    [12, 23, 44],
    [5, 77, 1, 213, 4, 21, 44],
    [
        [1, 44, 414],
        [12, 31, 31, 55]
    ],
    [
        [
            [1, 2], [3, 4]
        ],
        [
            [5, 6], [7, 8]
        ]
    ]
]

function searchInArray(arr, target) {
    let newArr = []

    arr.forEach(el => {
        el === target && newArr.push(el);
    });

    searchInArray(arr, target);
}

Answer 1

Как найти элемент в массиве с помощью рекурсии?

Можно предложить вот такой вариант поиска...

let arr = [
  1, [1, 2, 3, 4, 5],
  [12, 23, 44],
  [5, 77, 1, 213, 4, 21, 44],
  [
    [1, 44, 414],
    [12, 31, 31, 55]
  ],
  [
    [
      [1, 2],
      [3, 4]
    ],
    [
      [5, 6],
      [7, 8]
    ]
  ]
]
console.log(searchInArray(arr, 44))

//
function searchInArray(arr, target) {
  return newArr = arr.reduce((a, v) => {
    // если это массив - рекурсивно вызываем функцию
    if (Array.isArray(v)) return [...a, ...searchInArray(v, target)]
    // если это нужный элемент добавляем его
    if (v === target) return [...a, v]
    return a
  },[])
}

Answer 2

traverse рекурсивно обходит все элементы всех вложенных массивов и передаёт их в функцию обратного вызова cb.

searchInArray с помощью traverse отбирает нужные элементы и помещает их в список found.

const traverse = (a, cb) => {
    if (Array.isArray(a)) {
        for (const v of a) {
            traverse(v, cb);
        }
    } else {
        cb(a);
    }
};

const searchInArray = (a, target) => {
    const found = [];
    traverse(a, v => {
        if (v === target) {
            found.push(v);
        }
    });
    return found;
}

console.log(searchInArray([
    1,
    [1, 2, 3, 4, 5],
    [12, 23, 44],
    [5, 77, 1, 213, 4, 21, 44],
    [[1, 44, 414], [12, 31, 31, 55]],
    [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
], 44));

traverse можно записать в виде генератора. Код в searchInArray упростится - не нужна функция обратного вызова, всё можно сделать в цикле:

function* traverse(a) {
    if (Array.isArray(a)) {
        for (const v of a) {
            yield* traverse(v);
        }
    } else {
        yield a;
    }
};

const searchInArray = (a, target) => {
    const found = [];
    for (const v of traverse(a)) {
        if (v === target) {
            found.push(v);
        }
    }
    return found;
}

console.log(searchInArray([
    1,
    [1, 2, 3, 4, 5],
    [12, 23, 44],
    [5, 77, 1, 213, 4, 21, 44],
    [[1, 44, 414], [12, 31, 31, 55]],
    [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
], 44));

БЛОГ НА HUSL

Рекурсивный поиск элемента в массиве

Ответы (2 шт):