Популярные алгоритмы сортировки массивов

Программирование - Практика программирования

Разбор популярных алгоритмов сортировки массивов, реализованных на 1с. + обработка с наглядной реализацией алгоритмов.

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


1.Алгоритм "Сортировка выбором". 

Является одним из самых простых алгоритмов сортировки массива. Смысл в том, чтобы идти по массиву и каждый раз искать минимальный элемент массива, обменивая его с начальным элементом неотсортированной части массива. На небольших массивах может оказаться даже эффективнее, чем более сложные алгоритмы сортировки, но в любом случае проигрывает на больших массивах. Число обменов элементов по сравнению с "пузырьковым" алгоритмом N/2, где N - число элементов массива.

Алгоритм:
1. Находим минимальный элемент в массиве.
2. Меняем местами минимальный и первый элемент местами.
3. Опять ищем минимальный элемент в неотсортированной части массива
4. Меняем местами уже второй элемент массива и минимальный найденный, потому как первый элемент массива является отсортированной частью.
5. Ищем минимальные значения и меняем местами элементы,пока массив не будет отсортирован до конца.

//Сортировка выбором {---
Функция СортировкаВыбором(Знач Массив) 
	
	Мин = 0;
	Для i = 0 По Массив.ВГраница() Цикл		
		Мин = i;                       		
		Для j = i + 1 ПО Массив.ВГраница() Цикл		//Ищем минимальный элемент в массиве	
			Если Массив[j] < Массив[Мин] Тогда
				Мин = j;
			КонецЕсли; 
		КонецЦикла; 
		Если Массив [Мин] = Массив [i] Тогда           //Если мин. элемент массива = первому элементу неотс. части массива, то пропускаем.
			Продолжить;
		КонецЕсли;
		
		Смена = Массив[i];                            //Производим замену элементов массива.
		Массив[i] = Массив[Мин];
		Массив[Мин] = Смена;  
		
	КонецЦикла;
	Возврат Массив;	
КонецФункции
 

2.Алгоритм "Сортировка пузырьком". 

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

Алгоритм:
1.  Каждый элемент массива сравнивается с последующим и если элемент[i] > элемент[i+1] происходит замена. Таким образом самые "легкие" элементы "всплывают" - перемещаются к началу списка,а  самые тяжелые "тонут" - перемещаются к концу.
2.  Повторяем Шаг 1 n-1 раз, где n - Массив.Количество ().

//Сортировка пузырьком {---
Функция СортировкаПузырьком(Знач Массив)
	
	Для i = 0 По Массив.ВГраница() Цикл
		Для j = 0 ПО Массив.Вграница() - i - 1 Цикл
			Если Массив[j] > Массив[j + 1] Тогда
				Замена = Массив[j];
				Массив[j] = Массив[j + 1];
				Массив[j + 1] = Замена;
			КонецЕсли;			
		КонецЦикла;		
	КонецЦикла;	
	Возврат Массив;	
КонецФункции
//---}

3.Алгоритм "Шейкерная сортировка"(Сортировка перемешиванием,Двунаправленная пузырьковая сортировка).

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

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

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

//Сортировка перемешивание (Шейкер-Сортировка) {---
Функция СортировкаПеремешиванием(Знач Массив)
	
	Для i = 0 ПО Массив.ВГраница()/2 Цикл
		
		нИтер = 0;
		конИтер = Массив.ВГраница();  		
		Пока нИтер  Массив[нИтер+1] Тогда
				Замена = Массив[нИтер];
				Массив[нИтер] = Массив[нИтер + 1];
				Массив[нИтер + 1] = Замена;				
			КонецЕсли;
			нИтер = нИтер + 1;//Двигаем позицию на шаг вперед
			//Проходим с конца
			Если Массив[конИтер - 1] > Массив[конИтер] Тогда
				Замена = Массив[конИтер - 1];
				Массив[конИтер-1] = Массив[конИтер];
				Массив[конИтер] = Замена;				
			КонецЕсли;
			конИтер = конИтер - 1;//Двигаем позицию на шаг назад  			
		КонецЦикла; 		
	КонецЦикла;	   
	
	Возврат Массив;	
	
КонецФункции
//---}

4. Алгоритм "Гномья сортировка".

Алгоритм так странно назван благодаря голландскому ученому Дику Груну.

Гномья сортировка основана на технике, используемой обычным голландским садовым гномом (нидерл. tuinkabouter). Это метод, которым садовый гном сортирует линию цветочных горшков. По существу он смотрит на следующий и предыдущий садовые горшки: если они в правильном порядке, он шагает на один горшок вперёд, иначе он меняет их местами и шагает на один горшок назад. Граничные условия: если нет предыдущего горшка, он шагает вперёд; если нет следующего горшка, он закончил.
Дик Грун

Вот собственно и все описание алгоритма "Гномья сортировка". Что интересно, алгоритм не содержит вложенных циклов, а сортирует весь массив за один проход.

//Гномья сортировка {---   
Функция ГномьяСортировка(Знач Массив)
	
	i = 1;
	j = 2;
	
	Пока i < Массив.Количество() Цикл // Сравнение < - Сортировка по возрастанию, > - по убыванию   
		
		Если Массив[i-1]  
			i = j;
			j = j + 1;
		Иначе
			Замена = Массив[i];
			Массив[i] = Массив[i - 1];
			Массив[i - 1] = Замена;			
			i = i - 1;
			Если i = 0 Тогда
				i = j;
				j = j + 1;
			КонецЕсли;			
		КонецЕсли;		
	КонецЦикла;	
	
	Возврат Массив;	
КонецФункции
//---}
 

5. Алгоритм "Сортировка вставками".

Представляет собой простой алгоритм сортировки. Смысл заключается в том, что на каждом шаге мы берем элемент, ищем для него позицию и вставляем в нужное место.
Элементарный пример: При игре в дурака, вы тянете из колоды карту и вставляете ее в соответствующее место по возрастанию в имеющихся у вас картах. Или
в магазине вам дали сдачу 550 рублей- одна купюра 500, другая 50. Заглядываете в кошелек, а там купюры достоинством 10,100,1000. Вы вставляете купюру
достоинсвом 50р. между купюрами достоинством 10р и 100р, а купюру в 500 рублей между купюрами 100р и 1000р. Получается 10,50,100,500,1000 - Вот вам
и алгоритм "Сортировка вставками".
Таким образом с каждым шагом алгоритма, вам необходимо отсортировать подмассив данных и вставить значение в нужное место.


//Сортировка вставками {---
Функция СортировкаВставками(Знач Массив)
	
	Для i = 0 По Массив.ВГраница()-1 Цикл			
		Ключ = i + 1;
		Замена = Массив[Ключ];
		j = i + 1;
		Пока j > 0 И Замена < Массив[j - 1] Цикл
			Массив[j] = Массив[j - 1];
			Замена = j - 1;
			Ключ = j - 1; 
			j = j - 1;
		КонецЦикла;	
	
		Массив[Ключ] = Замена;
		
	КонецЦикла;   
	
	Возврат Массив;	
	
КонецФункции
//---}

6. Алгортим "Сортировка слиянием". 

Интересный в плане реализации и идеи алгоритм. Смысл его в том, чтобы разбивать массив на подмассивы, пока длина каждого подмассива не будет равна 1. Тогда мы утверждаем, что такой подмассив отсортирован. Затем сливаем получившиеся подмассивы воедино, одновременно сравнивая и сортируя поэлементно значения подмассивов.

 

p/s не смог вставить сюда рисунок с более наглядной схемой, постоянно размазывается. Зато хорошо видна в блоке скриншотов внизу. Можно посмотреть как работает алгоритм.

  

//Сортировка слиянием {---

Функция СортировкаСлиянием(Знач Массив)
	
	Если Массив.Количество() = 1 Тогда
		Возврат Массив;
	КонецЕсли;
	
	ТочкаРазрыв = Массив.Количество() / 2;
	
	лМассив = Новый Массив;
	прМассив = Новый Массив;
	
	Для Сч = 0 ПО Массив.ВГраница() Цикл
		Если Сч < ТочкаРазрыв Тогда
			лМассив.Добавить(Массив[Сч]);
		Иначе
			прМассив.Добавить(Массив[Сч]);
		КонецЕсли;
	КонецЦикла;
	
	Возврат Слияние(СортировкаСлиянием(лМассив),СортировкаСлиянием(прМассив));
	
КонецФункции

Функция Слияние(массив1,массив2)
	
	a = 0;
	b = 0;
	слМассив = Новый Массив;
	
	Для Сч = 0 ПО (Массив1.Количество() + Массив2.Количество())-1 Цикл
		слМассив.Добавить();
	КонецЦикла;
	
	Для i = 0 ПО (массив1.Количество() + массив2.Количество())-1 Цикл    		
		Если b <  массив2.Количество() И a < массив1.Количество() Тогда			
			Если (массив1[a] > массив2[b]) И (b < массив2.Количество()) Тогда
				слМассив[i] =  массив2[b];
				b = b + 1;
			Иначе
				слМассив[i] =  массив1[a];
				a = a + 1;
			КонецЕсли; 			
		Иначе
			Если b < массив2.количество() Тогда
				слМассив[i] = массив2[b];
				b = b + 1;
			Иначе
				слМассив[i] = массив1[a];
				a = a + 1;
			КонецЕсли;			
		КонецЕсли;
				
	КонецЦикла;	
	
	Возврат слМассив;
	
КонецФункции   
//---}
 

7. Алгортим "Сортировка Шелла". 

 Алгоритм назван так в честь американского ученого Дональда Шелла. По своей сути этот алгоритм является усовершенствованным алгоритмом "Сортировка вставками". Смысл алгоритма заключается в том, чтобы сравнивать не только элементы, стоящие рядом друг с другом, но и на некотором удалении. Сначало выбирается Шаг - некий промежуток, через который будут сравниваться элементы массива на каждой итерации. Обычно его определяют так:
Для первой итерации Шаг = Цел(Массив.Количество()/2), для последующих Шаг = Цел(Шаг/2). Т.е. постепенно шаг сокращается и когда Шаг будет равен 1 произойдет последние сравнение и массив будет отсортирован.

Пример:
Дан массив (10,5,3,1,14,2,7,12).
1. Шаг = 4.
Сортируем простыми вставками каждые 4 группы по 2 элемента (10,14)(5,2)(3,7)(1,12)

10,2,3,1,14,5,7,12

2. Шаг = 2 
Сортируем простыми вставками каждые 2 группы по 4 элемента (10,3,14,7)(2,1,5,12) 

3,1,7,2,10,5,14,12

3. Шаг = 1
Сортируем простыми вставками каждую 1 группу по 8 элементов.

 1,2,3,5,7,10,12,14 


//Сортировка Шелла {---
Функция СортировкаШелла(Знач Массив)
	
	Шаг = Цел(Массив.Количество()/2);
	
	Пока Шаг > 0 Цикл
		i = 0;
		Пока i < (Массив.Количество() - Шаг) Цикл
			j = i;
			Пока j >= 0 И Массив[j] > Массив[j + Шаг] Цикл
				Замена = Массив[j];
				Массив[j] = Массив[j + Шаг];
				Массив[j + Шаг] = Замена;
				j = j - 1;
				
				Если ПрименитьОтображениеСортировки Тогда	
					ОтобразитьДиаграммуСортировки(Массив);	
				КонецЕсли;
				
			КонецЦикла;				
			i = i + 1;	
		КонецЦикла;
		Шаг = Цел(Шаг/2);
		
		ОбработкаПрерыванияПользователя();
	КонецЦикла;
	
	Возврат Массив;
	
КонецФункции   
//---}

8. Алгортим "Быстрая сортировка". 

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

 //Алгоритм "Быстрая сортировка" { 
Процедура б_Сортировка(Массив,НижнийПредел,ВерхнийПредел)
      
	
    i    = НижнийПредел;
    j    = ВерхнийПредел;
    m    = Массив[Цел((i+j)/2)];
	
	Пока Истина Цикл        
        Пока Массив[i] < m Цикл            
            i    = i + 1;                   
		КонецЦикла;
		
        Пока Массив[j] > m Цикл            
            j    = j - 1;                   
        КонецЦикла; 
        
        Если i > j Тогда                       
            Прервать;                        
        КонецЕсли;
        
	КонецЦикла;
	
    Если НижнийПредел < j Тогда         
        б_Сортировка(Массив,НижнийПредел,j);        
	КонецЕсли; 
	
    Если i < ВерхнийПредел Тогда                      
        б_Сортировка(Массив,i,ВерхнийПредел);        
    КонецЕсли;
    
КонецПроцедуры

Функция БыстраяСортировка(Массив)
	
	НижняяГраница = 0;
	ВерхняяГраница = Массив.ВГраница();	
	б_Сортировка(Массив,НижняяГраница,ВерхняяГраница);
	
	Возврат Массив;
	
КонецФункции
 //---}

9. Классическая сортировка массива в 1с. 

Передаем массив в список значений. Сортируем стандартным методом "Сортировать". 

//Сортировка списком значений {---
Функция СортировкаСпискомЗначений(Знач Массив)
	
        мСписокЗнч = Новый СписокЗначений;
        мСписокЗнч.ЗагрузитьЗначения(Массив);
	мСписокЗнч.СортироватьПоЗначению(НаправлениеСортировки.Возр);	
	Возврат мСписокЗнч.ВыгрузитьЗначения();
КонецФункции
//---}


Все сортировки можно ускорить расположив код в циклах в 1 строку. Но для читабельности, оставил так.


Написал обработку в которой реализованы все вышеперечисленные алгоритмы, также поддерживается динамическая анимация процесса сортировки(Кроме стандартной сортировки 1с).

-При запуске обработки автоматически происходит формирование массива случайных чисел от 0 до 100 размерностью 100 элементов.
-Для создания другого массива необходимо нажать на кнопку "Создание ГСЧ массива ", также можно выбирать необходимый диапазон.
-Для включения динамической анимации необходимо поставить галочку на "Отобразить сортировку в диаграмме". Советую на неэффективных алгоритмах устанавливать галочку при размерности массива до 100 элементов, иначе состаритесь ждать сортировки:) 

- Динамическая отрисовка процесса сортировки очень сильно снижает производительность, зато наглядно видно как работает алгоритм.

Скачать файлы

Наименование Файл Версия Размер
СортировкаМассива
.epf 11,25Kb
21.10.13
41
.epf 11,25Kb 41 Скачать

См. также

Вознаграждение за ответ
Показать полностью
Комментарии
1. Сергей Ожерельев (Поручик) 3661 19.10.13 01:08 Сейчас в теме
Где бы их ещё применить для 1С. Взял на заметку, может где понадобится.
2. Яков Коган (Yashazz) 2149 20.10.13 11:02 Сейчас в теме
Всю жизнь полагал, что в 1С применяется или быстрая, или шелловская сортировка. Интересно, что там на самом деле. Автор, делались ли замеры скорости, насколько метод списка значений выигрывает?
3. Евгений (Ekovichev) 533 20.10.13 13:38 Сейчас в теме
Мне думается, что в 1с используется быстрая сортировка. Сравнения делались между сортировкой списком и быстрой сортировкой. Разница в сортировке массива размерностью 10 000 и значениями диапазоном от 0 до 100 при сортировке списком значений и быстрой сортировкой вообще незаметна. А вот на массиве размерностью 100 000 диапазон значений от 0 до 1000, сортировка списком значений показала результат около 2-3 секунд, а быстрая в среднем 6-7 секунд.
4. Сергей Ожерельев (Поручик) 3661 20.10.13 14:51 Сейчас в теме
(0) Вижу исправили. Вчера Был перебор массива в функции СортировкаСпискомЗначений(). Хотел написать, но отвлёкся.

мСписокЗнч = ЗагрузитьЗначения(Массив);
5. Евгений (Ekovichev) 533 20.10.13 15:01 Сейчас в теме
Да, вчера сам перечитал статью и заметил, понял, что не стоит писать по ночам)
6. Анатолий (hame1e00n) 483 20.10.13 18:48 Сейчас в теме
Полезная информация, спасибо!
7. Василий Борисов (EliasShy) 49 21.10.13 06:38 Сейчас в теме
Хорошо было бы написать жадность алгоритмов в нотации большого О.
8. Евгений (Ekovichev) 533 21.10.13 06:42 Сейчас в теме
Хорошо, добавлю в статью
9. Александр Окулов (PowerBoy) 2584 21.10.13 07:52 Сейчас в теме
Очепятки:
Если Массив[i-1] - по убыванию
i = j;
j = j + 1;
Иначе



Если ij Тогда
Прервать;
КонецЕсли;

10. Евгений (Ekovichev) 533 21.10.13 08:11 Сейчас в теме
Исправил, спасибо за замечание
11. Сергей Борисов (juntatalor) 58 21.10.13 14:23 Сейчас в теме
Мне приходилось использовать "свою" сортировку для сортировки дерева значений на управляемой форме. Уж не помню, чем меня не устраивал метод ДанныеФормыДерево -> ДеревоЗначений -> Сортировка -> ДанныеФормыДерево, но быстрая сортировка на клиенте подошла лучше.
12. Михаил Афанасьев (mikmike) 5 22.10.13 06:14 Сейчас в теме
а метод двоичного дерева?
У меня в свое время была курсовая по методам сортировки.
Так метод двоичного дерева на больших массивах сильно быстрей работает
PS 1C тогда и в проекте не существовало. Алгоритм сложный, рекурсивный, но шустрый на больших массивах.
13. Евгений (Ekovichev) 533 22.10.13 06:33 Сейчас в теме
Да метод бинарного дерева интересен, я его посмотрел, начал писать на 1С и что-то не закончил :) Но если будет интересно, можно и его рассмотреть
18. Михаил Афанасьев (mikmike) 5 23.10.13 06:31 Сейчас в теме
(13) теоритически конечно интересно - у меня в свое время заметный выигрыш получался на массивах из сотен и более элементов. 10 чисел быстрее всего упорядочивает самый простой алгоритм.
Но вот на сколько реальна задача? Приведите кто-нибудь пример из жизни, пожалуйста.
14. ediks (ediks) 325 22.10.13 16:18 Сейчас в теме
15. Mu_meson (KAPACEB.AA) 22.10.13 21:55 Сейчас в теме
16. Mu_meson (KAPACEB.AA) 22.10.13 21:57 Сейчас в теме
Если не ошибаюсь, в сортировке вставками вместо:


Пока j > 0 Цикл
Если Замена < Массив[j - 1] Тогда
Массив[j] = Массив[j - 1];
Замена = j - 1;
Ключ = j - 1;
КонецЕсли;
j = j - 1;
КонецЦикла;


в идеале должно быть так:

Пока j > 0 И Замена < Массив[j - 1] Цикл
Массив[j] = Массив[j - 1];
Замена = j - 1;
Ключ = j - 1;
j = j - 1;
КонецЦикла;

В таком случае не будет бессмысленного перебора элементов в уже отсортированной части массива.

Пруфлинк
17. Евгений (Ekovichev) 533 22.10.13 22:03 Сейчас в теме
(16) Mu_meson, Вы правы, поправил.
20. Роман Грук (gruk) 3 23.10.13 12:27 Сейчас в теме
А вот на массиве размерностью 100 000 диапазон значений от 0 до 1000, сортировка списком значений показала результат около 2-3 секунд, а быстрая в среднем 6-7 секунд.

ИМХО: Дак наверное и не получится "сортировку списком значений" обогнать. Это же функция платформы, а любые самописные алгоритмы требуют время на интерпритацию команд.

Вот еще надо проверить, сколько памяти массив и список отъедают, и может в жизни и пригодиться для обработки очень больших массивов.

Думал, что в конце статьи увижу табличку с замером производительности алгоритмов и потребляемыми ресурсами :(

Но все равно плюсую, познавательно.
21. Евгений (Ekovichev) 533 23.10.13 12:30 Сейчас в теме
(20) gruk, Сделаю, хорошая идея. Насчет времени все ясно, только как замерить потребляемые ресурсы?
24. Роман Грук (gruk) 3 24.10.13 04:27 Сейчас в теме
(21) Я имел ввиду оценить ресурсы приблизительно. Допустим "Сортировка вставками" потребляет мало, т.к. не нужен доп. массив и используется всего 4 переменных. (Кстати, если сделать процедуру и работать не со Знач массив, а со ссылкой, то ресурсов потребуется в 2 раза меньше.) Экономия ресурсов - 5. А "Сортировка слиянием" создает новые массивы. Экономия - 3.
Почему я заговорил про ресурсы, пишу програмку, там использую 2-х мерные большие массивы. Комп слабоват. Сортирую через таблицы значений и память подъедает заметно, винда начинает использовать файл подкачки и падает производительность.

Замер памяти я делал так: запускал 1с, консоль программиста, писал код, смотрел потребляемую память через дисп.задач, запускал код(в конце выводил предупреждение, чтоб массив не уничтожился), опять смотрел память.
Результаты с 100 000 элементов от 0 до 65535 такие: Массив ~800 Кб, СписокЗначений ~9,5 Мб, ТаблицаЗначений с одной колонкой ~5,8 Мб. Еще заметил что после массива память освобождается почти сразу, а после списка или таблицы нет (но если запустить второй раз, увеличение потребления памяти уже намного меньше)
25. Роман Грук (gruk) 3 24.10.13 04:37 Сейчас в теме
(21) насчет времени все просто.

Scr = Новый COMОбъект("MSScriptControl.ScriptControl"); 
Scr.Language = "javascript"; 

ВремяНачалаВыполнения = Scr.Eval("new Date().getTime()");

   //выполнить код

ВремяКонцаВыполнения = Scr.Eval("new Date().getTime()");
ВремяВыполнения = ВремяКонцаВыполнения - ВремяНачалаВыполнения; //время в милисекундах
Показать


Откуда взял, не помню, да простит меня автор.
22. DAnry (DAnry) 7 23.10.13 13:06 Сейчас в теме
Спасибо. Достаточно полный анализ по узкой теме. Однозначно +
23. Андрей Овсянкин (Evil Beaver) 4413 23.10.13 14:54 Сейчас в теме
Еще бы неплохо написать, какой именно алгоритм скрывается за 1С-овским "СортироватьПоЗначению()". Сейчас уже не найду, но вроде бы где-то проскакивало в сети, что там qsort, т.е. быстрая сортировка.
26. Евгений (Ekovichev) 533 24.10.13 06:42 Сейчас в теме
Как будет время проведу тест и в таблице опубликую. Замер времени вы взяли отсюда http://infostart.ru/public/71130/ :)
27. Данила Елистратов (CagoBHuK) 27 25.10.13 14:20 Сейчас в теме
Однозначный плюс за труд.
28. Максим Зудин (kasper076) 18 25.10.13 14:28 Сейчас в теме
29. Евгений (Ekovichev) 533 25.10.13 15:10 Сейчас в теме
(28) kasper076, Я тоже сегодня на хабре прочел, заинтересовался:)
30. mikhailovaew (mikhailovaew) 128 28.11.13 12:47 Сейчас в теме
эх, где тут ildarovich, он бы еще каждый алгоритм оптимизировал с ускорением работы в 5 раз )
31. Сергей Аверьянов (saver77) 9 06.03.14 15:29 Сейчас в теме
Спасибо за проделанную работу. Имею два предложения по быстрой сортировке:
1. Для наглядности вызов ОтобразитьДиаграммуСортировки лучше разместить в цикле, тогда нагляднее будет.
2. Полагаю, так красивее, если условие выхода из цикла перенести из оператора Если в оператор Пока.
В итоге код процедуры будет такой

Процедура б_Сортировка(Массив,НижнийПредел,ВерхнийПредел)

    i    = НижнийПредел;
    j    = ВерхнийПредел;
    m    = Массив[Цел((i+j)/2)];
	
	//Пока Истина Цикл
	Пока i<=j Цикл  		
		
        Пока Массив[i] < m Цикл            
            i    = i + 1;                   
		КонецЦикла;
		
        Пока Массив[j] > m Цикл            
            j    = j - 1;                   
        КонецЦикла; 
        
        Если i<=j Тогда               
            Замена            = Массив[i];
            Массив[i]    = Массив[j];
            Массив[j]    = Замена;
            i            = i + 1;
            j            = j - 1;            
			Если ПрименитьОтображениеСортировки Тогда	
				ОтобразитьДиаграммуСортировки(Массив);	
			КонецЕсли;			
        КонецЕсли;
        
		//Если i>j Тогда                       
		//	Прервать;                        
		//КонецЕсли;
        
	КонецЦикла;
	
    Если НижнийПредел < j Тогда         
        б_Сортировка(Массив,НижнийПредел,j);        
	КонецЕсли; 
	
    Если i < ВерхнийПредел Тогда                      
        б_Сортировка(Массив,i,ВерхнийПредел);        
    КонецЕсли;
    
КонецПроцедуры
Показать
A1ice1990; Ekovichev; +2 Ответить
32. Александр Тарасенков (tarasenkov) 228 20.06.14 12:46 Сейчас в теме
В коде процедуры быстрой сортировки забыли важную часть:
       Если i <= j Тогда               
            Замена       = Массив[i];
            Массив[i]    = Массив[j];
            Массив[j]    = Замена;
            i            = i + 1;
            j            = j - 1;            
        КонецЕсли;

(Обработку скачал, там этот код есть)
A1ice1990; Фаршик; Ekovichev; +3 Ответить
33. Иван Гончаров (JohnConnor) 25 22.12.14 07:43 Сейчас в теме
однозначна нужная вещь, для изучения алгоритмов
34. Александр Пушкин (Sasha25) 26.12.14 11:24 Сейчас в теме
Ну прямо таки даже и не знаю что и сказать. Наверное конечно фундаментальными знаниями нужно владеть
35. Илларион Пак (pakill) 43 20.01.15 03:30 Сейчас в теме
Когда-то, еще до нашей эры (ДОС, Паскаль) придумал метод сортировки: "разноской по значению" и для сравнения написал маленькую демо-програмку.
Прикрепленные файлы:
SORTDEMO.EXE
SORTDEMO.PAS
SORTSHOW.PAS
DoctorRoza; +1 Ответить
36. Алексей Роза (DoctorRoza) 03.02.15 11:11 Сейчас в теме
Отмечусь, может пригодится! Хотя .. обрабатывать в 1С Массив(), да еще и большим количеством элементов .. в какой задаче такое возможно? :)
37. Алекс Ю (AlexO) 120 03.02.15 11:16 Сейчас в теме
(36) DoctorRoza,
в какой задаче такое возможно?
Например, в задаче, где в массив запихнута огромная ТЗ ))
38. Антон Паскаль (platon_) 10 21.08.15 16:59 Сейчас в теме
В Алгоритм "Гномья сортировка".
Упущена часть кода в первом условии
Если Массив[i-1]  < Массив[i]
39. Ivan Sadoviy (sadiv) 11 31.08.16 19:55 Сейчас в теме
Добавил управляемую форму.
Прикрепленные файлы:
СортировкиМассиваУпр.epf
Оставьте свое сообщение