Вставка и удаление в массиве
Когда нужно произвести какие-то изменения в массиве, метод JavaScript splice может прийти на помощь. Он позволяет осуществлять вставку, удаление и замену элементов в массиве JavaScript .
Рассмотрим аргументы, передаваемые в метод splice() .
Array.splice (start_index, number_of_elements_to_remove) :
- start_index — индекс в массиве, с которого начинается вставка или удаление элементов;
- number_of_elements_to_remove — задает количество элементов, которое необходимо удалить, начиная со star_index .
Все элементы, следующие за number_of_elements_to_remove , будут вставлены в массив, начиная с start_index . Они могут быть любого типа, включая строки, числа, булевы значения, объекты, функции, NULL , undefined , и т.д.
Для более детального изучения параметров метода Array.prototype.splice() Javascript воспользуйтесь MDN .
Давайте начнем с простого примера, демонстрирующего, как вставить число в массив с помощью метода Array.splice() .
Представьте, что у нас есть массив , и мы хотим вставить в него 2 между 1 и 3 . Пример реализации:
var my_array = ; var start_index = 1; var number_of_elements_to_remove = 0; my_array.splice(start_index, number_of_elements_to_remove, 2); console.log(my_array); //;
Обратите внимание, что JavaScript array splice воздействует непосредственно на массив. Таким образом, вызванный my_array метод splace() вместо того, чтобы вернуть новый массив, обновит my_array .
Пример удаления элемента из массива в JavaScript :
var my_array = ["a","b","c","k","d"]; var start_index = 3 var number_of_elements_to_remove = 1; var removed_elements = my_array.splice(start_index, number_of_elements_to_remove); console.log(removed_elements); //["k"] console.log(my_array); //["a","b","c","d"];
Обратите внимание, что в этом примере метод Array.splice() возвращает массив из удаленных элементов.
Взглянем на пример замены элементов в массиве JavaScript с помощью метода splice JavaScript :
var my_array = ["бейсбол", "баскетбол", "теннис", "гольф"]; var start_index = 1 var number_of_elements_to_remove = 2; var removed_elements = my_array.splice(start_index, number_of_elements_to_remove, "бокс", "боулоинг", "волейбол"); console.log(removed_elements); //["теннис", "гольф"] console.log(my_array); //["бейсбол", "бокс", "боулинг", "волейбол", "гольф"];
Приведенный выше пример заменяет «баскетбол » и «теннис » на «бокс «, «боулинг » и «волейбол «. Он может показаться немного запутанным из-за всех проведенных операций. Разберем все операции шаг за шагом. Для начала мы сообщаем методу splace() начальную позицию my_array . Затем number_of_elements_to_remove задаем 2, поэтому метод удаляет my_array и my_array . И, наконец, начиная со start_index my_array , вставляем в массив my_array элементы.
Метод JavaScript splace хорош, когда нужно вставить или удалить значения из массива t . Если массив уже отсортирован, метод splace() подходит, чтобы явно расположить новые значения в массиве. Он также хорошо работает, когда нужно удалить значения из массива по индексу. Обратите внимание на то, что метод splace() действует непосредственно на массив и возвращает только те значения, которые были удалены или вырезаны из массива.
Перевод статьи “Insert, Remove, and Replace elements with Array.splice() ” был подготовлен дружной командой проекта .
Хорошо Плохо
Вставка и удаление в массиве
Основным достоинством массива является прямой доступ к его элементам: для использования элемента нужно указать только имя массива и индекс (или индексы), которые преобразуются в физический адрес элемента. Скорость доступа не зависит от положения элемента в структуре.
Недостаток связан с операциями вставки и удаления элементов. Допустим, одномерный массив arrTable используется для хранения в своих элементах полезной информации, причем содержат информацию только начальные элементы, число которых равно Count. Эти «занятые» элементы называются активными , активные элементы имеют индексы в диапазоне . Очевидно, LastIndex = Count - 1. Если, например, в массив нужно вставить новую информацию в элемент с индексом ind, то все элементы с индексами, начиная с ind и до конца активной части, потребуется переместить на одну позицию, чтобы освободить место под вставляемый элемент NewElement. Эта операция может быть описана следующим фрагментом:
For i:= LastIndex DownTo indDo
arrTable := arrTable [i];
arrTable := NewElement;
Inc(Count); Inc(LastIndex);
Сдвиг части элементов означает их физическое перемещение в памяти. Логическая схема операции вставки показана на рисунке 5.4
Рисунок 5.4 - Вставка в вектор нового элемента: а - до вставки, б - после вставки
Объем памяти, который будет затронут при вставке нового элемента, зависит от значения n и количества сдвигаемых элементов. Время, требуемое на выполнение вставки, зависит от числа активных элементов в массиве: чем больше это количество, тем больше (в среднем) потребуется времени на сдвиг.
Тот же ход рассуждений справедлив и для операции удаления активного элемента из вектора. В случае удаления элемента с индексом ind, все элементы, начиная с элемента arrTable, должны быть перенесены на одну позицию к началу вектора, чтобы «закрыть» образовавшуюся от удаления элемента «дыру». Логическая схема операции удаления приводится на рисунке 5.5. Программный фрагмент удаления может иметь вид:
For i:= ind + 1 To LastIndexDo
arrTable := arrTable [i];
Dec(Count); Dec(LastIndex);
Таким образом, можно сделать вывод: операции вставки и удаления в массиве выполняются медленнее при увеличении количества элементов.
Другой важный недостаток массива связан с фиксацией его размеров. Если необходимо вставить новый элемент в статический массив, который полностью заполнен активными элементами, то произойдет ошибка времени выполнения. Решением проблемы является использование динамического массива, однако приходится все время контролировать текущее число элементов и применять процедуру SetLength при вставке в полностью заполненный массив.
Урок из серии: “Программирование на языке Паскаль”
Продолжим знакомиться с алгоритмами обработки одномерных массивов
. Сегодня рассмотрим алгоритмы для вставки элементов в массив
. Как и в алгоритмах с удалением элементов, будем различать два случая: вставку одного элемента и вставку нескольких элементов. Алгоритмы получаются разные.
Вставка одного элемента
Вставить элемент можно до или после данного элемента, номер этого элемента можно вводить с клавиатуры или искать при определённых условиях.
Рассмотрим вставку элемента после элемента с данным номером, номер этого элемента будем вводить с клавиатуры.
Рассмотрим несложную задачу.
Пример 1.
В массив, состоящий из n элементов, вставить число b после k-го элемента.
Решение
Рассмотрим на конкретном примере. Пусть дан следующий одномерный массив из 10 (n = 10) элементов:
3, -12, 5, 14, 27, -6, 1, -34, 10, -15.
Вставим число 100 после 5 элемента (b=100, k = 5)
Алгоритм вставки элемента в массив:
- Первые 5 элементов массива остаются без изменений.
- Сдвинуть все элементы, начиная с шестого, на один назад. Но чтобы не потерять соседнее значение, сдвиг будем начинать с последнего элемента – сдвинуть сначала десятый на один вправо, затем девятый, восьмой и т. д. до шестого (m:=m[i], i=n..k).
- На место шестого элемента записываем значение 100, то есть после 5-го элемента массива (m:=b;).
Получим следующий массив:
3, -12, 5, 14, 27, 100, -6, 1, -34, 10, -15.
Таким образом, в массиве стало 11 элементов, то есть массив надо определять на N+1 элемент:
Type myarray = Array Of Integer.
Составим теперь новую процедуру Insert1 (k1, x1, m ), которой передаются: k 1 – номер элемента, после которого надо вставить, х1 – число, которое вставляем, m – массив, в котором делаем преобразования.
Составим основную программу с использованием новой процедуры Insert1 (k1, x1, m).
Мы рассмотрели алгоритм вставки одного элемента в массив. Рассмотрим следующий случай.
Вставка нескольких элементов
Предположим, что необходимо вставлять не один элемент в массив, а по одному элементу после всех элементов с заданным свойством. Рассмотрим следующую задачу.
Пример 2. Вставить число после всех элементов массива, кратных 3.
Первое, на что необходимо обратить внимание – это описание массива: на сколько элементов может увеличиться массив?
Максимальное количество элементов, после которых может быть вставлен новый элемент, совпадает с количеством элементов массива. Так как может случиться, что все элементы массива отвечают заданному свойству. Поэтому массив может увеличиться в два раза (это его самая большая размерность), а значит, соответствующее ему описание будет следующим:
Type myarray = Array Of Integer;
Второе. Если мы будем просматривать элементы массива с начала и вставлять новый после элемента с заданным свойством, то следующим просматриваемым элементом будет новый (вставленный) элемент и его необходимо будет пропускать (“перепрыгивать”). Поэтому решение будет не очень эффективным.
Поэтому лучше всего просматривать массив, начиная с конца, тогда вставляемый элемент мешать не будет. При этом просмотр будет последовательным от N-го до 1-го.
И последнее, на что нужно обратить внимание, это то, что номер последнего элемента после каждой вставки будет меняться. Его нужно будет переопределять. Для этого нужно вести подсчет количества вставленных элементов на данный момент.
Для вставки нескольких элементов в массив составим новую процедуру Insert2
(k1, x1, m
), в которой будет вестись подсчет количества вставленных элементов и корректироваться номер последнего элемента.
Номер последнего элемента необходим для того, чтобы знать, сколько элементов необходимо сдвинуть при освобождении места для нового элемента, так как количество элементов в этой части массива увеличивается.
Ниже представлен текст процедуры с учетом изменений. Параметры у процедуры оставим прежние.
Теперь можно написать программный код основной программы. Он будет следующий:
Вы познакомились с алгоритмами вставки элементов в одномерный массив. На следующем уроке рассмотрим алгоритмы сортировки одномерных массивов.
end; {for i}
Вставка и удаление элемента в массив
Рассмотрим алгоритм вставки элемента в массив. Для простоты будем рассматривать только одномерные массивы. Массив состоит из некоторого количества элементов nmax (емкость
массива). Текущее количество элементов массива находится в переменной n.
Перед вставкой очередного элемента проверяем, что текущее количество элементов массива меньше, чем его емкость.
Далее проверяем, вставляется ли элемент в конец массива или нет. Если элемент вставляется в конец массива, то увеличиваем n на единицу и добавляем элемент. Иначе сдвигаем элементы массива индекс которых больше или равен индексу вставляемого элемента, рисунок 3.
Приведенный алгоритм реализован в программе, приведенной в листинге 6.
Листинг 6 – Вставка элемента в массив
{$MODE DELPHI} {$ENDIF}
{$APPTYPE CONSOLE} program InsElt;
i :integer;
//Ввод массива
//Элемент для вставки writeln("Vvedite element" ); readln(element);
//Индекс элемента
//Вставка элемента
if index < n+1 then begin
inc(n); //увеличиваем длину массива
if (Low(a) <= index) and (index <= n) then for i:=n downto index do
a[i]:=a; //сдвиг массива
a:=element; end
//Вывод элементов массива на экран for i:=1 to n do
writeln("a[" , i,"]=" , a[i]:6:2);
Удаление элемента происходит аналогично. Сначала проверяется, что индекс элемента не выходит за диапазон допустимых значений, а затем сдвигаются элементы таким образом, чтобы закрыть удаляемый элемент, рисунок 4
Листинг 7
{$MODE DELPHI} {$ENDIF}
{$APPTYPE CONSOLE} program DelElt;
const nmax = 5; //емкость массива
i :integer;
writeln("Vvedite chislo elementov massiva"); readln(n);
//Ввод массива
for i:=1 to n do begin write("a[" , i,"]=" ); readln(a[i]);
//Индекс элемента
writeln("Vvedite index elementa"); readln(index);
//Удаление элементов
if index if (Low(a) <= index) and (index <= n) then for i:=index to n do a[i]:=a;
//сдвиг массиваdec(n);
//уменьшаем длину массиваend
else begin writeln("Invalid index"
); readln; X[ 3 ] : =X [ 4 ]; X[ 4 ] : =X [ 5 ]; X[ 5 ] : =X [ 6 ]; Таким образом, все элементы с третьего по
пятый надо переместить влево на один - на место
i
-го элемента нужно записать (i+1)
-й. Блок-схема
алгоритма представлена на рис. 5.25 .
Теперь рассмотрим более общую задачу: необходимо удалить m
-й элемент из массива X
, состоящего из n
элементов. Для этого достаточно записать элемент (m+1)
-й на место
элемента c номером m, (m+2)
-й элемент - на место
(m+1)
-го и т. д., n
-й элемент - на место
(n–1)
-го. Процесс удаления элемента из массива представлен на рис. 5.26 . Алгоритм
удаления из массива Х
размерностью n
элемента с номером m
приведён на рис. 5.27 . После удаления
элемента 4А фактически сдвига части массива на один элемент влево
из массива изменится количество элементов в массиве (уменьшится на один), и у части элементов изменится индекс
. Если элемент удалён, то на место
него приходит следующий, передвигаться к которому (путём увеличения индекса на один) нет необходимости. Следующий элемент сам сдвинулся влево после удаления. Если обрабатывается массив
, в котором часть элементов удаляется, то после удаления элемента не надо переходить к следующему (при этом уменьшается количество элементов). В качестве примера рассмотрим следующую задачу. ЗАДАЧА 5.1. Удалить из массива отрицательные элементы. Алгоритм
решения задачи довольно прост: перебираем все элементы массива, если элемент отрицателен, то удаляем его путём сдвига всех последующих на один влево. Единственное, о чём стоить помнить, - что после удаления элемента не надо переходить к следующему для последующей обработки, он сам сдвигается на место
текущего. Блок-схема
решения задачи 5.1 представлена на рис. 5.28 . Ниже представлен текст программы с комментариями. program upor_massiv;
var i, n, j: byte; X: array [ 1.. 100 ] of real;
begin
writeln (’введите размер массива ’); readln (n);
{Ввод массива.}
for i:=1 to n do
begin
write (’X[ ’, i, ’ ]= ’);
readln (X[ i ]);
end;
writeln (’массив X ’);
for i:=1 to n do write (x [ i ] : 5: 2, ’ ’);
writeln;
i: = 1;
while (i<=n) do
{Если очередной элемент массива X[i] отрицателен, то}
if x [ i ]<0 then
begin
{удаляем элемент массива с номером i.}
for j:= i to n_1 do
x [ j ] : = x [ j + 1 ]; {Уменьшаем размер массива.}
{Не надо переходить к следующему элементу массива.}
n:=n -1;
end
else
{Если элемент не удалялся, то переходим к следующему элементу массива.}
i:= i +1;
writeln (’Изменённый массив ’);
for i:=1 to n do {Вывод преобразованного массива.}
write (X[ i ] : 5: 2, ’ ’); writeln; end. Результаты работы программы представлены на рис. 5.29 . Рассмотрим несложную задачу: вставить число b
в массив
X(10)
, между третьим и четвёртым элементами. Для решения этой задачи необходимо все элементы массива, начиная со четвёртого, сдвинуть вправо на один элемент. Затем в четвёртый элемент массива нужно будет записать b (X:=b;)
. Но чтобы не потерять соседнее значение
, сдвигать на один вправо нужно сначала десятый элемент, затем девятый, восьмой и т. д. до четвёртого. Блок-схема
алгоритма вставки приведена на рис. 5.30 . В общем случае блок-схема
вставки числа b
в массив
X(N)
, между элементами c номерами m
и m+1
представлена на рис. 5.31 . Ниже представлен фрагмент программы, реализующий этот
алгоритм 5При описании массива необходимо предусмотреть достаточный размер для вставки одного элемента.
. var i, n,m: byte;
X: array [ 1.. 100 ] of real;
b: real;
begin
writeln (’N= ’);
readln (n);
for i:=1 to n do
begin
write (’X[ ’, i, ’ ]= ’);
readln (X[ i ]);
end;
writeln (’Массив X ’);
for i:=1 to n do write (x [ i ] : 5: 2, ’ ’);
writeln;
writeln (’m= ’);
readln (m);
writeln (’ b= ’);
readln (b);
for i:=n downto m+1 do
x [ i +1]:=x [ i ];
x :=b;
n:=n+1;
writeln (’Изменённый массив ’);
for i:=1 to n do
write (X[ i ] : 5: 2, ’ ’);
writeln;
end. Рассмотрим, как можно передавать массивы в подпрограмму. Как известно (см. главу 4), чтобы объявить переменные в списке формальных параметров подпрограммы, необходимо указать их имена и типы. Однако типом любого параметра в списке может быть только стандартный или ранее объявленный тип. Поэтому для того, чтобы передать в подпрограмму массив
, необходимо вначале описать его
тип 6Тип данных массива, объявление массива см. в п. 2.4.9. Подробно работа с массивами описана в данной главе.
, а затем объявлять процедуру: тип_массива = array
[ список_индексов ] of
тип; procedure
имя_процедуры(имя_массива: тип_массива); Например: type
vector=array [ 1.. 10 ] of byte;
matrica=array [ 1.. 3, 1.. 3 ] of real;
procedure proc (A: matrica; b: vector; var x: vector); Понятно, что передача в подпрограмму строки вида имя_переменной: string
[ длина_строки ]; которая фактически является
массивом 7Тип данных "строка", объявление строки см. в п. 2.4.9
, должна осуществляться аналогично: тип_строки = string
[ длина_строки ]; procedure
имя_процедуры(имя_строки: тип_ строки); Например: type
stroka_5=string [ 5 ];
stroka_10=string [ 1 0 ];
function fun (S t r: stroka_5) : stroka_10; Массивы в подпрограмму можно передавать, используя понятие открытого массива. Открытый массив
- это
массив 8Тип данных "массив", объявление массива, обращение к массиву см. в п. 2.4.9.
, при описании которого указывается тип элементов, из которых он состоит, но не определяются границы изменения индексов: имя_открытого_массива: array of array of...
тип; Например: var
massiv_1: array of real;
massiv_2: array of array of char;
massiv_3: array of array of array of byte; Распределение памяти
и указание границ индексов
Рис.
5.25.
Рис.
5.26.
Рис.
5.27.
Рис.
5.28.
Рис.
5.29.
5.9 Вставка элемента в массив
Рис.
5.30.
Рис.
5.31.
5.10 Использование подпрограмм для работы с массивами