Преподаватель который помогает студентам и школьникам в учёбе.

Особенности и примеры использования массивов при разработке программ.

Содержание:

Введение

Такой тип данных как массивы был создан на заре компьютерной эры. Тип данных массив – это один из важнейших типов данных. Они используются в большинстве языков программирования и множеством программ. Сложно найти такую программу, где бы они не использовались: сложнейшие операционные системы и офисные пакеты, архиваторы, кодеки и т.п. Даже самый простой калькулятор без них реализовать было бы на порядок сложнее.

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

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

Тема массивов не потеряет свою актуальность еще очень и очень долго.

Определение массива и его виды

Любое исследование природы какого-либо предмета стоит начать с его определения. Давайте определимся с тем, что мы будем называть в дальнейшем массивом. В популярной интернет энциклопедии Википедия под массивом понимают структуру данных, хранящую набор значений (элементов массива), идентифицируемых по индексу или набору индексов, принимающих целые (или приводимые к целым) значения из некоторого заданного непрерывного диапазона. Нам кажется, что этому определению требуется дополнительная расшифровка. Здесь говорится об элементах массива иными словами о значениях массива. А также об индексах – порядковых номерах этих значений. Стало быть массив – это совокупность данных любых типов и индексов. Иными словами:

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

Какими же бывают типы данных, которые можно использовать в массивах? Ответ достаточно прост – любыми. Это и текст, и целые числа, и вещественные числа, и другие массивы. Кстати, массивы, содержащие в себе другие массивы, называются многомерными массивами.

Разговор о многомерных массивах плавно подводит нас к еще одному определению – размерности массива. Размерность массива – это количество индексов, необходимое для однозначной адресации элемента в рамках массива. По количеству используемых индексов массивы делятся на одномерные, двумерные, трёхмерные и т. д. Иными словами массивы делятся на одномерные и многомерные.

Как опять же подсказывает нам любимая студентами Вики Особенностью массива как структуры данных (в отличие, например, от связного списка) является константная вычислительная сложность доступа к элементу массива по индексу. Массив относится к структурам данных с произвольным доступом. Это означает, что какой бы длины, размерности и различий в типах элементов массива не было бы, доступ к каждому элементу массива осуществлялся бы в строго определенное и равное время. Одно и тоже время займет обращение к первому и сто первому элементу массива.

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

В простейшем случае массив имеет фиксированную длину по всем размерностям и может хранить данные только одного, заданного при описании, типа. Ряд языков поддерживает также динамические массивы, длина которых может изменяться по ходу работы программы, и гетерогенные массивы, которые могут в разных элементах хранить данные различных типов. Так же все языки программирования, поддерживающие массивы, могут позволить инициализировать пустой массив. Массив, который не содержит ни одного индекса и элемента массива. Такая конструкция может пригодиться для создания динамического массива.

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

В языках программирования, допускающих объявления программистом собственных типов, как правило, существует возможность создания типа «массив». В определении такого типа задаются типы и/или диапазоны значений каждого из индексов и тип элементов массива. Объявленный тип в дальнейшем может использоваться для определения переменных, формальных параметров и возвращаемых значений функций. Некоторые языки поддерживают для переменных-массивов операции присваивания (когда одной операцией всем элементам массива присваиваются значения соответствующих элементов другого массива).

Работа с массивами

Прежде чем иметь возможность работать с массивом его нужно инициализировать. Здесь есть два пути. Первый, когда мы знаем, сколько элементов массива у нас будет. Этот способ очень часто используется на уроках по информатике. И второй, когда мы не знаем длину массива. Это происходит гораздо чаще. В первом случаем инициализация происходит путем сопоставления элементов массива его индексам. Чуть позже мы разберем, как это происходит, на примерах в разных языках программирования. Во втором случае инициализируется пустой массив с индексами, которые будут проставляться автоматически, начиная с нуля. А элементы массива будут заноситься в массив из другой структуры.

Для того чтобы работать с элементом массива, к нему надо обратиться из программы. Массивы - это такие же числа или слова, как и любые другие. Для того чтобы работать с элементом массива, надо ввести: название массива[0]. Это позволит выбрать первый элемент массива и проводить с ним операции. Например:

Код ====================================================

print (Arr[0]) – данный фрагмент кода выведет первый элемент массива

Стоит отметить, что если мы собираемся проводить математические операции с массивами, то следует обратить внимание на тип. Это можно сделать, только если у нас имеется массив чисел: целых или с плавающей точкой.

Здесь мы бы хотели подробнее поговорить об индексах. Как правило, в качестве индекса выступают целые числа. Но это не обязательно. В качестве индекса могут также выступить и буквы или целые слова. Вообще в качестве индекса не могут выступать только специально зарезервированные слова (у каждого языка они свои), специальные символы, также не рекомендуется использовать пробел. Массив, в котором у индекса текстовое значение, называется ассоциативным.

Операции с массивами

Типичными операциями при работе с массивами являются:

– вывод данных из массива;

– ввод данных в массив;

– поиск максимального или минимального элемента массива;

– поиск заданного элемента массива;

– сортировка массива.

– объединение массивов.

– математические операции с массивами.

– генерация массивов.

Вывод данных из массива. Под выводом массива понимается вывод на экран монитора (в диалоговое окно) значений элементов массива. Если в программе необходимо вывести значения всех элементов массива, то для этого удобно использовать циклы. К примеру foreach.

Ввод данных в массив. Под вводом массива понимается процесс получения от пользователя (или из файла) во время работы программы значений элементов массива.

Поиск максимального или минимального элемента массива.

Задачу поиска минимального элемента массива рассмотрим на примере массива целых чисел. Алгоритм поиска минимального (максимального) элемента массива довольно очевиден: сначала делается предположение, что первый элемент массива является минимальным (максимальным), затем остальные элементы массива последовательно сравниваются с этим элементом. Если во время очередной проверки обнаруживается, что проверяемый элемент меньше (больше) принятого за минимальный (максимальный), то этот элемент становится минимальным (максимальным) и продолжается проверка оставшихся элементов.

Поиск в массиве заданного элемента. При решении многих задач возникает необходимость определить, содержит ли массив определенную информацию или нет. Задачи такого типа называются поиском в массиве. Для организации поиска в массиве могут быть использованы различные алгоритмы. Наиболее простой — это алгоритм простого перебора. Поиск осуществляется последовательным сравнением элементов массива с образцом до тех пор, пока не будет найден элемент, равный образцу, или не будут проверены все элементы. Алгоритм простого перебора применяется, если элементы массива не упорядочены.

Сортировка массива. Под сортировкой массива подразумевается процесс перестановки элементов массива, целью которого является размещение элементов массива в определенном порядке.

а[3] – обращение к элементу одномерного массива.

b[1,7] – обращение к элементу двумерного массива.

Обращение к элементам массива осуществляется указанием идентификаторов массива и в квадратных скобках номеров элемента через запятую.

Объединение массивов. Позволяет объединить разные элементы двух и более массивов. При этом повторяющихся данных не будет.

Математические операции с массивами. Элементы нескольких массивов можно сложить или перемножить.

История появления массивов

Массивы появились с первым языком программирования низкого уровня – Assembler. Это произошло в 1949 г. благодаря стараниям М.Уилкса. Этот ученый из Кембриджского университета перевел машинные коды в удобоваримый для человека вид. Также он перевел в понятный для программистов вид и типы данных, включая массивы.

Давайте посмотрим, как выглядят массивы на языке Assembler.

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

1) Перечислением элементов массива в поле операндов одной из директив описания данных. При перечислении элементы разделяются запятыми. К примеру: массив из 5 элементов. Размер каждого элемента 4 байта:

mas dd 1,2,3,4,5

2) Используя оператор повторения dup. К примеру: массив из 5 нулевых элементов. Размер каждого элемента 2 байта:

mas dw 5 dup (0)

3) Используя директивы label и rept. Пара этих директив может облегчить описание больших массивов в памяти и повысить наглядность такого описания. Директива rept относится к макросредствам языка ассемблера и вызывает повторение указанное число раз строк, заключенных между директивой и строкой endm. К примеру, определим массив байт в области памяти, обозначенной идентификатором mas_b. В данном случае директива label определяет символическое имя mas_b, аналогично тому, как это делают директивы резервирования и инициализации памяти. Достоинство директивы label в том, что она не резервирует память, а лишь определяет характеристики объекта. В данном случае объект — это ячейка памяти. Используя несколько директив label, записанных одна за другой, можно присвоить одной и той же области памяти разные имена и разный тип, что и сделано в следующем фрагменте:

n=0

mas_b label byte

mas_w label word

rept 4

dw 0f1f0h

endm

Работа с массивами в PHP

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

$keys = ['sky', 'grass', 'orange']; - здесь мы инициализируем массив из строк. Здесь $keys – это название массива, 'sky', 'grass', 'orange' – это элементы массива.

$arr = array(); - здесь мы проинициализировали пустой или как его еще называют безразмерный массив.

$arr1 = array(5 => 1, 12 => 2); - здесь мы использовали индексы. У элемента (еще говорят значения) 1 индекс (или ключ) будет равен 5. А у элемента 2 индекс будет равен 12.

Пример ассоциативного массива:

$array = array(
     "Пупкин" => "Василий",
     "Рост" => "180",
     “Вес”   => 80,
     -100  => 100,

50 => 60,
);

Пример вложенного массива:

$array2 = array(
     "Пупкин" => "Василий",
     "Рост" => "180",
     “Вес”   => 80,
     -100  => 100,

50 => 60,

"drugiVasi" => array(
"good" => array(
"Petrov" => "Petya"

"Ivanov" => "Ivan"
)

"sogood" => array(
"Sidorov" => "Sidor"

"Maria" => "Ivan"
)
);

$numbers = [20, -3, 50, -99, 55]; - пример числового массива

print_r ($numbers[1]); - обращаемся ко второму элементу массива

Полезные функции в PHP для работы с массивами

Одной из первых таких функций является array_combine(), которая создаёт новый массив из двух существующих: первый использует для создания ключей, второй в качестве значений:

$keys = ['sky', 'grass', 'orange']; - здесь мы инициализируем 1 массив

$values = ['blue', 'green', 'orange']; - здесь мы инициализируем 2 массив

$array = array_combine($keys, $values); - создаем 3 массив на основании первых двух

print_r($array); - выводим результат

В результате мы получили ассоциативный массив

// Array

// (

// [sky] => blue - здесь [sky] – индекс, blue – элемент

// [grass] => green

// [orange] => orange

// )

В этом же разрезе нам могут пригодиться функции array_values(). Она извлекает из ассоциативного массива значения; array_keys() возвращает только ключи заданного массива; array_flip() меняет местами ключи и значения:

print_r(array_keys($array)); // ['sky', 'grass', 'orange']

print_r(array_values($array)); // ['blue', 'green', 'orange']

print_r(array_flip($array));

Перебор значений массива с помощью цикла:

$arrays = [[1, 2], [3, 4], [5, 6]]

foreach ($arrays as list($a, $b)) {

$c = $a + $b;

echo($c . ', '); // 3, 7, 11,

}

С помощью функции array_sum() можно посчитать сумму элементов массива; array_product() перемножит все значения; array_reduce() позволит применить свою собственную формулу:

$numbers = [1, 2, 3, 4, 5];

echo(array_sum($numbers)); // 15

echo(array_product($numbers)); // 120

Генерация массивов. $bind = array_fill(0, 5, '?');

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

unset($arr[5]); - удаляем элемент из массива

unset($arr); - удаляем массив целиком

Функция sort() сортирует элементы массива в возрастающем порядке и присваивает новые ключи элементам массива. Разновидности сортировки в зависимости от префиксной буквы:

asort(), сортировка, сохраняющая отношения между ключами и значениями
ksort(), сортировка по ключам
rsort(), сортировка в прямом/обратном порядке

Работа с массивами в C

При решении задач с большим количеством данных одинакового типа использование переменных с различными именами, не упорядоченных по адресам памяти, затрудняет программирование. В подобных случаях в языке Си используют массивы. С точки зрения языка Си – языка низкого уровня, сильно приближенного к «железу» компьютера

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

Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.

Инициализация массива:

int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; - массив arr содержит 10 элементов, со значениями от 0 до 9

#include <stdio.h>
int main()
{
  int arr[] = { 5, 4, 3, 2, 1, 0, -1 }; - массив arr содержит 7 элементов
  printf("%d %d %d %d %d\n", a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
  getchar();
  return 0;
}

Многомерный массив.

#include <stdio.h>
int main()
{
  int a[2][3] = { 1, 2, 3, 4, 5, 6 };
  printf("%d %d %d\n", a[0][0], a[0][1], a[0][2]);
  printf("%d %d %d\n", a[1][0], a[1][1], a[1][2]);
  getchar();
  return 0;
}

В отличие от рассмотренного выше языка PHP, в C нет такого обилия встроенных функций по работе с массивами. Но по большому счету это не вызывает каких-либо неудобств. Все прекрасно делается с помощью условий и циклов. Массив в C должен иметь константный размер. Это значит, что невозможно, например, запросить у пользователя размер, а потом задать этот размер массиву.

В некоторых случаях можно узнать размер массива с помощью функции sizeof.

#include <conio.h>

#include <stdio.h>

void main() {

int A[57];

//sizeof возвращает размер всего массива в байтах

int size = sizeof(A) / sizeof(int);

printf("Size of array equals to %d", size);

getch();

}

Массивы небезопасны, так как неправильная работа с индексом может приводить к доступу к произвольному участку памяти. Это особенно актуально при работе с такими системами как автомобили или любые другие где работаем с железом. При работе с массивами, необходимо следить за тем, чтобы счётчик не превышал размер массива и не был отрицательным.

Динамические массивы — это массивы, память для хранения которых выделяется в момент выполнения программы. В отличие от них статические массивы удалить нельзя — они существуют в течение всего времени исполнения программы.

Стандартная библиотека языка Си содержит несколько функций для работы с динамической памятью: malloc, free

Работа с массивами в Lua

Чтобы создать массив, достаточно перечислить в фигурных скобках значения его элементов:

arr = {“Вася”, “Петя”, “Федя”};

А вот так инициализируется пустой массив: arr = {};

Еще можно так заполнить массив:

arr [1] = " Вася ";

arr [2] = " Петя ";

arr [3] = " Федя ";

Особенностью языка Lua можно назвать то, что массивы индексируются начиная с 1, а не 0, как в большинстве языков программирования.

arr = {[1]=“Вася”, [2]=“Петя”, [3]=“Федя”}; – это выражение эквивалентно тому, что находится выше.

Оператор получения длины #, применённый к массиву, возвращает его максимальный индекс (или размер): max = #arr

Обращение к элементу массива: print(arr[1]); // Вася

Для получения всех элементов массива, могут использоваться конструкции for, foreach:

for i=1,10 do

arr[i] = nil;

end

Пример двумерного массива:

Arr3 = {{"Вася","Пупкин",},"Петя","Федя"};

Характерной особенностью языка Lua, отличающей его от рассмотренных выше языков, является то, что массивы как таковые используются реже, чем производные от них – таблицы. В отличие от массивов элементы таблицы индексируются переменными. А значением может быть абсолютно любой тип данных Lua, да и вообще всё что угодно.

Работа с массивами в Ruby

В Ruby массивы могут содержать любые типы данных, включая числа, строки и другие объекты Ruby. Пример массива в Ruby по синтаксису ничем не будет отличаться от аналогичного примера в РНР:

arr = [

"Вася",

"Петя",

"Федя",

"Маруся"

] или в одну строку arr = ["Вася", "Петя", "Федя", "Маруся"]

Здесь стоит обратить внимание на особенность языка – после массива не ставится точка с запятой.

arr = [] – пример пустого или безразмерного массива

Записи можно иупростить:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday} – эта запись аналогична следующей:

days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

Следующий пример содержит разные типы данных в массиве, включая другой массив:

arr = [

"Вася",

null,

"Возраст",

30,

[

"пол",

"мужской",

]

3,1415

]

Индексы в Ruby начинаются с 0. Соответственно доступ к элементам массива будет выглядеть следующим образом: print arr[3] // получим 30

Методы, использующиеся при работе с массивами:

Чтобы найти последний элемент в массиве, используется индекс -1.

Чтобы узнать количество элементов в массиве, используется метод length. Пример: arr.length // 6

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

Также Ruby предоставляет методы first и last, которые выводят первый и последний элемент массива без индекса.

При запросе несуществующего индекса программа выдаст nil.
arr [10] выдаст nill, потому что в массиве такого индекса нет. Вообще, любой язык программирования, так или иначе, обрабатывает запрос к несуществующему индексу в массиве. Как правило, все выдают значение nill/null в этой ситуации. Одним из исключений будет являться язык С. Так как это язык низкого уровня, оперирующий с адресами в памяти, программа, написанная на нем вылетит с ошибкой.

Чтобы добавить элемент в конец массива используется метод push.

Добавить элемент в начало массива можно с помощью метода unshift.

Чтобы удалить определенный элемент из массива, используются методы delete или delete_at. Метод pop() удаляет последний элемент в массиве.

При работе с массивами также особое значение занимают циклы. Прохождение по массиву без этих конструкций превратилось бы в очень трудоемкий и тупой процесс.

Работа с массивами в Haskell

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

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

Список — это стандартный тип, характеризующий уже не просто данные, но структуру данных. Эта структура представляет собой набор данных одного типа. Одного типа – это надо запомнить. Это главное отличие от массивов, где типы могут быть разные.

Вот пример списка: [1.3, 45.7899] – очень похоже на LUA, не правда ли?

В стандартной Haskell-библиотеке существует отдельный модуль Data.List, включающий широкий набор функций, работающих со списком. Откроем модуль Main и импортируем в него модуль Data.List:

module Main where

import Data.List

main :: IO ()

main = putStrLn (head ["Вася", "Петя", "Федя"])

// head возвращает первый элемент списка т.е. «Вася».

main = print (tail ["Вася", "Петя", "Федя"])

// tail возвращает остальные элементы списка.

Список целых чисел от 1 до 1000

main :: IO ()

main = print tenNumbers

where tenNumbers = [1..1000]

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

['a'..'z'] = "abcdefghijklmnopqrstuvwxyz" – алфавит

Кортеж — ещё одна стандартная структура данных, но, в отличие от списка, она может содержать данные как одного типа, так и разных. Эта структура

Структуры, способные содержать данные разных типов, называют гетерогенными (в переводе с греческого: «разного рода»).

("Миша", "2019", "Курсач", "4" )

Со списками можно делать много всего, а вот с кортежами — не очень. Самые частые действия — собственно формирование кортежа и извлечение хранящихся в нём данных.

Работа с массивами в Go

Массив в языке Go — это нумерованная последовательность элементов одного типа, с фиксированной длинной.

package main

import "fmt"

func main() {

var arr [5]int

fmt.Println("emp:", arr)

В этом примере мы создали массив arr, который будет содержать именно 5 элементов типа int. Тип данных и размер массива - обязательны при объявлении массива. По-умолчанию массив имеет нулевые значения элементов. Для int это 0.

a[4] = 100

fmt.Println("set:", a) - устанавливаем значение элемента в массиве

fmt.Println("get:", a[4]) - получаем значение элемента массива

fmt.Println("len:", len(a)) -Встроенная функция len возвращает размер массива

b := [5]int{1, 2, 3, 4, 5} – инициализируем массив одной строкой

fmt.Println("dcl:", b)

var twoD [2][3]int - создаем многомерный массив

for i := 0; i < 2; i++ {

for j := 0; j < 3; j++ {

twoD[i][j] = i + j

}

fmt.Println("2d: ", twoD)

}

Работа с массивами в Rust

В языке программирования Rust, так же как и в языке Go, массивы представлены набором объектов одного типа с фиксированной длинной. Массивы создаются с помощью квадратных скобок [].

let arr = [1, 2, 3]; - инициализируем массив

for arr in &arr {

println!("Массив: {}", arr);

} - вывод элементов массива

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

Кортеж похож на массив, только может хранить значения разных типов. Элементы кортежа указываются между круглыми скобками ().

let tuple2 = (2, "Вася"); - создание кортежа

println!("Число: {}", tuple2.0);

println!("Строка: {}", tuple2.1);

} – вывод элементов кортежа

let ones = [1; 20]; - создаем 20 единичек

Работа с массивами в Java

Как и во многих других языках в Java массивы – это именованное множество переменных одного типа. Чтобы сослаться на определённый элемент в массиве нужно знать имя массива в соединении с целым значением, называемым индексом. Индекс указывает на позицию конкретного элемента относительно начала массива. Обратите внимание, что первый элемент будет иметь индекс 0, второй имеет индекс 1, третий - индекс 2 и так далее.

int[] hzchto; - создаем пустой массив

int[] hzchto = new int[10]; - массив будет иметь 10 чисел

Если массив создаётся таким образом, то всем элементам массива автоматически присваиваются значения по умолчанию. Например, для числовых значений начальное значение будет 0. Для массива типа boolean начальное значение будет равно false, для массива типа char - '\u0000', для массива типа класса (объекты) - null.

int[3] hzchto – доступ к 4 элементу массива

int[] hzchto = {2, 5, 7, -5, 3, 0}; - инициализация массива с заранее заданными значениями

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

String[] myFriends = {

"Вася",

"Петя",

"Федя",

"Русланчегг",

"Вовчегг",

};

Перебор значений в массиве осуществляется с помощью циклов

int myNum[] = { -100, 0, 1, 2, 3, 100};

for (int num : myNum) {

String strToPrint = num;

}

Многомерные массивы:

int[][] a = {

{ 1, 2, 3 },

{ 4, 5, 6 }

}

int[][][] b = new int[2][4][4]; - трехмерный массив

String[][] arr = new String[4][3]; - двумерный массив

arr[0][0] = "1";

arr[0][1] = "Вася";

arr[0][2] = "Рога";

arr[1][0] = "2";

arr[1][1] = "Петя";

arr[1][2] = "и";

arr[2][0] = "3";

arr[2][1] = "Федя";

arr[2][2] = "Копыта";

Работа с массивами в Python

Перед тем как добавить (создать) новый массив в Python 3, необходимо произвести импорт библиотеки, отвечающей за работу с таким объектом. Для этого потребуется добавить строку from array import * в файл программы. Массивы в Python, как и во многих других языках, ориентированы на взаимодействие с одним постоянным типом данных, вследствие чего все их ячейки имеют одинаковый размер. Воспользовавшись функцией array, можно создать новый набор данных. В следующем примере демонстрируется заполнение массива Python — запись целых чисел при помощи метода, предложенного выше.

from array import *

data = array('i', [2, 5, 4, 0, 8])

Как можно заметить, функция array принимает два аргумента, первым из которых становится тип создаваемого массива, а на месте второго стоит начальный список его значений. В данном случае i представляет собой целое знаковое число, занимающее 2 байта памяти.

Чтобы добавить новый элемент в массив Python необходимо воспользоваться методом insert. Для этого потребуется вызвать его через созданный ранее объект и ввести в качестве аргументов два значения. Первое (4) отвечает за индекс нового элемента в массиве, то есть место, куда его следует поместить, а второе (3) представляет собой само значение.

from array import *

data = array('i', [2, 5, 4, 0, 8])

data.insert(4, 3)

В Python удалить ненужные элементы из массива можно при помощи метода pop, аргументом которого является индекс ячейки (3). Как и в случае с добавлением нового элемента, метод необходимо вызвать через ранее созданный объект, как это показано в примере.

from array import *

data = array('i', [2, 5, 4, 0, 8])

data.pop(3)

Функция len служит для получения длины (размера) массива в Python в виде целочисленного значения. Чтобы отобразить в Python количество элементов массива на экране стоит воспользоваться методом print.

from array import *

data = array('i', [2, 5, 4, 0, 8])

print(len(data))

В некоторых случаях для правильного представления определенного набора информации обычного одномерного массива оказывается недостаточно. В языке программирования Python 3 двумерных и многомерных массивов не существует, однако базовые возможности этой платформы легко позволяют построить двумерный список.

Как и в случае с двумерным массивом, представленным в виде сложного списка, многомерный массив реализуется по принципу «списков внутри списка».

d1 = []

for k in range(5):

d2 = []

for j in range(5):

d3 = []

for i in range(5):

d3.append(0)

d2.append(d3)

d1.append(d3)

Для взаимодействия с наборами данных одного типа в языке программирования Python, как правило, используются массивы

Применение массивов в алгоритмах

Рассматривать в полном объеме такую обширную тему как алгоритмы в данной курсовой не представляется возможным. К тому же на разных языках одни и те же алгоритмы реализованы по разному. Стало быть надо остановить свой выбор на одном языке и выбрать несколько наиболее показательных алгоритмов. Мы остановим свой выбор на Python, в силу его простоты и лаконичности, массового распространения и интереса к нему со стороны сообщества программистов.

1. Двоичный поиск значения в списке (или массиве) используется для упорядоченных последовательностей (отсортированных по возрастанию или убыванию). Заключается такой поиск в определении, содержит ли массив определенное значение, а также определение места его нахождения.
li = [0,3,5,7,10,20,28,30,45,56] # исходный список

x = 28 # искомое значение

i = 1 # первый элемент

j = len(li) # последний элемент

m = int((i + j) / 2) # середина (приблизительно)

while li[m]!=x or i>j:

m = int((i + j) / 2) # найти новую середину

if x > li[m]: # если значение больше серединного

i = m + 1 # то сместить левую границу за середину

else:

j = m - 1 # переместить правую границу до середины

if i > j:

print ("Элемент не найден")

else:

print (m) # вывести индекс искомого элемента

2. Сортировка выбором

s = [2,4,1,3] # массив элементов

m = 0 #индекс первого элемента

i = 1 #индекс второго элемента

while i < len(s): #пока индекс меньше длины строки

if s[i] < s[m]: # если значение под индексом i меньше, чем под m,

m = i # то присвоить m индекс i

i += 1 # увеличить i на единицу

print (s[m]) # вывести значение элемента под индексом m

3. Сортировка пузырьком

li = [5,2,7,4,0,9,8,6]

n = 1

while n < len(li):

for i in range(len(li)-n):

if li[i] > li[i+1]:

li[i],li[i+1] = li[i+1],li[i]

n += 1

Заключение

В данной курсовой работе были рассмотрены массивы. Мы рассмотрели виды массивов, для чего они создавались и когда были созданы. Также мы рассмотрели реализацию массивов в разных языках программирования. Показали, что в разных языках понятие массива различается. Они обладают разными свойствами и методами. Мы рассмотрели использование массивов в реальных алгоритмах, например сортировки.

В компьютерном мире сейчас насчитывается более 9000 языков программирования. Поэтому, даже если бы мы сильно захотели, описать концепцию массивов в каждом из них, то это было бы очень долго и нецелесообразно. Также мы не рассматривали языки, где массивы не предусмотрены априори, такие как HTML, SQL

Массивы – один из важнейших типов данных. Они продолжают развиваться. В некоторых языках таких, например, как Python и Rust, есть несколько видов массивов, называющихся по разному: массив, список, кортеж. Массивы были созданы на заре компьютерной эры и они не утратили своего значения и по сей день. И языки программирования, которые только будут входить в обиход, будут продолжать использовать массивы в том или ином виде.

Список используемой литературы

www.wkipedia.ru
https://habr.com/ru/
Т.А. Жданова Ю.С. Бузыкова ОСНОВЫ АЛГОРИТМИЗАЦИИ И ПРОГРАММИРОВАНИЯ
Белов П.М. Основы алгоритмизации в информационных системах
Белов П.М. Основы алгоритмизации в информационных системах