Как найти номер элемента в массиве

В этом посте будет обсуждаться, как найти индекс элемента в массиве в C#.

Решение должно либо возвращать индекс первого вхождения требуемого элемента, либо -1, если его нет в массиве.

1. Использование Array.IndexOf() метод

Рекомендуемое решение — использовать Array.IndexOf() метод, который возвращает индекс первого вхождения указанного элемента в этот массив.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

using System; public static class Extensions {     public static int findIndex<T>(this T[] array, T item) {         return Array.IndexOf(array, item);     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

2. Использование Array.FindIndex() метод

The Array.FindIndex() метод возвращает индекс первого элемента, который удовлетворяет предоставленному предикату, или -1 если такого элемента нет.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

using System; public static class Extensions {     public static int findIndex<T>(this T[] array, T item) {         return Array.FindIndex(array, val => val.Equals(item));     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

3. Использование Enumerable.Select() метод

The System.Linq.Enumerable.Select() метод проецирует каждый элемент последовательности в новую форму. В следующем примере кода показано, как мы можем использовать Select() для проецирования последовательности значений и использования как значения, так и индекса каждого элемента, чтобы найти первое вхождение указанного элемента в этом массиве.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

using System; using System.Linq; using System.Collections.Generic; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         try {             return array                 .Select((element, index) => new KeyValuePair<T, int>(element, index))                 .First(x => x.Key.Equals(item)).Value;         }         catch (InvalidOperationException) {             return —1;         }     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

 
Мы можем избежать блока try-catch, используя FirstOrDefault() метод вместо First():

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

using System; using System.Linq; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         return array             .Select((element, index) => new { element, index })             .FirstOrDefault(x => x.element.Equals(item)) ?. index ?? —1;     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

4. Выполнение линейного поиска

Наивное решение состоит в том, чтобы выполнить линейный поиск в заданном массиве, чтобы определить, присутствует ли целевой элемент в массиве.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

using System; using System.Collections.Generic; public static class Extensions {     public static int findIndex<T>(this T[] array, T item)     {         EqualityComparer<T> comparer = EqualityComparer<T>.Default;         for (int i = 0; i < array.Length; i++)         {             if (comparer.Equals(array[i], item)) {                 return i;             }         }         return —1;     } } public class Example {     public static void Main()     {         int[] array = { 1, 2, 3, 4, 5 };         int item = 4;         int index = array.findIndex(item);         if (index != —1) {             Console.WriteLine(String.Format(«Element {0} is found at index {1}», item, index));         }         else {             Console.WriteLine(«Element not found in the given array.»);         }     } } /*     результат: Element 4 is found at index 3 */

Скачать  Выполнить код

Вот и все, что касается поиска индекса элемента в массиве в C#.

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂

Сводка

Метод indexOf() возвращает первый индекс, по которому данный элемент может быть найден в массиве или -1, если такого индекса нет.

Синтаксис

arr.indexOf(searchElement[, fromIndex = 0])

Параметры

searchElement

Искомый элемент в массиве.

fromIndex

Индекс, с которого начинать поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу. Если рассчитанный индекс оказывается меньше 0, поиск ведётся по всему массиву. Значение по умолчанию равно 0, что означает, что просматривается весь массив.

Описание

Метод indexOf() сравнивает искомый элемент searchElement с элементами в массиве, используя строгое сравнение (en-US) (тот же метод используется оператором ===, тройное равно).

Примеры

Пример: использование indexOf()

В следующем примере indexOf() используется для поиска значений в массиве.

var array = [2, 5, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1
array.indexOf(9, 2);  // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

Пример: нахождение всех вхождений элемента

В следующем примере indexOf() используется для поиска всех индексов элемента в указанном массиве, которые с помощью push() добавляются в другой массив.

var indices = [];
var array = ['a', 'b', 'a', 'c', 'a', 'd'];
var element = 'a';
var idx = array.indexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}

console.log(indices);
// [0, 2, 4]

Полифил

Метод indexOf() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать indexOf() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что TypeError и Math.abs() имеют свои первоначальные значения.

// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.14
// Ссылка (en): http://es5.github.io/#x15.4.4.14
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.14
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(searchElement, fromIndex) {
    var k;

    // 1. Положим O равным результату вызова ToObject с передачей ему
    //    значения this в качестве аргумента.
    if (this == null) {
      throw new TypeError('"this" is null or not defined');
    }

    var O = Object(this);

    // 2. Положим lenValue равным результату вызова внутреннего метода Get
    //    объекта O с аргументом "length".
    // 3. Положим len равным ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. Если len равен 0, вернём -1.
    if (len === 0) {
      return -1;
    }

    // 5. Если был передан аргумент fromIndex, положим n равным
    //    ToInteger(fromIndex); иначе положим n равным 0.
    var n = +fromIndex || 0;

    if (Math.abs(n) === Infinity) {
      n = 0;
    }

    // 6. Если n >= len, вернём -1.
    if (n >= len) {
      return -1;
    }

    // 7. Если n >= 0, положим k равным n.
    // 8. Иначе, n<0, положим k равным len - abs(n).
    //    Если k меньше нуля 0, положим k равным 0.
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

    // 9. Пока k < len, будем повторять
    while (k < len) {
      // a. Положим Pk равным ToString(k).
      //   Это неявное преобразование для левостороннего операнда в операторе in
      // b. Положим kPresent равным результату вызова внутреннего метода
      //    HasProperty объекта O с аргументом Pk.
      //   Этот шаг может быть объединён с шагом c
      // c. Если kPresent равен true, выполним
      //    i.  Положим elementK равным результату вызова внутреннего метода Get
      //        объекта O с аргументом ToString(k).
      //   ii.  Положим same равным результату применения
      //        Алгоритма строгого сравнения на равенство между
      //        searchElement и elementK.
      //  iii.  Если same равен true, вернём k.
      if (k in O && O[k] === searchElement) {
        return k;
      }
      k++;
    }
    return -1;
  };
}

Спецификации

Specification
ECMAScript Language Specification # sec-array.prototype.indexof

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

Урок 23. Поиск элемента в массиве

Просмотров 2.6к. Обновлено 23 ноября 2020

Урок из серии: «Язык программирования Паскаль»

На этом уроке рассмотрим алгоритмы поиска элемента в одномерном массиве. Эти алгоритмы очень похожи на обработку последовательностей (поиск, выборка и т.д.).

Отличие заключается в том, что в массиве одновременно доступны все его компоненты. Такой доступ называется параллельным.

Рассмотрим несколько примеров.

Пример 1. Найти номера четных элементов.

Решение.

Для нахождения четных элементов необходимо просмотреть весь массив, и если будут попадаться четные элементы, то нужно выводить их на экран. Напишем процедуру, которая принимает в качестве входного параметра массив и выводит на экран нужные элементы.

Procedure Solve(m : myarray);
Var i: Integer;
Begin
   For i:=1 To n Do 
      If m[i] Mod 2 = 0 Then Write(i:5);{если элемент четный, то вывести на экран}
End;

Пример 2. Есть ли отрицательный элемент в массиве?

Решение.

Для решения таких задач удобнее использовать циклы с условиями и составлять функции, результат которых имеет логический тип.

Начинаем с первого элемента (i = 1).

Пока не просмотрен последний (i<=n) и не найден отрицательный (m [i]>=0), будем переходить к следующему (inc (i)).

Таким образом, мы закончим просмотр в одном из двух случаев:

• первый — просмотрели все элементы и не нашли отрицательный, тогда i>n;
• второй — нашли нужный, при этом i<=n.

Напишем функцию, значение которой истина (True), если такой элемент есть, и ложь (False), если его нет.

Function Controll (m: myarray): Boolean;
Var i : Integer;
Begin
   i := 1;
   While (i<=n) And (m[i]>0) Do Inc(i);
   Control1:=(i<=n)
End;

Пример 3. Найти номер последнего отрицательного элемента массива.

Решение.

Последний отрицательный — это первый отрицательный элемент, если начать просмотр с конца.

Если очередной элемент не является отрицательным, то нужно уменьшать значение текущего индекса, пока он не станет меньше номера первого элемента или не будет найден отрицательный элемент.

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

Договоримся, что если такого элемента нет, то значение функции будет равно 0.

Function Control2 (m: myarray): Integer;
Var i : Integer;
Begin
   i:=n;
   While (i>=1) And (m[i]>0) Do Des(i);
   If i<1 Then Control2:=0
          Else Control2:=i;
End;

Вы рассмотрели алгоритмы на поиск и выборку элементов в массиве.

На следующем уроке продолжим знакомиться с алгоритмами  обработки одномерных массивов.

Array

Объект Array служит для создания массивов. Массив — это набор элементов, содержащих значения, сохраненный под одним именем. Например, массив score может использоваться для сохранения счета сыгранных матчей. Массивы могут состоять из чисел, строковых переменных, объектов и других типов данных. Перед использованием массив необходимо объявить через конструктор Array и оператор new.

Создадим несколько массивов:

array1 = new Array(); // массив без заданных значений
array2 = new Array(30); // Массив из 30 элементов
array3 = new Array(1,, 2, 3, "four", "five"); // Массив с определенными значениями

Если длина массива не определена, как показано в первом примере, то она может изменяться динамически, при этом элементами массива могут быть значения любого типа. Чтобы определить значения массива, укажите его индекс в скобках. Индексирование элементов массива начинается с 0, поэтому элементы объявленного выше второго массива имеют индексы 0—29, но общее их количество равно числу аргументов. Следующие операторы определяют значения первых четырех элементов массива:

scores[0] = 39;
scores[1] = 40;
scores[2] = 100;
scores[3] = 49;

Также можно использовать другой способ создания массива через квадратные скобки.

const cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats[2]); // выводит третий элемент массива Рыжик

Вы можете переписать значение в массиве по его индексу.

cats[1] = "Васька";
// Проверим
console.log(cats[1]);

Можно сначала создать пустой массив, а потом добавить нужные элементы.

const cats[];
cats[0] = "Барсик";
cats[1] = "Мурзик";

Можно добавлять не по порядку, например, сразу в пятый индекс. Тогда в 3 и 4 будут значения undefined.

cats[5] = "Пушок";
console.log(cats[4]);

В массив можно вложить ещё один массив.

Массивы имеют свойство length. Оно определяет количество элементов, из которых состоит массив. Оно же определяется при создании массива. В следующем примере отображается число элементов массива array2:

console.log(array2.length);

Зная длину массива, мы можем быстро узнать индекс последнего элемента, вычитая единицу.

console.log(cats.length - 1);

Массивы часто используются в циклах

var num = new Array (1, 2, 3, 4, 5, 6, 7, 8, 9);
var sum = 0;
for (i = 0; i < num.length; i++)
  sum += num[i];

В начале примера инициируется массив с именем num, состоящий из девяти элементов. В цикле пробегаем по всем элементам массива с помощью конструкции num[i] и суммируем все значения массива.

Массивы являются весьма гибкими. Размер массива устанавливается динамически. Если мы создадим массив myArray[29] = «Вася», то величина массива автоматически устанавливается в размере 30 элементов.

Массивы в JavaScript могут лишь увеличиваться в размерах, но не могут уменьшаться.

Управление элементами массива

Содержимое массива определяется значениями его элементов. При управлении элементами массива используются те же методы, что и при управлении значениями и переменными. Например, следующий оператор позволяет отобразить значения первых четырех элементов массива scores:

scoredisp = "Статистика: " + scores[0] + "," + scores[1] + "," + scores[2] + "," + scores [3];
document.write(scoredisp);

Использование строковых массивов

Наряду с числовыми массивами, активно используются и строковые массивы. Это позволяет просто и эффективно управлять большими объемами текстовой информации. Объявление строковых массивов проводится тем же способом, что и объявление числовых массивов:

names = new Array(30);
names[0] = "Александр";
names[1] = "Вера";

Элементы строкового массива используются везде, где позволено использовать строковые переменные. Все описанные выше методы выполняются и для элементов строковых массивов. Например, следующий оператор позволяет распечатать первые пять символов значения первого элемента массива names:

document.write(names[0].substring(0,5));

Добавление элементов в массив

Для добавления нового элемента в массив используется метод push(), в скобках нужно указать элемент для добавления.

var cats = ["Барсик", "Мурзик", "Рыжик"];
cats.push("Васька");
console.log(cats);

При добавлении нового элемента изменяется длина массива. Сам элемент добавляется в конец массива.

Для добавления элемента в начало массива используйте метод unshift().

cats.unshift("Пушок");

Здесь также автоматически изменится длина массива и поменяются индексы у элементов, которые там были.

Удаление элементов массива

Удалить последний элемент массива можно через метод pop(), который возвращает удаляемый элемент. Соответственно, уменьшается и длина массива.

var deleted = cats.pop();
console.log(deleted);

Первый элемент можно удалить через метод shift(), который также возвращает значение удаляемого элемента.

deleted = cats.shift();
console.log(deleted);

Объединение массивов

Объединить один массив с другим можно через функцию concat(), указав в качестве параметра второй массив. Элементы второго массива окажутся после элементов первого массива. При этом образуется третий общий массив.

firstArray.concat(secondArray)

Попробуем.

var cats = ["Барсик", "Мурзик", "Рыжик"];
var dogs = ["Бобик", "Шарик", "Тузик"];
var pets = cats.concat(dogs);
console.log(pets);

Сами массивы остаются прежними и не меняются.

Можно объединять несколько массивов, перечисляя их через запятую.

firstArray.concat(secondArray, thirdArray, fourthArray)

Поиск индекса по элементу

Чтобы узнать индекс элемента в массиве (его порядковый номер), используйте функцию indexOf().

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.indexOf("Мурзик")); // вернет 1

По сути метод работает наоборот. По индексу мы можем узнать значение элемента, а по элементу его индекс.

var cats = ["Барсик", "Мурзик", "Рыжик"];
var index = cats.indexOf("Мурзик");
console.log(cats[index]); // вернет Мурзик

Если элемента по запрашиваемому индексу нет, то возвращается -1.

Если элемент в массиве встречается несколько раз, то возвращается первый найденный.

Превращаем массив в строку

С помощью функции join() можно преобразовать массив в строку.

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.join());
// возвращает Барсик,Мурзик,Рыжик

Как видите, элементы массива перечисляются через запятую и без пробелов и кавычек.

Если вас не устраивают запятые, то в параметре функции вы можете указать свой разделитель.

var cats = ["Барсик", "Мурзик", "Рыжик"];
console.log(cats.join("#"));
// Барсик#Мурзик#Рыжик

Если в массиве находятся нестроковые значения, то JavaScript автоматически сделает их строками.

Реклама