6. Перестановка элементов массива в обратном порядке

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

Решение. Для всех индексов необходимо каждый i-й элемент поменять местами с -м элементом. Обратите внимание, что для обмена местами левой и правой половин массива цикл должен отработать только раз при любом n (как четном, так и нечетном).

#include <stdio.h>

void main()

{

const int n=10;

int A[n], i, t;

// ввод массива А

for(i=0; i<n/2; i++)

{ t=A[i]; A[i]=A[n-i-1]; A[n-i-1]=t; }

printf("Элементы массива после перестановки: \n");

for(i=0; i<n; i++)

printf(" %d", A[i]);

}

7. Циклический сдвиг элементов массива

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

1

2

3

4

5

–––––––

5

1

2

3

4

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

1

2

3

4

5

–––––––

2

3

4

5

1

Пример. Значения массива сдвинуть циклически вправо на одну позицию.

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

#include <stdio.h>

void main()

{

const int n=10;

int A[n], i, t;

// ввод массива А

t=A[n-1];

for(i=n-1; i>0; i--)

A[i]=A[i-1];

A[0]=t;

printf("Элементы массива после циклического сдвига: \n");

for(i=0; i<n; i++)

printf(" %d", A[i]);

}

8. Сортировка элементов массива в порядке возрастания (убывания)

Сортировка – это расстановка элементов некоторого списка в заданном порядке.

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

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

Изучим два понятных, но неэффективных метода, которых хватает для простых задач.

Метод пузырька

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

Предположим, что у нас n элементов в массиве и индекс каждого элемента лежит в промежутке от 1 до n.

Алгоритм и особенности этой сортировки таковы:

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

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

3. При втором проходе незачем сравнивать последний элемент с предпоследним. Последний элемент уже стоит на своем месте. Значит, число сравнений будет на одно меньше.

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

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

6. После этого первый элемент не с чем сравнивать, и, следовательно, последний проход по массиву не нужен. Другими словами, количество проходов по массиву равно n-1.

7. Количество сравнений в каждом проходе равно n-i, где i – это номер прохода по массиву (первый, второй, третий и т.д.).

8. При обмене элементов массива обычно используется "буферная" (третья) переменная, куда временно помещается значение одного из элементов.

#include <stdio.h>

void main()

{

const int n=10;

int A[n], i, j, t;

// ввод массива А

for(i=1; i<n; i++)

for(j=0; j<n-i; j++)

if (A[j]>A[j+1])

{ t=A[j]; A[j]=A[j+1]; A[j+1]=t; }

printf("Отсортированный массив:\n");

for(i=0; i<n; i++)

printf(" %d", A[i]);

}

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

Метод выбора минимального элемента

Этот метод основывается на алгоритме поиска минимального элемента. В массиве А[n] отыскивается минимальный элемент, который ставится на первое место. Для того чтобы не потерять элемент, стоявший на первом месте, этот элемент устанавливается на место минимального. Затем в усеченной последовательности, исключая первый элемент, отыскивается минимальный элемент и ставится на второе место, и так далее n-1 раз, пока не встанет на свое место предпоследний (n-1)-й элемент массива А, сдвинув максимальный элемент в самый конец.

#include <stdio.h>

void main()

{

const int n=10;

int A[n], i, k, min, imin;

// ввод массива А

for(k=0; k<n-1; k++)

{

min=A[k]; imin=k;

for(i=k+1; i<n; i++)

if (A[i]<min) { min=A[i]; imin=i; }

A[imin]=A[k]; A[k]=min;

}

printf("Отсортированный массив:\n");

for(i=0; i<n; i++)

printf(" %d", A[i]);

}