Программирование / 6 Массивы, оператор foreach
.pdf6. Массивы и строки
Массив представляет собой совокупность переменных одного типа с общим для обращения к ним именем. В C# массивы могут быть как одномерными, так и многомерными, хотя чаще всего применяются одномерные массивы. Массивы служат самым разным целям, поскольку они предоставляют удобные средства для объединения связанных вместе переменных. Например, в массиве можно хранить максимальные суточные температуры, зарегистрированные в течение месяца, перечень биржевых курсов или же названия книг по программированию из домашней библиотеки.
Главное преимущество массива – в организации данных таким образом, чтобы ими было проще манипулировать.
Массивами в C# можно пользоваться практически так же, как и в других языках программирования. Тем не менее, у них имеется одна особенность: они реализованы в виде объектов. Именно поэтому не рассматривали их, пока не были даны базовые понятия классов и их экземпляров. Реализация массивов в виде объектов дает ряд существенных преимуществ, и далеко не самым последним среди них является возможность утилизировать неиспользуемые массивы средствам "сборки мусора".
6.1. Одномерные массивы
Одномерный массив представляет собой список связанных переменных. Такие списки часто применяются в программировании. Например, в одномерном массиве можно хранить учетные номера активных пользователей сети или текущие средние уровни достижений бейсбольной команды.
Для того чтобы воспользоваться массивом в программе, требуется двухэтапная процедура, поскольку в C# массивы реализованы в виде объектов. Во-первых, необходимо объявить переменную, которая может обращаться к массиву. И во-вторых, нужно создать экземпляр массива, используя оператор new. Так, для объявления одномерного массива обычно применяется следующая общая форма:
тип[] имя_массива = new тип[размер] ;
где тип объявляет конкретный тип элемента массива. Тип элемента определяет тип данных каждого элемента, составляющего массив. Обратите внимание на квадратные скобки, которые сопровождают тип. Они указывают на то, что объявляется одномерный массив. А размер определяет число элементов массива.
Если у вас имеется некоторый опыт программирования на C или C++, обратите особое внимание на то, как объявляются массивы в C#. В частности, квадратные скобки следуют после названия типа, а не имени массива.
Обратимся к конкретному примеру. В приведенной ниже строке кода создается массив типа int, который составляется из десяти элементов и связывается с переменной ссылки на массив, именуемой sample.
int[] sample = new int[10];
В переменной sample хранится ссылка на область памяти, выделяемой для массива оператором new. Эта область памяти должна быть достаточно большой, чтобы в ней могли храниться десять элементов массива типа int.
Как и при создании экземпляра класса, приведенное выше объявление массива можно разделить на два отдельных оператора. Например:
int[] sample;
sample = new int[10];
В данном случае переменная sample не ссылается на какой-то определенный физический объект, когда она создается в первом операторе. И лишь после выполнения второго оператора эта переменная ссылается на массив.
Доступ к отдельному элементу массива осуществляется по индексу. Индекс обозначает по-
ложение элемента в массиве. В языке C# индекс первого элемента всех массивов оказывается нулевым. В частности, массив sample состоит из 10 элементов с индексами от 0 до 9. Для индексирования массива достаточно указать номер требуемого элемента в квадратных скобках. Так, первый элемент массива sample обозначается как sample[0], а последний – как sample[9].
6.2. Инициализация одномерного массива
Методы ввода и вывода класса Console не поддерживают ввод и вывод массива целиком, поэтому эти действия приходится выполнять как циклические процессы над отдельными элементами массива, используя (в частности) оператор for.
Существует несколько вариантов инициализации массивов.
Первый вариант – инициализация при объявлении, используется, как правило, для небольших массивов, и заранее ивестных начальных значений. Его форма:
тип[] имя_массива = {vail, val2, val3, ..., valN);
где vai1 - valN обозначают первоначальные значения, которые присваиваются по очереди, слева направо и по порядку индексирования. Для хранения инициализаторов массива в C# автоматически распределяется достаточный объем памяти. А необходимость пользоваться оператором new явным образом отпадает сама собой.
Любопытно, что при инициализации массива можно также воспользоваться оператором new, хотя особой надобности в этом нет. Например, приведенный ниже фрагмент кода считается верным, но избыточным для инициализации массива nums в упомянутой выше программе.
int[] nums = new int[] { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 };
Несмотря на свою избыточность, форма инициализации массива с оператором new оказывается полезной в том случае, если новый массив присваивается уже существующей переменной ссылки на массив. Например:
int[] nums;
nums = new int[] { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 };
В данном случае переменная nums объявляется в первом операторе и инициализируется во втором.
И последнее замечание: при инициализации массива его размер можно указывать явным образом, но этот размер должен совпадать с числом инициализаторов. В качестве примера ниже приведен еще один способ инициализации массива nums.
int[] nums = new int[10] { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 };
В этом объявлении размер массива nums задается равным 10 явно. В качестве примера ниже приведен вариант программы, вычисляющей среднее арифметическое элементов массива.
// Вычислить среднее арифметическое ряда значений. using System;
class Average
{
static void Main()
{
int[] nums = { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 }; int avg = 0;
for (int i = 0; i < 10; i++)
avg = avg + nums[i]; avg = avg / 10; Console.WriteLine("Среднее: " + avg);
}
}
Здесь использована сама краткая форма инициализации (то есть, нет оператора new, и размер массива явно не задается).
Второй вариант инициализации – после объявления. В этом случае используются циклы for – циклически (последовательно) получаем доступ к элементам массива, и задаем их значение. При этом значение можно вводить с клавиатуры, или вычислять. В следующей части программы объявляются, а затем инициализируются 2 одномерных массива.
int[] sample = new int[10]; int[] sample_read = new int[10]; int i;
//Инициализируем массив for (i = 0; i < 10; i++)
sample[i] = i;
//Инициализируем массив вводимыми с клавиатуры значениями for (i = 0; i < 10; i++)
{
Console.WriteLine("sample_read [{0}] = ", i); sample[i] = Convert.ToInt32(Console.ReadLine());
}
Элементы первого массива sample инициалиируются их индексами (значение элемента равно его индексу). В случае второго массива sample_read сначала выводится сообщение о вводе значения очередного элемента, а затем этот элемент инициализируется введенным пользователем значением.
Схематически массив sample можно представить таким образом:
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
sample[0] |
sample[1] |
sample[2] |
sample[3] |
sample[4] |
sample[5] |
sample[6] |
sample[7] |
sample[8] |
sample[9] |
6.3. Вывод элементов одномерного массива на экран
Вывод элементов массива также осуществляется с помощью цикла (в частности for).
Предположим, в вашей программе сделаны объявления:
const int n = 15;
int[] sample = new int[n]; int i;
Тогда первый способ вывода элементов массива в строку будет иметь инструкцию:
Console.WriteLine("Элементы массива sample имеют значения"); for (i = 0; i < n; i++)
Console.Write(sample[i] + " "); Console.WriteLine();
В этой инструкции сначала метод WriteLine() сообщает, какую информацию пользователь увидит на экране. Затем оператор for сформирует цепочку чисел, разделенных пробелами. После чего курсор будет переведен на новую строку.
Второй способ обеспечивает вывод значений элементов массива в столбец, причем каждый из элементов будет идентифицирован:
for (i = 0; i < n; i++)
Console.WriteLine("sample[{0}] = {1}",i,sample[i]);
6.4. Соблюдение границ массива
Границы массива в C# строго соблюдаются. Если границы массива не достигаются или же превышаются, то возникает ошибка при выполнении. Для того чтобы убедиться в этом, попробуйте выполнить приведенную ниже программу, в которой намеренно превышаются границы массива.
// Продемонстрировать превышение границ массива. using System;
class ArrayErr
{
static void Main()
{
int[] sample = new int[10]; int i;
// Воссоздать превышение границ массива. for (i = 0; i < 100; i = i + 1)
sample[i] = i;
}
}
Как только значение переменной i достигает 10, возникнет исключительная ситуация типа IndexOutOfRangeException, связанная с выходом за пределы индексирования массива, и программа преждевременно завершится.
6.5.Многомерные массивы
Впрограммировании чаще всего применяются одномерные массивы, хотя и многомерные не так уж и редки. Многомерным называется такой массив, который отличается двумя или более измерениями, причем доступ к каждому элементу такого массива осуществляется с помощью определенной комбинации двух или более индексов.
6.5.1. Двумерные массивы
Простейшей формой многомерного массива является двумерный массив. Местоположение любого элемента в двумерном массиве обозначается двумя индексами. Такой массив можно представить в виде таблицы, на строки которой указывает один индекс, а на столбцы – другой.
В следующей строке кода объявляется двумерный массив вещественных чисел размером 10x20.
int[,] table = new int[10, 20];
Обратите особое внимание на объявление этого массива. Как видите, оба его размера разделяются запятой. В первой части этого объявления синтаксическое обозначение
[ , ]
означает, что создается переменная ссылки на двумерный массив. Если же память распределяется для массива с помощью оператора new, то используется следующее синтаксическое обозначение.
int[10 , 20]
В данном объявлении создается массив размерами 10x20, но и в этом случае его размеры разделяются запятой.
Для доступа к элементу двумерного массива следует указать оба индекса, разделив их запятой. Например, в следующей строке кода элементу массива table с координатами местоположения (3,5) присваивается значение 10.
table[3, 5] = 10;
6.5.2. Массивы трех и более измерений
В C# допускаются массивы трех и более измерений. Ниже приведена общая форма объявления многомерного массива.
тип[, ... , ] имя_массива = new тип[размер1, размер2, . . . размерN] ;
Например, в приведенном ниже объявлении создается трехмерный целочисленный массив размерами 4x10х3.
int[,,] multidim = new int[4, 10, 3];
А в следующем операторе элементу массива multidim с координатами местоположения (2,4,1) присваивается значение 100.
multidim[2, 4, 1] = 100;
6.6. Инициализация многомерных массивов
Инициализация многомерных массивов аналогична одномерным массивам. Для инициализации многомерного массива достаточно заключить в фигурные скобки список инициализаторов каждого его размера. Ниже в качестве примера приведена общая форма инициализации двумерного массива:
тип[,] имя_массива = { |
|
{val, val, val, |
..., val}, |
{val, val, val, |
..., val}, |
. |
|
. |
|
. |
|
{val, val, val, |
. . ., val} }; |
где val обозначает инициализирующее значение, а каждый внутренний блок – отдельный ряд. Первое значение в каждом ряду сохраняется на первой позиции в массиве, второе значение – на второй позиции и т.д. Обратите внимание на то, что блоки инициализаторов разделяются запятыми, а после завершающей эти блоки закрывающей фигурной скобки ставится точка с запятой.
В качестве примера приведем фрагмент программы, в которой двумерный массив sqrs инициализируется числами от 1 до 5 и квадратами этих чисел.
int[,] sqrs = {{ 1 , 1 },
{2 , 4 },
{3 , 9 },
{4 , 16 },
{5 , 25 } };
Дугой вариант инициализации – использование вложенных циклов for:
const int n = 10; const int m = 5;
int[,] sample = new int[n,m]; int[,] sample_read = new int[n,m]; int i,j;
//Инициализируем массив for (i = 0; i < n; i++)
for (j = 0; i < m; j++) sample[i,j] = i + j;
//Инициализируем массив вводимыми с клавиатуры значениями for (i = 0; i < n; i++)
for (j = 0; i < m; j++)
{Console.WriteLine("sample_read [{0} , {1}] = ", i, j);
sample[i,j] = Convert.ToInt32(Console.ReadLine());
}
Внешний цикл (по i) отвечает за измеение индекса строки, а внутренний (по j) – столбца. Сначала поочередно заполняются элементы первой строки, затем – второй, третьей и тд.
Элементы первого массива sample инициалиируются их индексами (значение элемента равно его индексу). В случае второго массива sample_read сначала выводится сообщение о вводе значения очередного элемента, а затем этот элемент инициализируется введенным пользователем значением.
6.7. Вывод элементов марицы (двумерного массива) на экран
Вывод элементов массива также осуществляется с помощью цикла (в частности for).
Предположим, в вашей программе сделаны объявления:
const int n = 15; const int m = 10;
int[,] sample = new int[n,m]; int i,j;
Тогда первый способ вывода элементов массива в виде матрицы будет иметь инструкцию:
Console.WriteLine("Элементы массива sample имеют значения"); for (i = 0; i < n; i++)
{
for (j = 0; i < m; j++) Console.Write(sample[i,j] + " ");
Console.WriteLine();
}
В этой инструкции сначала метод WriteLine() сообщает, какую информацию пользователь увидит на экране. Затем внутренний оператор for сформирует цепочку чисел, разделенных пробелами. После чего курсор будет переведен на новую строку и будет сформирована следующая цепочка чисел. И так далее, пока не будет выведен весь массив.
Второй способ обеспечивает вывод значений элементов массива в столбец, причем каждый из элементов будет идентифицирован:
for (i = 0; i < n; i++)
for (j = 0; i < m; j++)
Console.WriteLine("sample[{0}, {1}] = {2}",i,j,sample[i,j]);
Ниже приведен более наглядный пример в виде небольшой программы, в которой двумерный массив сначала заполняется числами от 1 до 12, а затем выводится его содержимое.
// Продемонстрировать двумерный массив. using System;
class TwoD
{
static void Main()
{
int i, j;
int[,] table = new int[3, 4]; for (i = 0; i < 3; ++i)
{
for (j = 0; j < 4; ++j)
{
table[i, j] = (i * 4) + j + 1; Console.Write(table[i, j] + "\t");
}
Console.WriteLine();
}
Console.ReadLine();
}
}
В данном примере элемент массива table[0, 0] будет иметь значение 1, элемент массива table[ 0 , 1] – значение 2, элемент массива table[ 0 , 2] – значение 3 и т.д. А значение элемента массива table[ 2 , 3] окажется равным 12. На следующем рисунке схематически показано расположение элементов этого массива и их значений.
|
0 |
1 |
2 |
3 |
правый индекс |
0 |
1 |
2 |
3 |
4 |
(индекс столбца) |
|
|||||
|
|
|
|
|
|
1 |
5 |
6 |
7 |
8 |
|
|
|
|
|
|
|
2 |
9 |
10 |
11 |
12 |
|
|
|
|
|
|
|
левый индекс (ин- |
table[1][2] |
декс строки) |
|
Если вам приходилось раньше программировать на C, C++ или Java, то будьте особенно внимательны, объявляя или организуя доступ к многомерным массивам в C#. В этих языках программирования размеры массива и индексы указываются в отдельных квадратных скобках, тогда как в C# они разделяются запятой.
6.8. Примеры решения задач с использованием массивов
Пример 22. В результате измерения случайного параметра сформирован массив из N вещественных чисел.
|
1 |
N |
|
Вычислить эмпирическую среднюю X |
Xi и среднее квадратиче- |
||
|
|||
|
N i 1 |
||
Начало
Ввод массива x[n]
average=0; st_deviation=0;
A i=1; i>n
ское отклонение
N
( Xi X )2
|
i 1 |
|
, N 10. |
|
|
||
|
|
N 1 |
|
Обозначим average = X и st_deviation = σ, алгоритм программы изображен на рисунке справа.
using System; class ThreeDMatrix
{
static void Main()
{
const int n = 20;
double[] x = new double[n]; double average, st_deviation; average = st_deviation = 0;
Console.WriteLine("Введите массив x, из {0} вещественных чисел", n); for (int i = 0; i < n; i++)
x[i] = Convert.ToDouble(Console.ReadLine()); for (int i = 0; i < n; i++)
average += x[i]; average /= n;
for (int i = 0; i < n; i++)
st_deviation+= (x[i]-average)*(x[i] - average); st_deviation = Math.Sqrt(st_deviation / (n - 1));
Console.WriteLine("average={0:#.###}\nstandart deviation={1:#.###}", average, st_deviation);
Console.ReadLine();
}
}
average+= x[i]
A i++
average /= n;
B i=1; i>n
st_deviation+= (x[i]-average)* (x[i]-average);
B i++
st_deviation=
Math.sqrt( aver- age/(n-1));
Вывод average, st_deviation
Конец
Существует класс задач, в которых индекс массива используется для формализации вычислительного процесса путем сведения исходных формул к конечным суммам и произведениям. Преобразованные таким образом формулы программируются с помощью арифметических циклов. При обращении к элементам массива в качестве индексов можно использовать выражения перечисляемого типа.
Пример 23. Дана последовательность вещественных чисел X1, Х2, X3,..., Х24. Требуется вы-
числить U = X1 • Х2 • Х3 • X4 + X5 • Х6 • Х7 • Х8 + ... + Х21 • Х22 • X23 • Х24
Для программирования необходимо линейную формулу U преобразовать к следующему ви-
ду:
6 4
U X 4(i 1) j i 1 j 1
Нетрудно заметить, что задача сведена к двойному арифметическому циклу.
Для накопления суммы по i используется переменная summ_i, исходное состояние которой равно 0. Для накопления произведения используется рабочая переменная product_j, которая рассчитывается шесть раз для значений индекса i=1,2,…,6. Для накопления произведения начальное значение j принимается равным 1. Кроме того, не следует забывать, что в C# нумерация массивов начинается с 0.
using System; class Example23;
{
static void Main()
{
const int n = 24;
double[] x = new double[n]; double summ_i, product_j; summ_i = 0;
product_j = 1;
Console.WriteLine("Введите массив x, из {0} вещественных чисел", n); for (int i = 0; i < n; i++)
x[i] = Convert.ToDouble(Console.ReadLine()); summ_i=0;
for (int i = 1; i < 7; i++)
{
product_j=1;
for (int j =0; j<4; j++) product_j*=x[4*(i-1)+j];
summ_i+=product_j;
}
Console.WriteLine("U = {0:#.###}",summ_i); Console.ReadLine();
}
}
Пример 24. Найти сумму двух матриц С = А + В размерностью m х n. Элементы Сi,j искомой
матрицы C вычисляются по формулам: Сi,j=Аi,j+Bi,j; i = 1...m; j = 1...n. Размерность вводится с клавиатуры.
using System; class Example24
{
static void Main()
{
int n,m;
Console.WriteLine("Введите размерность матриц n и m"); n = Convert.ToInt32(Console.ReadLine());
m = Convert.ToInt32(Console.ReadLine()); double[,] A = new double[n,m]; double[,] B = new double[n,m]; double[,] C = new double[n,m]; Console.WriteLine("Введите матрицу A");
for (int i = |
0; i < n; i++) |
for (int |
j = 0; j < m; j++) |
A[i, |
j] = Convert.ToDouble(Console.ReadLine()); |
Console.WriteLine("Введите матрицу B"); |
|
for (int i = |
0; i < n; i++) |
for (int |
j = 0; j < m; j++) |
B[i, |
j] = Convert.ToDouble(Console.ReadLine()); |
for (int i = |
0; i < n; i++) |
{ |
|
for (int |
j = 0; j < m; j++) |
{ |
|
C[i, j] = A[i, j] + B[i, j]; Console.Write(C[i, j]+"\t");
}
Console.WriteLine();
}
Console.ReadLine();
}
}
Пример 25. Найти сумму элементов главной диагонали 3-х мерного массива nxnxn.
// Суммировать значения по одной из диагоналей матрицы n x n x n. using System;
class Example25
{
static void Main()
{
const int n = 5;
int[, ,] cube = new int[n, n, n]; int sum = 0;
int count = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) cube[i, j, k] = count++;
for (int z = 0; z < n; z++) sum += cube[z, z, z];
Console.WriteLine("Сумма значений по первой диагонали: " + sum); Console.ReadLine();
}
}
6.9. Нахождение минимального и максимального элементов массива
Одной из наиболее распространенных задач обработки массивов является поиск минимального (максимального) элемента.
Пример 26. В массиве из 20 вещественных чисел поменять местами наибольшие и наименьшие элементы.
Уточним пространство решений. В исходном массиве x может присутствовать несколько максимальных и минимальных элементов. Возможен неординарный случай для этой задачи, который состоит в том, что все элементы массива равны между собой. Переменные, используемые в программе, и их тип описаны в следующей таблице:
Идентификатор |
Содержательный смысл |
Тип |
x[i] |
Элемент с индексом i массива x |
double |
min_x |
Значение наименьшего элемента из x |
double |
max_x |
Значение наибольшего элемента из x |
double |
Эту задачу нужно решать с помощью двух последовательных просмотров массива x. Целью первого просмотра является вычисление наибольшего max_x и наименьшего min_x значений элементов массива x. В начале просмотра значение первого элемента x[1] считается одновременно наибольшим и наименьшим, что справедливо в том случае, если в массиве всего один элемент.
Далее со второго элемента x[2] и до последнего x[20] сравниваются значение текущего элемента с min_x. Если значение текущего элемента меньше, то оно с этого момента считается минимальным. По окончании цикла в рабочей ячейке min_x окажется число, равное значению наименьшего элемента. Аналогично поступаем для нахождения max_x.
Далее нужно сравнить между собой min_x и max_x. Если эти величины равны между собой, то массив состоит из 20 равнозначных элементов. Следовательно, переставлять их местами нет необходимости. Если min_x≠max_x, то нужно наименьшим элементам присвоить значение max_x, а наибольшим элементам присвоить значение min_x. Эти действия являются основой для второго просмотра массива x.
using System; class FindMinMax
{
static void Main()
{
const int n =20;
double[] x = new double[n]; double min_x, max_x;
Console.WriteLine("Введите массив x
из 20 вещественных чисел");
for (int i = 0; i < 20; i++) x[i] = Con-
vert.ToDouble(Console.ReadLine()); max_x = x[1];
min_x = x[1];
for (int i = 1; i < 20; i++)
{
if (min_x > x[i]) min_x = x[i]; if (max_x < x[i]) max_x = x[i];
}
if (min_x!=max_x)
for ( int i = 0; i < 20; i++) if (max_x==x[i]) x[i]=min_x; else if (min_x==x[i])
x[i]=max_x;
for (int i = 0; i < 20; i++) Console.Write(x[i]+"\t");
Console.WriteLine();
Console.ReadLine();
}
}
|
|
Начало |
|
|
Ввод массива |
|
|
x |
|
|
min_x=x[1]; |
|
|
max_x=x[1]; |
|
|
A |
|
|
i=2; |
|
|
i>20 |
|
True |
|
|
|
min_x>x[i]; |
|
min_x=x[i]; |
|
|
|
False |
|
True |
|
|
|
max_x<x[i]; |
|
max_x=x[i]; |
|
|
|
False |
|
|
A |
|
|
i++ |
|
False |
|
|
|
max_x!= min_x |
|
|
True |
|
|
B |
|
|
i=1; |
|
|
i>20 |
|
False |
|
|
|
max_x==x[i]; |
False |
|
True |
|
min_x==x[i]; |
|
|
x[i]= min_x; |
|
|
|
|
|
True |
|
|
x[i]= max_x; |
|
|
|
B |
|
|
i++ |
В случае многомерных массивов алгоритм поиска минимального и максимального элементов не изменяется. Единственое отличие, в том, что для просмтора многомерного массива нужно будет использовать несколько вложенных циклов (по циклу на
каждое измерение). Кроме того, порой полезно запоминать не само значение минимального или максимального элемента, а его индекс (индексы – в случае многомерного массива). И в дальнейшей обработке обращаться к элементу массива с этими индексами.