Методические указания и задания к лабораторным работам для учащихся ссуз специальности Т1002



страница18/31
Дата14.08.2018
Размер2.1 Mb.
#43969
ТипМетодические указания
1   ...   14   15   16   17   18   19   20   21   ...   31

Порядок выполнения работы


  1. Изучить теоретические сведения по теме: ”Алгоритмы сортировок включением и выбором”

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

  3. Показать работающую программу преподавателю.

  4. Ответить на контрольные вопросы.

Контрольные вопросы


  1. Понятие сортировки. Виды сортировок.

  2. Сортировки включением. Описание алгоритмов методов сортировки прямыми и бинарными включениями.

  3. Сортировки включением. Описание алгоритмов методов сортировки прямыми и бинарными включениями.

  4. Сортировка выбором. Описание алгоритма.

  5. Фрагменты программ для реализации данных методов сортировок.



Лабораторная работа № 19


Реализация алгоритмов обменных сортировок при написании программы на Паскале
Цель работы: формирование знаний и умений по изучению методов внутренних сортировок. Приобретение навыков реализации алгоритмов сортировки.

Краткие теоретические сведения


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

Сортировка прямого обмена (пузырьковая)


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

Начнем последовательность обменов с элементами а[N]. В каждом проходе местами меняются соседние элементы. Самый легкий элемент поднимается за один проход, самый тяжелый опускается вниз за один проход. Если самый большой элемент был первым, то выполняется N проходов. Критерием окончания является отсутствие обменов при очередном проходе.



Здесь и далее, во всех процедурах сортировки ключи упорядочиваются по возрастанию. На входе процедур - количество элементов массива (n), на выходе - упорядоченный массив элементов(а).

Procedure Bubble_Sort(n:word;Var a:t);

Var

i,j:word;



x:integer;

Begin


For i:=2 To n Do

begin


For j:=n DownTo i Do

If a[j-1]>a[j] Then

begin

x:=a[j-1]; a[j-1]:=a[j]; a[j]:=x



end

end


End;{Bubble_Sort}

Шейкерная сортировка


Улучшение алгоритма - это запоминать, производится ли на данном проходе какой-либо обмен. Если нет, то это означает, что алгоритм может закончить работу. Этот процесс улучшения можно продолжить, если запомнить не только сам факт обмена, но и место (индекс) последнего обмена. Все пары соседних элементов с индексами, меньшими этого индекса k, уже расположены в нужном порядке. Поэтому следующие проходы можно заканчивать на этом индексе, вместо того чтобы двигаться до установленной заранее нижней границы i.

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

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

Procedure Shaker_Sort(n:word;Var a:t);

Var

j,k,l,r:word;



x:integer;

Begin


l:=2; r:=n; k:=n;

Repeat


For j:=r DownTo l Do

If a[j-1]>a[j] Then

begin

x:=a[j-1]; a[j-1]:=a[j]; a[j]:=x; k:=j;



end;

l:=k+1;


For j:=l To r Do

If a[j-1]>a[j] Then

begin

x:=a[j-1]; a[j-1]:=a[j]; a[j]:=x; k:=j;



end;

r:=k-1;


Until l>r

End;{Shaker_Sort}


Пирамидальная сортировка

Пирамида определяется как последовательность ключей hl, hl+1, ..., hr такая, что hi<=h2i, hi<=h2i+1 для всякого i=l,...,r/2.
Предположим, что дана пирамида с элементами hl+1, ..., hr для некоторых значений l и r и нужно добавить новый элемент x для того, чтобы сформировать расширенную пирамиду hl, ..., hr. Новый элемент x сначала помещается в вершину дерева, а затем “просеивается” по пути, на котором находятся меньшие по сравнению с ним элементы, которые одновременно поднимаются вверх; таким образом, формируется новая пирамида.

Здесь в процедуре Heap_Sort вызывается процедура Sift, которая реализует алгоритм формирования пирамиды.

Procedure Heap_Sort(n:word;Var a:t);

Var

l,r:word;x:integer;



Procedure Sift;

Label 13;

Var i,j:word;

Begin


i:=l; j:=2*i; x:=a[i];

While j<=r Do

begin

If j

If a[j]

If x>=a[j] Then Goto 13;

a[i]:=a[j]; i:=j; j:=2*i;

end;


13: a[i]:=x

End;{Sift}

BEGIN

l:=(n div 2)+1; r:=n;



While l>1 Do

begin


l:=l-1; Sift

end;


While r>1 Do

begin


x:=a[1]; a[1]:=a[r]; a[r]:=x;

r:=r-1; Sift

end

END;{Heap_Sort}


Обменная сортировка разделением


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

Выбирается любой произвольный элемент массива, далее массив просматривается слева направо до тех пор пока не будет найден элемент больший выбранного; а затем просмотрим его справа налево, пока не найдем элемент меньший выбранного. Найденные элементы поменяем местами. Затем продолжим процесс “просмотра с обменом”, пока два просмотра не встретятся где-то в середине массива. В результате массив разделится на две части: левую - с ключами меньшими выбранного элемента; и правую - с большими ключами. Описанный алгоритм применяется к обоим этим частям, в результате чего последовательность разбивается на 4 части. Алгоритм применяется к каждой четвертинке и т.д. Разделение заканчивается, когда в каждой части остается 1 элемент.



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

Procedure Quick_Sort(n:word;Var a:massiv);

Procedure Sort1(l,r:word);

Var


w,x:integer;

i,j:word;

Begin

i:=l; j:=r;



x:=a[(l+r) div 2];

Repeat


While a[i]While a[j]>x Do j:=j-1;

If i<=j Then

begin


w:=a[i]; a[i]:=a[j]; a[j]:=w;

i:=i+1; j:=j-1

end

Until i>j;



If l

If i

End;{Sort1}

BEGIN


Sort1(1,n);

END;{Quick_Sort}




Поделитесь с Вашими друзьями:
1   ...   14   15   16   17   18   19   20   21   ...   31




База данных защищена авторским правом ©vossta.ru 2022
обратиться к администрации

    Главная страница