русс | укр

Языки программирования

ПаскальСиАссемблерJavaMatlabPhpHtmlJavaScriptCSSC#DelphiТурбо Пролог

Компьютерные сетиСистемное программное обеспечениеИнформационные технологииПрограммирование

Все о программировании


Linux Unix Алгоритмические языки Аналоговые и гибридные вычислительные устройства Архитектура микроконтроллеров Введение в разработку распределенных информационных систем Введение в численные методы Дискретная математика Информационное обслуживание пользователей Информация и моделирование в управлении производством Компьютерная графика Математическое и компьютерное моделирование Моделирование Нейрокомпьютеры Проектирование программ диагностики компьютерных систем и сетей Проектирование системных программ Системы счисления Теория статистики Теория оптимизации Уроки AutoCAD 3D Уроки базы данных Access Уроки Orcad Цифровые автоматы Шпаргалки по компьютеру Шпаргалки по программированию Экспертные системы Элементы теории информации

Метод быстрой сортировки с разделением


Дата добавления: 2015-06-12; просмотров: 906; Нарушение авторских прав


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

Program Quck_sort; {Быстрая сортировка по невозрастанию дроблением массива на части}

uses Crt;

const

Count=20;

M: array [1.. Count] of byte=(9,11,12,3,19,1,5,17,10,18,3,19,17,9,12,20,20,19,2,5);

var

I, A: integers;

procedure QuickS(First, Last: integer);

var I,J,X,W,L: integer;

begin

I: = First; {Левая граница массива - первый элемент}

J: = Last; (Правая граница массива - первый элемент}

X: =M [(First+ Last) div 2]; (Определить середину массива}

repeat

while M[I]>X do

I: =1+1;

While X>M [J] do

J: = J-1;

A: =A+1 ;( Увеличить число итераций обмена элементов}

if K=J then

begin (Обменять местами элементы}

W: =M[i];

M [I]:=M [J];

M [J]:=W;

I: =I+1;

J: =J-1 ;( Печатать текущее состояние массива после каждой перестановки}

for L:=1 to Count do Write (‘’, M [L]);

Writeln (′Число итераций =′, А);

end;

until I>J;

if First<J then QuickS (First, J)

if K Last then Quacks(I, Last); {Рекурсивный вызов процедуры QuickS }

end;{Конец сортировки}

begin {Начало основной программы}

CIrScr;

Writeln (′Исходный массив :′);

Writeln;

for I:=1 to Count do Write(M[I]:3,′‘); Writeln;

A: =0;

QuickS (1, Count) ;{ Вызов процедуры сортировки QuickS}

Writeln {′Отсортированный массив :′); Writeln;

for I:=1 to Count do Write(M[I]:3,′‘); Writeln;

end.

После первого вызова процедуры QuickS в исходном массиве: 9 11 12 3 1 9 1 5 1710 183 1 9 17 9 12 20 20 19 2 5 будет определена его середина (10-й элемент) и переменной X присвоено значение M[10], т.е. 18. После этого массив делится на две части: 9 1 12 3 1 9 1 5 17 10 18 и 3 19 17 9 12 20 20 9 2 5



Далее выполняется обмен элементами по следующему правилу:

При просмотре левой части массива слева направо выполняется поиск такого элемента массива, что M[I]>X, затем при просмотре правой части справа налево отыскивается такой элемент, M[I]<X. Выполняется обмен местами данных элементов, пока все элементы слева от середины, удовлетворяющие условию M[I]>X, не будут обменены с элементами, расположенными справа от середины и удовлетворяющими условию M[I]<X. В результате этого получим массив из двух частей следующего вида:

9 11 12 19 1 5 17 10 18 3 19 17 9 12 20 20 19 2 5 Число итераций=1

19 20 12 3 19 1 5 17 10 18 3 19 17 9 12 20 11 9 2 5 Число итераций=2

19 20 20 3 19 1 5 17 10 18 3 19 17 9 12 12 11 9 2 5 Число итераций=3

19 20 20 19 19 1 5 17 10 18 3 3 17 9 12 12 11 9 2 5 Число итераций=4

19 20 20 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=5

Далее рекурсивно левая часть в свою очередь дробится на две части, и вызывается процедура для сортировки левой части (с 1-го по 6-и элемет)

20 20 19 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=7

20 20 19 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=8

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

20 20 19 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=9

20 20 19 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=10

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

Затем рекурсивно вызывается процедура для аналогичной сортировки правой части (с 7-го по 19-й элемент). Результат последовательных этапов сортировки массива отображается так:

20 20 19 19 19 18 5 17 10 1 3 3 17 9 12 12 11 9 2 5 Число итераций=11

20 20 19 19 19 18 17 17 10 1 3 3 5 9 12 12 11 9 2 5 Число итераций=12

20 20 19 19 19 18 17 17 10 1 3 3 5 9 12 12 11 9 2 5 Число итераций=13

20 20 19 19 19 18 17 17 10 9 3 3 5 9 12 12 11 1 2 5 Число итераций=14

20 20 19 19 19 18 17 17 10 9 1 1 3 5 9 12 12 3 1 2 5 Число итераций=15

20 20 19 19 19 18 17 17 10 9 1 1 12 5 9 12 3 3 1 2 5 Число итераций=16

20 20 19 19 19 18 17 17 10 9 1 1 12 12 9 5 3 3 1 2 5 Число итераций=17

20 20 19 19 19 18 17 17 10 9 1 1 12 12 9 5 3 3 1 2 5 Число итераций=18

20 20 19 19 19 18 17 17 12 9 1 1 12 10 9 5 3 3 1 2 5 Число итераций=19

20 20 19 19 19 18 17 17 12 12 1 1 9 10 9 5 3 3 1 2 5 Число итераций=20

20 20 19 19 19 18 17 17 12 12 1 1 9 10 9 5 3 3 1 2 5 Число итераций=21

20 20 19 19 19 18 17 17 12 12 1 1 9 10 9 5 3 3 1 2 5 Число итераций=22

20 20 19 19 19 18 17 17 12 12 1 1 10 9 9 5 3 3 1 2 5 Число итераций=23

20 20 19 19 19 18 17 17 12 12 1 1 10 9 9 5 3 3 1 2 5 Число итераций=24

20 20 19 19 19 18 17 17 12 12 1 1 10 9 9 5 3 3 1 2 5 Число итераций=25

20 20 19 19 19 18 17 17 12 12 1 1 10 9 9 5 3 3 1 2 5 Число итераций=26

20 20 19 19 19 18 17 17 12 12 1 1 10 9 9 5 5 3 3 2 1 Число итераций=27

По последнему значению А определяем что для данного массива сортировка по невозрастанию выполняется за 27 итераций.

Как видно из приведенных примеров, алгоритм ″быстро″ сортировки дает лучшие результаты, чем пузырьковый метод, однако следует учесть, что в некоторых случаях это преимущество снижается. Например, если применить эту программу для сортировки массива M, элементы которого имеют значение 29, 27, 24, 3, 23, 19, 19, 18, 1, 17, 15, 13, 1, 0, 9, 9, 8, 6, 6, 5, то сортировка будет выполнена за 28 итераций, т.е. время процесса и число итераций даже увеличатся, несмотря на то, что исходный массив в большей степени упорядочен, в то время как сортировка линейным методом-190 итераций для обоих массивов, пузырьковым-166(для первого массива-170).



<== предыдущая лекция | следующая лекция ==>
Сортировка методом пузырька. | Бинарный поиск в упорядоченных массивах.


Карта сайта Карта сайта укр


Уроки php mysql Программирование

Онлайн система счисления Калькулятор онлайн обычный Инженерный калькулятор онлайн Замена русских букв на английские для вебмастеров Замена русских букв на английские

Аппаратное и программное обеспечение Графика и компьютерная сфера Интегрированная геоинформационная система Интернет Компьютер Комплектующие компьютера Лекции Методы и средства измерений неэлектрических величин Обслуживание компьютерных и периферийных устройств Операционные системы Параллельное программирование Проектирование электронных средств Периферийные устройства Полезные ресурсы для программистов Программы для программистов Статьи для программистов Cтруктура и организация данных


 


Не нашли то, что искали? Google вам в помощь!

 
 

© life-prog.ru При использовании материалов прямая ссылка на сайт обязательна.

Генерация страницы за: 0.068 сек.