├── README.md
├── SortingAlgorithms.xcodeproj
    ├── project.pbxproj
    ├── project.xcworkspace
    │   ├── contents.xcworkspacedata
    │   ├── xcshareddata
    │   │   └── IDEWorkspaceChecks.plist
    │   └── xcuserdata
    │   │   └── MacBookAir.xcuserdatad
    │   │       └── UserInterfaceState.xcuserstate
    └── xcuserdata
    │   └── MacBookAir.xcuserdatad
    │       ├── xcdebugger
    │           └── Breakpoints_v2.xcbkptlist
    │       └── xcschemes
    │           └── xcschememanagement.plist
└── SortingAlgorithms
    ├── BubleSort.swift
    ├── CountingSort.swift
    ├── HeapSort.swift
    ├── MergeSort.swift
    ├── QuickSort.swift
    ├── SelectionSort.swift
    ├── ShakerSort.swift
    ├── ShellSort.swift
    └── main.swift


/README.md:
--------------------------------------------------------------------------------
  1 | ## Алгоритмы Сортировки
  2 | традиционные алгоритмы сортировки массивов написанные на Swift 4
  3 | 
  4 | ## Quick Sort (быстрая сортировка)
  5 | Выбираем некоторый опорный элемент (например, средний). После этого разбиваем исходный массив на три части: элементы эквивалентные опорному, меньше, больше опорного.
  6 | Рекурсивно вызовемся от большей и меньшей частей. В итоге получим отсортированный массив, так как каждый элемент меньше опорного стоял раньше каждого большего опорного. 
  7 | 
  8 | ![quick sort gif](https://upload.wikimedia.org/wikipedia/commons/f/fe/Quicksort.gif)
  9 | 
 10 | **Асимптотика:**
 11 | 
 12 | сложность в худшем  | сложность в среднем | сложность в лучшем |
 13 | --------------------|---------------------|--------------------|
 14 | O(n<sup>2</sup>)    | O(n log n)          | O(n)               |
 15 |  **худший случай**: если опорный элемент наименьший или наибольший из всех, то каждый раз массив разбивается на подмассивы размерами 1 и n-1 | - |**лучший случай**: массив постоянно разбивается опорным элементом на две раные части | 
 16 | 
 17 | **Расход памяти:** В общем случае O(log n). При неудачных подборках опорного элемнта O(n) - здесь память будет расходоваться не на создание новых вспомогательных массивов,
 18 | а на рекурсию, хранение адресов возврата и локальных переменных.
 19 | 
 20 | Алгоритм неустойчив (неудачные входные данные могут привести к значительному увеличению времени работы и расхода памяти). 
 21 | Является одним из самых быстродействующих алгоритмов, однако для массивов с небольшим количеством элементом может оказаться малоэффективным. 
 22 | 
 23 | ## Selection Sort (сортировка выбором)
 24 | Алгоритм пробегает по всем ещё не упорядоченным элементам, ищет среди них минимальный (сохраняя его значение и индекс) и переставляет в конец выстриваемого списка.
 25 | 
 26 | ![selection sort gif](https://upload.wikimedia.org/wikipedia/commons/9/94/Selection-Sort-Animation.gif)
 27 | 
 28 | **Асимптотика:**
 29 | 
 30 | сложность в худшем  | сложность в среднем | сложность в лучшем |
 31 | --------------------|---------------------|--------------------|
 32 | O(n<sup>2</sup>)    | O(n<sup>2</sup>)    | O(n<sup>2</sup>)   |
 33 | 
 34 | **Расход памяти:** O(1). Дополнительной памяти не требуется.
 35 | 
 36 | Алгоритм неустойчив.
 37 | 
 38 | ## Bubble Sort (пузырьковая сортировка)
 39 | Соседние элементы  сравниваются и при необходимости меняются местами, в результате "лёгкие" элементы перемещаются к началу списка, а "тяжёлые" - к концу. Операция циклически выполняется для оставшихся элементов.
 40 | 
 41 | ![bubble sort gif](http://gifimage.net/wp-content/uploads/2017/10/bubble-sort-gif-9.gif)
 42 | 
 43 | **Асимптотика:**
 44 | 
 45 | сложность в худшем  | сложность в среднем | сложность в лучшем |
 46 | --------------------|---------------------|--------------------|
 47 | O(n<sup>2</sup>)    | O(n<sup>2</sup>)    | O(n)               |
 48 | 
 49 | **Расход памяти:** O(1). Дополнительной памяти не требуется.
 50 | 
 51 | Алгоритм устойчив. На практике может использоваться лишь для сортировки маленьких массивов. И в этом случае лучше взять классическую сортировку, а не её модификацию.
 52 | 
 53 | ## Shaker Sort (сортировка перемешиванием)
 54 | Устанавливаем левую и правую границы сортируемой области массива. Поочерёдно просматриваем массив справа налево и слева направо. На очередной итерации при достижении правой границы 
 55 | сдвигаем её на предыдущий элемент (-1) и движемся справа налево, при достижении левой границы сдвигаем её на следующий элемент (+1) и двигаемся слева направо.
 56 | 
 57 | ![shaker sort gif](https://upload.wikimedia.org/wikipedia/commons/e/ef/Sorting_shaker_sort_anim.gif)
 58 | 
 59 | **Асимптотика:**
 60 | 
 61 | сложность в худшем  | сложность в среднем      | сложность в лучшем    |
 62 | --------------------|--------------------------|-----------------------|
 63 | O(n<sup>2</sup>)    |зависит от выбранных шагов| O(n log<sup>2</sup> n)|
 64 |  **худший случай**: отсортированный в обратном порядке массив| - |**лучший случай**:  отсортированный массив| 
 65 | 
 66 | **Расход памяти:** O(1). Дополнительной памяти не требуется.
 67 | 
 68 | Алгоритм устойчив. 
 69 | 
 70 | ## Shell Sort (сортировка Шелла)
 71 | Сравниваем элементы находящиеся друг от друга на некотором расстоянии (шаге). В алгоритме два цикла. Внутренний переставляет элементы. 
 72 | Внешний служит для изменения шага, через который внутренний цикл элементы будет переставлять. Шаг постепенно сокращается до 1 (минимальное расстояние между двумя элементами) - и тогда алгоритм Шелла превращается в 
 73 | обычную сортировку вставками.
 74 | 
 75 | ![shell sort gif](https://upload.wikimedia.org/wikipedia/commons/thumb/2/20/Shellsort-ru.svg/600px-Shellsort-ru.svg.png)
 76 | 
 77 | **Асимптотика:**
 78 | 
 79 | сложность в худшем  | сложность в среднем | сложность в лучшем |
 80 | --------------------|---------------------|--------------------|
 81 | O(n<sup>2</sup>)    | O(n<sup>2</sup>)    | O(n)               |
 82 |  **худший случай**: неудачный выбор шага| - |**лучший случай**: массив уже отсортирован в правильном порядке| 
 83 | 
 84 | **Расход памяти:** O(1). Дополнительной памяти не требуется.
 85 | 
 86 | Алгоритм неустойчив.
 87 | 
 88 | ## Counting Sort (сортировка подсчётом)
 89 | Проходимся по массиву и подсчитываем количество вхождений каждого элемента. После проходим по массиву значений и выводим каждое число столько раз, сколько нужно.
 90 | 
 91 | ![counting sort gif](https://gabrielghe.github.io/assets/themes/images/2016-03-09-counting-sort.gif)
 92 | 
 93 | **Асимптотика:**
 94 | 
 95 | сложность в худшем  | сложность в среднем | сложность в лучшем |
 96 | --------------------|---------------------|--------------------|
 97 | O(n)                | O(n)                | O(n)               |
 98 | 
 99 | **Расход памяти:** O(1). Дополнительной памяти не требуется.
100 | 
101 | Алгоритм устойчив. Применение сортировки подсчётом целесообразно лишь тогда, когда массив состоит из целочисленных, положительных чисел.
102 | 
103 | ## Merge Sort (сортировка слиянием)
104 | Исходный массив делится надвое на всё меньшие подмассивы, пока количество элементов в очередных не станет равным 2 или 1. 
105 | Если в подмассиве 2 элемента, то он упорядочивается банальным сравнением. А подмассив из одного элемента по своей сути является упорядоченным. Затем происходит обратный процесс - слияние подмассивов. 
106 | Поскольку подмассивы к этому времени являются упорядоченными, то можем сравнивать лишь элементы, стоящие в их начале.
107 | 
108 | ![merge sort gif](http://gifimage.net/wp-content/uploads/2017/10/merge-sort-gif-5.gif)
109 | 
110 | **Асимптотика:**
111 | 
112 | сложность в худшем  | сложность в среднем | сложность в лучшем |
113 | --------------------|---------------------|--------------------|
114 | O(n log n)          | O(n log n)          | O(n log n)         |
115 | 
116 | **Расход памяти:** O(n). Требует дополнительной памяти, примерно равной размеру исходного массива. Память расходуется на рекурсивный вызов и на постоянное создание вспомогательных подмассивов.
117 | 
118 | Алгоритм устойчив. На «почти отсортированных» массивах работает столь же долго, как на хаотичных.
119 | 
120 | ## Heap Sort (пирамидальная сортировка)
121 | Строим на основе неотсортированного массива так называемую двоичную кучу или пирамиду. В результате получается бинарное дерево каждый узел которого больше предыдущего, тем самым
122 | на вершине дерева оказывается элемент с максимальным значением. Затем вершина дерева переставляется в конец, откуда и будет выстраиваться отсортированный подмассив. А среди оставшихся элементов происходит ряд перестановок с целью восстановить дерево, чтобы в его вершине вновь оказался максимальный элемент из ещё не отсортированной части. 
123 | Таким образом на первом месте постоянно оказывается один из самых "лёгких" элементов, который затем серией перестановок отправляется назад.
124 | 
125 | ![heap sort gif](https://www.fluentcpp.com/wp-content/uploads/2018/01/ezgif-3-734bb0bf98.gif)
126 | 
127 | **Асимптотика:**
128 | 
129 | сложность в худшем  | сложность в среднем | сложность в лучшем |
130 | --------------------|---------------------|--------------------|
131 | O(n log n)          | O(n log n)          | O(n log n)         |
132 | 
133 | **Расход памяти:** O(1). Дополнительной памяти не требуется. Хотя в алгоритме присутствует рекурсивный вызов, но чтобы добраться до конца даже очень большого массива, рекурсий нужно мало, и они моментально закрываются.
134 | 
135 | Алгоритм устойчив. На почти отсортированных массивах работает столь же долго, как и на хаотических данных. Не работает на связанных списках и других структурах памяти последовательного доступа. 
136 | Из-за сложности реализации выигрыш получается только на больших размерах массива.
137 | 
138 | ## TODO List
139 | * Сортировка расческой / Comb sort
140 | * Сортировка вставками / Insertion sort
141 | * Сортировка двоичным деревом / Tree sort
142 | * Гномья сортировка / Gnome sort
143 | * Блочная сортировка / Bucket sort
144 | * Поразрядная сортировка / Radix sort
145 | * Битонная сортировка / Bitonic sort
146 | * реализовать гибридную сортировку
147 | 
148 | 
149 | 
150 | 
151 | 
152 | 
153 | 
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 50;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		D00325F620D4290900D84D0D /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = D00325F520D4290900D84D0D /* main.swift */; };
 11 | 		D00325FD20D429A700D84D0D /* QuickSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D00325FC20D429A700D84D0D /* QuickSort.swift */; };
 12 | 		D00325FF20D42D2B00D84D0D /* SelectionSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D00325FE20D42D2B00D84D0D /* SelectionSort.swift */; };
 13 | 		D003D1B62101D3AA005EA7E6 /* ShellSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D003D1B52101D3AA005EA7E6 /* ShellSort.swift */; };
 14 | 		D0319FC220D5189100217AD1 /* BubleSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0319FC120D5189100217AD1 /* BubleSort.swift */; };
 15 | 		D0319FC420D51E8200217AD1 /* ShakerSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0319FC320D51E8200217AD1 /* ShakerSort.swift */; };
 16 | 		D09348F92115A9B3001859FD /* MergeSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D09348F82115A9B3001859FD /* MergeSort.swift */; };
 17 | 		D09348FB2115B62F001859FD /* HeapSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D09348FA2115B62F001859FD /* HeapSort.swift */; };
 18 | 		D096ACF42107D46E00D247C9 /* CountingSort.swift in Sources */ = {isa = PBXBuildFile; fileRef = D096ACF32107D46E00D247C9 /* CountingSort.swift */; };
 19 | /* End PBXBuildFile section */
 20 | 
 21 | /* Begin PBXCopyFilesBuildPhase section */
 22 | 		D00325F020D4290900D84D0D /* CopyFiles */ = {
 23 | 			isa = PBXCopyFilesBuildPhase;
 24 | 			buildActionMask = 2147483647;
 25 | 			dstPath = /usr/share/man/man1/;
 26 | 			dstSubfolderSpec = 0;
 27 | 			files = (
 28 | 			);
 29 | 			runOnlyForDeploymentPostprocessing = 1;
 30 | 		};
 31 | /* End PBXCopyFilesBuildPhase section */
 32 | 
 33 | /* Begin PBXFileReference section */
 34 | 		D00325F220D4290900D84D0D /* SortingAlgorithms */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = SortingAlgorithms; sourceTree = BUILT_PRODUCTS_DIR; };
 35 | 		D00325F520D4290900D84D0D /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };
 36 | 		D00325FC20D429A700D84D0D /* QuickSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QuickSort.swift; sourceTree = "<group>"; };
 37 | 		D00325FE20D42D2B00D84D0D /* SelectionSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SelectionSort.swift; sourceTree = "<group>"; };
 38 | 		D003D1B52101D3AA005EA7E6 /* ShellSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ShellSort.swift; sourceTree = "<group>"; };
 39 | 		D0319FC120D5189100217AD1 /* BubleSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BubleSort.swift; sourceTree = "<group>"; };
 40 | 		D0319FC320D51E8200217AD1 /* ShakerSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ShakerSort.swift; sourceTree = "<group>"; };
 41 | 		D09348F82115A9B3001859FD /* MergeSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MergeSort.swift; sourceTree = "<group>"; };
 42 | 		D09348FA2115B62F001859FD /* HeapSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HeapSort.swift; sourceTree = "<group>"; };
 43 | 		D096ACF32107D46E00D247C9 /* CountingSort.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CountingSort.swift; sourceTree = "<group>"; };
 44 | /* End PBXFileReference section */
 45 | 
 46 | /* Begin PBXFrameworksBuildPhase section */
 47 | 		D00325EF20D4290900D84D0D /* Frameworks */ = {
 48 | 			isa = PBXFrameworksBuildPhase;
 49 | 			buildActionMask = 2147483647;
 50 | 			files = (
 51 | 			);
 52 | 			runOnlyForDeploymentPostprocessing = 0;
 53 | 		};
 54 | /* End PBXFrameworksBuildPhase section */
 55 | 
 56 | /* Begin PBXGroup section */
 57 | 		D00325E920D4290900D84D0D = {
 58 | 			isa = PBXGroup;
 59 | 			children = (
 60 | 				D00325F420D4290900D84D0D /* SortingAlgorithms */,
 61 | 				D00325F320D4290900D84D0D /* Products */,
 62 | 			);
 63 | 			sourceTree = "<group>";
 64 | 		};
 65 | 		D00325F320D4290900D84D0D /* Products */ = {
 66 | 			isa = PBXGroup;
 67 | 			children = (
 68 | 				D00325F220D4290900D84D0D /* SortingAlgorithms */,
 69 | 			);
 70 | 			name = Products;
 71 | 			sourceTree = "<group>";
 72 | 		};
 73 | 		D00325F420D4290900D84D0D /* SortingAlgorithms */ = {
 74 | 			isa = PBXGroup;
 75 | 			children = (
 76 | 				D00325F520D4290900D84D0D /* main.swift */,
 77 | 				D00325FC20D429A700D84D0D /* QuickSort.swift */,
 78 | 				D00325FE20D42D2B00D84D0D /* SelectionSort.swift */,
 79 | 				D0319FC120D5189100217AD1 /* BubleSort.swift */,
 80 | 				D0319FC320D51E8200217AD1 /* ShakerSort.swift */,
 81 | 				D003D1B52101D3AA005EA7E6 /* ShellSort.swift */,
 82 | 				D096ACF32107D46E00D247C9 /* CountingSort.swift */,
 83 | 				D09348F82115A9B3001859FD /* MergeSort.swift */,
 84 | 				D09348FA2115B62F001859FD /* HeapSort.swift */,
 85 | 			);
 86 | 			path = SortingAlgorithms;
 87 | 			sourceTree = "<group>";
 88 | 		};
 89 | /* End PBXGroup section */
 90 | 
 91 | /* Begin PBXNativeTarget section */
 92 | 		D00325F120D4290900D84D0D /* SortingAlgorithms */ = {
 93 | 			isa = PBXNativeTarget;
 94 | 			buildConfigurationList = D00325F920D4290900D84D0D /* Build configuration list for PBXNativeTarget "SortingAlgorithms" */;
 95 | 			buildPhases = (
 96 | 				D00325EE20D4290900D84D0D /* Sources */,
 97 | 				D00325EF20D4290900D84D0D /* Frameworks */,
 98 | 				D00325F020D4290900D84D0D /* CopyFiles */,
 99 | 			);
100 | 			buildRules = (
101 | 			);
102 | 			dependencies = (
103 | 			);
104 | 			name = SortingAlgorithms;
105 | 			productName = SortingAlgorithms;
106 | 			productReference = D00325F220D4290900D84D0D /* SortingAlgorithms */;
107 | 			productType = "com.apple.product-type.tool";
108 | 		};
109 | /* End PBXNativeTarget section */
110 | 
111 | /* Begin PBXProject section */
112 | 		D00325EA20D4290900D84D0D /* Project object */ = {
113 | 			isa = PBXProject;
114 | 			attributes = {
115 | 				LastSwiftUpdateCheck = 0940;
116 | 				LastUpgradeCheck = 0940;
117 | 				ORGANIZATIONNAME = "MacBook Air";
118 | 				TargetAttributes = {
119 | 					D00325F120D4290900D84D0D = {
120 | 						CreatedOnToolsVersion = 9.4;
121 | 					};
122 | 				};
123 | 			};
124 | 			buildConfigurationList = D00325ED20D4290900D84D0D /* Build configuration list for PBXProject "SortingAlgorithms" */;
125 | 			compatibilityVersion = "Xcode 9.3";
126 | 			developmentRegion = en;
127 | 			hasScannedForEncodings = 0;
128 | 			knownRegions = (
129 | 				en,
130 | 			);
131 | 			mainGroup = D00325E920D4290900D84D0D;
132 | 			productRefGroup = D00325F320D4290900D84D0D /* Products */;
133 | 			projectDirPath = "";
134 | 			projectRoot = "";
135 | 			targets = (
136 | 				D00325F120D4290900D84D0D /* SortingAlgorithms */,
137 | 			);
138 | 		};
139 | /* End PBXProject section */
140 | 
141 | /* Begin PBXSourcesBuildPhase section */
142 | 		D00325EE20D4290900D84D0D /* Sources */ = {
143 | 			isa = PBXSourcesBuildPhase;
144 | 			buildActionMask = 2147483647;
145 | 			files = (
146 | 				D003D1B62101D3AA005EA7E6 /* ShellSort.swift in Sources */,
147 | 				D0319FC420D51E8200217AD1 /* ShakerSort.swift in Sources */,
148 | 				D09348F92115A9B3001859FD /* MergeSort.swift in Sources */,
149 | 				D0319FC220D5189100217AD1 /* BubleSort.swift in Sources */,
150 | 				D096ACF42107D46E00D247C9 /* CountingSort.swift in Sources */,
151 | 				D00325F620D4290900D84D0D /* main.swift in Sources */,
152 | 				D00325FF20D42D2B00D84D0D /* SelectionSort.swift in Sources */,
153 | 				D09348FB2115B62F001859FD /* HeapSort.swift in Sources */,
154 | 				D00325FD20D429A700D84D0D /* QuickSort.swift in Sources */,
155 | 			);
156 | 			runOnlyForDeploymentPostprocessing = 0;
157 | 		};
158 | /* End PBXSourcesBuildPhase section */
159 | 
160 | /* Begin XCBuildConfiguration section */
161 | 		D00325F720D4290900D84D0D /* Debug */ = {
162 | 			isa = XCBuildConfiguration;
163 | 			buildSettings = {
164 | 				ALWAYS_SEARCH_USER_PATHS = NO;
165 | 				CLANG_ANALYZER_NONNULL = YES;
166 | 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
167 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
168 | 				CLANG_CXX_LIBRARY = "libc++";
169 | 				CLANG_ENABLE_MODULES = YES;
170 | 				CLANG_ENABLE_OBJC_ARC = YES;
171 | 				CLANG_ENABLE_OBJC_WEAK = YES;
172 | 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
173 | 				CLANG_WARN_BOOL_CONVERSION = YES;
174 | 				CLANG_WARN_COMMA = YES;
175 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
176 | 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
177 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
178 | 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
179 | 				CLANG_WARN_EMPTY_BODY = YES;
180 | 				CLANG_WARN_ENUM_CONVERSION = YES;
181 | 				CLANG_WARN_INFINITE_RECURSION = YES;
182 | 				CLANG_WARN_INT_CONVERSION = YES;
183 | 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
184 | 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
185 | 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
186 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
187 | 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
188 | 				CLANG_WARN_STRICT_PROTOTYPES = YES;
189 | 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
190 | 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
191 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
192 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
193 | 				CODE_SIGN_IDENTITY = "Mac Developer";
194 | 				COPY_PHASE_STRIP = NO;
195 | 				DEBUG_INFORMATION_FORMAT = dwarf;
196 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
197 | 				ENABLE_TESTABILITY = YES;
198 | 				GCC_C_LANGUAGE_STANDARD = gnu11;
199 | 				GCC_DYNAMIC_NO_PIC = NO;
200 | 				GCC_NO_COMMON_BLOCKS = YES;
201 | 				GCC_OPTIMIZATION_LEVEL = 0;
202 | 				GCC_PREPROCESSOR_DEFINITIONS = (
203 | 					"DEBUG=1",
204 | 					"$(inherited)",
205 | 				);
206 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
207 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
208 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
209 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
210 | 				GCC_WARN_UNUSED_FUNCTION = YES;
211 | 				GCC_WARN_UNUSED_VARIABLE = YES;
212 | 				MACOSX_DEPLOYMENT_TARGET = 10.13;
213 | 				MTL_ENABLE_DEBUG_INFO = YES;
214 | 				ONLY_ACTIVE_ARCH = YES;
215 | 				SDKROOT = macosx;
216 | 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
217 | 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
218 | 			};
219 | 			name = Debug;
220 | 		};
221 | 		D00325F820D4290900D84D0D /* Release */ = {
222 | 			isa = XCBuildConfiguration;
223 | 			buildSettings = {
224 | 				ALWAYS_SEARCH_USER_PATHS = NO;
225 | 				CLANG_ANALYZER_NONNULL = YES;
226 | 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
227 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
228 | 				CLANG_CXX_LIBRARY = "libc++";
229 | 				CLANG_ENABLE_MODULES = YES;
230 | 				CLANG_ENABLE_OBJC_ARC = YES;
231 | 				CLANG_ENABLE_OBJC_WEAK = YES;
232 | 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
233 | 				CLANG_WARN_BOOL_CONVERSION = YES;
234 | 				CLANG_WARN_COMMA = YES;
235 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
236 | 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
237 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
238 | 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
239 | 				CLANG_WARN_EMPTY_BODY = YES;
240 | 				CLANG_WARN_ENUM_CONVERSION = YES;
241 | 				CLANG_WARN_INFINITE_RECURSION = YES;
242 | 				CLANG_WARN_INT_CONVERSION = YES;
243 | 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
244 | 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
245 | 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
246 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
247 | 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
248 | 				CLANG_WARN_STRICT_PROTOTYPES = YES;
249 | 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
250 | 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
251 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
252 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
253 | 				CODE_SIGN_IDENTITY = "Mac Developer";
254 | 				COPY_PHASE_STRIP = NO;
255 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
256 | 				ENABLE_NS_ASSERTIONS = NO;
257 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
258 | 				GCC_C_LANGUAGE_STANDARD = gnu11;
259 | 				GCC_NO_COMMON_BLOCKS = YES;
260 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
261 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
262 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
263 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
264 | 				GCC_WARN_UNUSED_FUNCTION = YES;
265 | 				GCC_WARN_UNUSED_VARIABLE = YES;
266 | 				MACOSX_DEPLOYMENT_TARGET = 10.13;
267 | 				MTL_ENABLE_DEBUG_INFO = NO;
268 | 				SDKROOT = macosx;
269 | 				SWIFT_COMPILATION_MODE = wholemodule;
270 | 				SWIFT_OPTIMIZATION_LEVEL = "-O";
271 | 			};
272 | 			name = Release;
273 | 		};
274 | 		D00325FA20D4290900D84D0D /* Debug */ = {
275 | 			isa = XCBuildConfiguration;
276 | 			buildSettings = {
277 | 				CODE_SIGN_STYLE = Automatic;
278 | 				DEVELOPMENT_TEAM = RN5J25X5C5;
279 | 				PRODUCT_NAME = "$(TARGET_NAME)";
280 | 				SWIFT_VERSION = 4.0;
281 | 			};
282 | 			name = Debug;
283 | 		};
284 | 		D00325FB20D4290900D84D0D /* Release */ = {
285 | 			isa = XCBuildConfiguration;
286 | 			buildSettings = {
287 | 				CODE_SIGN_STYLE = Automatic;
288 | 				DEVELOPMENT_TEAM = RN5J25X5C5;
289 | 				PRODUCT_NAME = "$(TARGET_NAME)";
290 | 				SWIFT_VERSION = 4.0;
291 | 			};
292 | 			name = Release;
293 | 		};
294 | /* End XCBuildConfiguration section */
295 | 
296 | /* Begin XCConfigurationList section */
297 | 		D00325ED20D4290900D84D0D /* Build configuration list for PBXProject "SortingAlgorithms" */ = {
298 | 			isa = XCConfigurationList;
299 | 			buildConfigurations = (
300 | 				D00325F720D4290900D84D0D /* Debug */,
301 | 				D00325F820D4290900D84D0D /* Release */,
302 | 			);
303 | 			defaultConfigurationIsVisible = 0;
304 | 			defaultConfigurationName = Release;
305 | 		};
306 | 		D00325F920D4290900D84D0D /* Build configuration list for PBXNativeTarget "SortingAlgorithms" */ = {
307 | 			isa = XCConfigurationList;
308 | 			buildConfigurations = (
309 | 				D00325FA20D4290900D84D0D /* Debug */,
310 | 				D00325FB20D4290900D84D0D /* Release */,
311 | 			);
312 | 			defaultConfigurationIsVisible = 0;
313 | 			defaultConfigurationName = Release;
314 | 		};
315 | /* End XCConfigurationList section */
316 | 	};
317 | 	rootObject = D00325EA20D4290900D84D0D /* Project object */;
318 | }
319 | 


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:SortingAlgorithms.xcodeproj">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
3 | <plist version="1.0">
4 | <dict>
5 | 	<key>IDEDidComputeMac32BitWarning</key>
6 | 	<true/>
7 | </dict>
8 | </plist>
9 | 


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/project.xcworkspace/xcuserdata/MacBookAir.xcuserdatad/UserInterfaceState.xcuserstate:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ava8/SortingAlgorithms/489a96ca7ffd87ec86c618b3f5357a8c878e44b8/SortingAlgorithms.xcodeproj/project.xcworkspace/xcuserdata/MacBookAir.xcuserdatad/UserInterfaceState.xcuserstate


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/xcuserdata/MacBookAir.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Bucket
3 |    type = "1"
4 |    version = "2.0">
5 | </Bucket>
6 | 


--------------------------------------------------------------------------------
/SortingAlgorithms.xcodeproj/xcuserdata/MacBookAir.xcuserdatad/xcschemes/xcschememanagement.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>SchemeUserState</key>
 6 | 	<dict>
 7 | 		<key>SortingAlgorithms.xcscheme</key>
 8 | 		<dict>
 9 | 			<key>orderHint</key>
10 | 			<integer>0</integer>
11 | 		</dict>
12 | 	</dict>
13 | </dict>
14 | </plist>
15 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/BubleSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  BubleSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 16.06.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func bubleSort<T:Comparable>(_ list: [T]) -> [T] {
12 |     var sortList = list
13 | 
14 |     //алгоритм повторяется n-1 раз, где n - количество элементов в массиве
15 |     for i in 0..<(sortList.count-1) {
16 |         for j in 0..<(sortList.count-1-i) {
17 |             //элемент массива сравнивается с последующим
18 |             if sortList[j] > sortList[j+1] {
19 |                 //элементы меняются местами, таким образом:
20 |                 //"легкие" элементы перемещаются к началу списка
21 |                 //"тяжёлые" элементы - к концу списка
22 |                 sortList.swapAt(j, j+1)
23 |             }
24 |         }
25 |     }
26 |     return sortList
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/CountingSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  CountingSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 25.07.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | // WARNING!
12 | // сортировка подсчётом работает только для массива из целочисленных чисел, которые больше нуля
13 | func countingSort(_ list: [Int]) -> [Int] {
14 |     var sortList = list
15 |     
16 |     // находим максимальный элемент сортируемого массива
17 |     let maxValue = list.max()
18 |     // организуем массив размерностью: максимальный элемент + 1
19 |     var container = Array(repeating: 0, count: maxValue! + 1)
20 |     
21 |     // проверяем на наличие отрицательных значений
22 |     if list.contains(where: {$0 < 0}) {
23 |         print("wrong input array: contains negative nums")
24 |          print("\n")
25 |         return list
26 |     }
27 |     
28 |     // записываем в наш контейнер сколько раз повторяется каждое значение массива
29 |     // например:
30 |     // исходный массив: 0,8,3,1,10,4  максимальный эл-т: 10
31 |     // контейнер, размерностью 10 :
32 |     // [0]1,[1]1,[2]0,[3]1,[4]1,[5]0,[6]0,[7]0,[8]1,[9]0,[10]1
33 |     // ***([индекс]значение)
34 |     list.forEach({container[$0] += 1})
35 |     
36 |     var elem = 0
37 |     // сортируем массив, исходя из значений в "контейнере"
38 |     for i in 0..<maxValue! + 1 {
39 |         for _ in 0..<container[i] {
40 |             sortList[elem] = i
41 |             elem += 1
42 |         }
43 |     }
44 |     return sortList
45 | }
46 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/HeapSort.swift:
--------------------------------------------------------------------------------
  1 | //
  2 | //  HeapSort.swift
  3 | //  SortingAlgorithms
  4 | //
  5 | //  Created by MacBook Air on 04.08.2018.
  6 | //  Copyright © 2018 MacBook Air. All rights reserved.
  7 | //
  8 | 
  9 | import Foundation
 10 | 
 11 | // массив можно отсортировать пирамидальной сортировкой, если
 12 | // на его основе строить сортирующее дерево, известное как куча
 13 | // (двоичная куча, пирамида)
 14 | 
 15 | class BinaryHeap<T: Comparable> {
 16 |     // куча
 17 |     var heap = [T]()
 18 |     // количество элементов в куче
 19 |     var size: Int {
 20 |         get {
 21 |             return heap.count
 22 |         }
 23 |     }
 24 |     var isEmpty: Bool {
 25 |         return heap.isEmpty
 26 |     }
 27 |     
 28 |     // пустая инициализация
 29 |     init() { }
 30 |     // инициализация с преобразованием в кучу массива
 31 |     init(array: [T]) {
 32 |         buildHeap(array)
 33 |     }
 34 |     
 35 |     // добавление элемента
 36 |     func insert(value: T) {
 37 |         heap.append(value)
 38 |         siftUp(size-1)
 39 |     }
 40 |     
 41 |     // удаление минимального элемента
 42 |     func extractMin() -> T? {
 43 |         guard !isEmpty else { return nil }
 44 |         guard size > 1 else { return heap.removeLast() }
 45 |         heap.swapAt(0, size-1)
 46 |         let root = heap.removeLast()
 47 |         siftDown(0)
 48 |         return root
 49 |     }
 50 |     
 51 |     // строим кучу из входного массива
 52 |     private func buildHeap(_ array: [T]) {
 53 |         self.heap = array
 54 |         for i in stride(from: size/2-1, through: 0, by: -1) {
 55 |             siftDown(i)
 56 |         }
 57 |     }
 58 |     
 59 |     // функции восстановления свойств кучи:
 60 |     
 61 |     // sift up - просеивание вверх
 62 |     // используем если значение измененного элемента уменьшается
 63 |     private func siftUp(_ index: Int) {
 64 |         var c = index                       // - child
 65 |         var p = parentIndex(child: c)       // - parent
 66 |         
 67 |         while let parent = parent(child: c)  {
 68 |             guard heap[c] < parent else { break }
 69 |             heap.swapAt(c, p)
 70 |             c = p
 71 |             p = parentIndex(child: c)
 72 |         }
 73 |     }
 74 |     
 75 |     // sift down - просеивание вниз
 76 |     // используем если значение измененного элемента увеличивается
 77 |     private func siftDown(_ index: Int) {
 78 |         var p = index
 79 |         while let max = minChild(parent: p) {
 80 |             guard heap[p] > max.child else { break }
 81 |             heap.swapAt(p, max.index)
 82 |             p = max.index
 83 |         }
 84 |     }
 85 |     
 86 |     // индекс родителя
 87 |     private func parentIndex(child: Int) -> Int {
 88 |         return child / 2 - 1
 89 |     }
 90 |     // индекс левого потомка
 91 |     private func leftIndex(parent: Int) -> Int {
 92 |         return parent * 2 + 1
 93 |     }
 94 |     // индекс правого потомка
 95 |     private func rightIndex(parent: Int) -> Int {
 96 |         return parent * 2 + 2
 97 |     }
 98 |     
 99 |     // возвращает родителя
100 |     private func parent(child: Int) -> T? {
101 |         let p = parentIndex(child: child)
102 |         guard p >= 0 && p < heap.count else { return nil }
103 |         return heap[p]
104 |     }
105 |     // возвращает левого потомка родителя
106 |     private func left(parent: Int) -> T? {
107 |         let l = leftIndex(parent: parent)
108 |         guard l < heap.count else { return nil }
109 |         return heap[l]
110 |     }
111 |     // возвращает правого потомка родителя
112 |     private func right(parent: Int) -> T? {
113 |         let r = rightIndex(parent: parent)
114 |         guard r < heap.count else { return nil }
115 |         return heap[r]
116 |     }
117 |     
118 |     // находим минимальное значение потомка у родителя
119 |     private func minChild(parent: Int) -> (child: T, index: Int)? {
120 |         
121 |         // если существуют оба потомка
122 |         if let x = left(parent: parent), let y = right(parent: parent) {
123 |             return x < y ?
124 |                 (child: x, index: leftIndex(parent: parent)) :
125 |                 (child: y, index: rightIndex(parent: parent))
126 |         } else if let x = left(parent: parent) {
127 |             // если существует только левый потомок
128 |             return (child: x, index: leftIndex(parent: parent))
129 |         } else if let y = right(parent: parent) {
130 |             // если существует только правый потомок
131 |             return (child: y, index: rightIndex(parent: parent))
132 |         }
133 |         
134 |         return nil
135 |     }
136 |     
137 | }
138 | 
139 | // собственно сама пирамидальная сортировка
140 | 
141 | func heapSort<T: Comparable>(_ list: [T]) -> [T] {
142 |     // делаем из массива кучу
143 |     let heap = BinaryHeap(array: list)
144 |     var sortList = [T]()
145 |     
146 |     // обходим нашу кучу
147 |     while let min = heap.extractMin() {
148 |         sortList.append(min)
149 |     }
150 |     
151 |     return sortList
152 | }
153 | 
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 
163 | 
164 | 
165 | 
166 | 
167 | 
168 | 
169 | 
170 | 
171 | 
172 | 
173 | 
174 | 
175 | 
176 | 
177 | 
178 | 
179 | 
180 | 
181 | 
182 | 
183 | 
184 | 
185 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/MergeSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  MergeSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 04.08.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func mergeSort<T:Comparable>(_ list: [T]) -> [T] {
12 |      // если в нашем массиве больше, чем один элемент, то имеет смысл его сортировать
13 |     if list.count > 1 {
14 |         
15 |         // находим средний элемент
16 |         let mid = list.count / 2
17 |         // делим массив на левую часть и правую
18 |         let leftPart = Array(list[0..<mid])
19 |         let rightPart = Array(list[mid...])
20 |         
21 |         // разделяем массив до тех пор пока это возможно
22 |         var dividedLeft = mergeSort(leftPart)
23 |         var dividedRight = mergeSort(rightPart)
24 |         
25 |         // массив уже "слитых" элементов
26 |         var merged = [T]()
27 |         
28 |         // сравниваем разделённые части и "сливаем" в правильном порядке
29 |         while dividedLeft.count > 0 && dividedRight.count > 0 {
30 |             if dividedLeft.first! < dividedRight.first! {
31 |                 merged.append(dividedLeft.removeFirst())
32 |             } else {
33 |                 merged.append(dividedRight.removeFirst())
34 |             }
35 |         }
36 |         return merged + dividedLeft + dividedRight
37 |         
38 |     } else {
39 |         return list
40 |     }
41 | }
42 | 
43 | 
44 | 
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | 
55 | 
56 | 
57 | 
58 | 
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 
69 | 
70 | 
71 | 
72 | 
73 | 
74 | 
75 | 
76 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/QuickSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  QuickSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 15.06.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | 
12 | func quickSort<T:Comparable>(_ list: [T]) -> [T] {
13 |     // если в нашем массиве больше, чем один элемент, то имеет смысл его сортировать
14 |     if list.count > 1 {
15 |         
16 |         //определяем опорный элемент - середина массива
17 |         let pivot = list[0+(list.count - 0)/2]
18 |         
19 |         //создаём массив элементов меньших, чем опорный
20 |         var less:[T] = []
21 |         //создаём массив элементов эквивалентных опорному
22 |         var equal:[T] = []
23 |         //создаём массив элементов больших, чем опроный
24 |         var greater:[T] = []
25 |         
26 |         //проходим по массиву и сортируем элементы по группам
27 |         for element in list {
28 |             if element < pivot {
29 |                 less.append(element)
30 |             } else if element == pivot {
31 |                 equal.append(element)
32 |             } else if element > pivot {
33 |                 greater.append(element)
34 |             }
35 |         }
36 |         return quickSort(less) + equal + quickSort(greater)
37 |     } else {
38 |         return list
39 |     }
40 | }
41 | 
42 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/SelectionSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  SelectionSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 15.06.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func selectionSort<T:Comparable>(_ list: [T]) -> [T] {
12 |     var sortList = list
13 |     
14 |     //ищем минимальный элемент в массиве
15 |     for i in sortList.indices {
16 |         var min = i
17 |         for j in i..<sortList.count {
18 |             if sortList[j] < sortList[min] {
19 |                 min = j
20 |             }
21 |         }
22 |         //меняем местами элементы пока весь массив не будет отсортирован
23 |         if min != i {
24 |             sortList.swapAt(min, i)
25 |         }
26 |     }
27 |     return sortList
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/ShakerSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  ShakerSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 16.06.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func shakerSort<T:Comparable>(_ list: [T]) -> [T] {
12 |     var sortList = list
13 | 
14 |     //левая и правая границы сортируемой области массива
15 |     var leftIndex = 0
16 |     var rightIndex = sortList.count-1
17 |     //флаг наличия перемещений
18 |     var flag : Bool
19 | 
20 |     //пока левая и правая границы цикла не замкнуться
21 |     while leftIndex < rightIndex {
22 |         flag = false
23 |         
24 |         //двигаемся слева направо
25 |         for i in leftIndex..<rightIndex {
26 |             //если следующий элемент меньше текущего
27 |             if sortList[i] > sortList[i+1] {
28 |                 //меняем их местами
29 |                 sortList.swapAt(i+1, i)
30 |                 //перемещения есть
31 |                 flag = true
32 |             }
33 |         }
34 |         //сдвигаем правую границу на предыдущий элемент
35 |         rightIndex -= 1
36 |         
37 |         //проверяем есть ли премещения или массив уже отсротирован
38 |         if flag == false {break}
39 |         
40 |         //двигаемся справа налево
41 |         for i in (leftIndex..<rightIndex).reversed() {
42 |             //если предыдущий элемент больше текущего
43 |             if sortList[i] > sortList[i+1] {
44 |                 //меняем их местами
45 |                 sortList.swapAt(i, i+1)
46 |                 //перемещения есть
47 |                 flag = true
48 |             }
49 |         }
50 |         //сдвигаем левую границу на следующий элемент
51 |         leftIndex += 1
52 |         
53 |         //проверяем есть ли премещения или массив уже отсротирован
54 |         if flag == false {break}
55 |     }
56 |     return sortList
57 | }
58 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/ShellSort.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  ShellSort.swift
 3 | //  SortingAlgorithms
 4 | //
 5 | //  Created by MacBook Air on 20.07.2018.
 6 | //  Copyright © 2018 MacBook Air. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func shellSort<T:Comparable>(_ list: [T]) -> [T] {
12 |     var sortList = list
13 |     
14 |     //сравнивать будем элементы, находящиеся друг от друга на некотором расстоянии
15 |     var step = sortList.count/2
16 |     
17 |     // пока шаг не будет равен 1
18 |     while step > 0 {
19 |         //разбиваем исходный массив на группы из элементов отстоящих друг от друга на шаг
20 |         for i in step..<sortList.count {
21 |             //значение первого элемента из пары для сравнения
22 |             let value = sortList[i]
23 |             var j = i
24 |             
25 |             while j >= step && sortList[j-step] > value {
26 |                 sortList[j] = sortList[j-step]
27 |                 j -= step
28 |             }
29 |             //после сравнения меняем местами элементы
30 |             sortList[j] = value
31 |         }
32 |         //сокращаем шаг, тем самым уменьшая количество групп
33 |         step /= 2
34 |     }
35 |     return sortList
36 | }
37 | 


--------------------------------------------------------------------------------
/SortingAlgorithms/main.swift:
--------------------------------------------------------------------------------
  1 | //
  2 | //  main.swift
  3 | //  SortingAlgorithms
  4 | //
  5 | //  Created by MacBook Air on 15.06.2018.
  6 | //  Copyright © 2018 MacBook Air. All rights reserved.
  7 | //
  8 | 
  9 | import Foundation
 10 | 
 11 | var list1 = [1,9,4,5,1,0]
 12 | var list2 = [9,3,-7,0,3]
 13 | var list3 = [1,-2,3,-4,5,6,7,-8,9,10]
 14 | var list4 = [10,9,8,7,6,5,4,3,2,1]
 15 | var list5 = [0,1,2,3,4]
 16 | var tmp = [356, 876, 0, 4, 378, 45, 23, 100, 36, 5, 1, 10, 67, 456, 342, 35, 21, 34, 68, 567, 234, 34, 1098]
 17 | 
 18 | //создание рандомного массива пользовательского размера
 19 | //print("Size of array: ", terminator:"");
 20 | //let size = Int(readLine()!)!;
 21 | //var arr = [UInt32]();
 22 | //
 23 | //for _ in 1 ... size {
 24 | //    arr.append(arc4random_uniform(100));
 25 | //}
 26 | 
 27 | 
 28 | // быстрые тесты сортировки
 29 | 
 30 | print("быстрая сортировка:")
 31 | print("исходный массив: \(list3)")
 32 | print("отсортированный массив: \(quickSort(list3))")
 33 | print("\n")
 34 | print("сортировка выбором:")
 35 | print("исходный массив: \(list3)")
 36 | print("отсортированный массив: \(selectionSort(list3))")
 37 | print("\n")
 38 | print("пузырьковая сортировка:")
 39 | print("исходный массив: \(list3)")
 40 | print("отсортированный массив: \(bubleSort(list3))")
 41 | print("\n")
 42 | print("шейкерная сортировка:")
 43 | print("исходный массив: \(list3)")
 44 | print("отсортированный массив: \(shakerSort(list3))")
 45 | print("\n")
 46 | print("сортировка Шелла:")
 47 | print("исходный массив: \(list3)")
 48 | print("отсортированный массив: \(shellSort(list3))")
 49 | print("\n")
 50 | print("сортировка подсчётом:")
 51 | print("исходный массив: \(list3)")
 52 | print("отсортированный массив: \(countingSort(list2))")
 53 | print("\n")
 54 | print("сортировка слиянием:")
 55 | print("исходный массив: \(list3)")
 56 | print("отсортированный массив: \(mergeSort(list3))")
 57 | print("\n")
 58 | print("пирамидальная сортировка:")
 59 | print("исходный массив: \(list3)")
 60 | print("отсортированный массив: \(heapSort(list3))")
 61 | print("\n")
 62 |  
 63 | 
 64 | // временные тесты для сортировок
 65 | /*
 66 | 
 67 | func runningTime<T>(f: @autoclosure () -> T) -> (result:T, duration: String) {
 68 |     let startTime = CFAbsoluteTimeGetCurrent()
 69 |     let result = f()
 70 |     let endTime = CFAbsoluteTimeGetCurrent()
 71 |     return (result, "время работы \(endTime - startTime) секунд")
 72 | }
 73 | 
 74 | var oneHundredArray: [Int] = []
 75 | for _ in 0...99 {
 76 |     oneHundredArray.append(Int(arc4random_uniform(100)))
 77 | }
 78 | var oneThousnadArray: [Int] = []
 79 | for _ in 0...999 {
 80 |     oneThousnadArray.append(Int(arc4random_uniform(100)))
 81 | }
 82 | var oneMillionArray: [Int] = []
 83 | for _ in 0...999999 {
 84 |     oneMillionArray.append(Int(arc4random_uniform(100)))
 85 | }
 86 | 
 87 | print("тесты для массивов с 100 элементов")
 88 | print("\n")
 89 | 
 90 | print("быстрая сортировка:")
 91 | print(runningTime(f: quickSort(oneHundredArray)).duration)
 92 | print("сортировка выбором:")
 93 | print(runningTime(f: selectionSort(oneHundredArray)).duration)
 94 | print("пузырьковая сортировка:")
 95 | print(runningTime(f: bubleSort(oneHundredArray)).duration)
 96 | print("шейкерная сортировка:")
 97 | print(runningTime(f: shakerSort(oneHundredArray)).duration)
 98 | print("сортировка Шелла:")
 99 | print(runningTime(f: shellSort(oneHundredArray)).duration)
100 | print("сортировка подсчётом:")
101 | print(runningTime(f: countingSort(oneHundredArray)).duration)
102 | print("сортировка слиянием:")
103 | print(runningTime(f: mergeSort(oneHundredArray)).duration)
104 | print("пирамидальная сортировка:")
105 | print(runningTime(f: heapSort(oneHundredArray)).duration)
106 | print("\n")
107 | 
108 | print("тесты для массивов с 1000 элементов")
109 | print("\n")
110 | 
111 | print("быстрая сортировка:")
112 | print(runningTime(f: quickSort(oneThousnadArray)).duration)
113 | print("сортировка выбором:")
114 | print(runningTime(f: selectionSort(oneThousnadArray)).duration)
115 | print("пузырьковая сортировка:")
116 | print(runningTime(f: bubleSort(oneThousnadArray)).duration)
117 | print("шейкерная сортировка:")
118 | print(runningTime(f: shakerSort(oneThousnadArray)).duration)
119 | print("сортировка Шелла:")
120 | print(runningTime(f: shellSort(oneThousnadArray)).duration)
121 | print("сортировка подсчётом:")
122 | print(runningTime(f: countingSort(oneThousnadArray)).duration)
123 | print("сортировка слиянием:")
124 | print(runningTime(f: mergeSort(oneThousnadArray)).duration)
125 | print("пирамидальная сортировка:")
126 | print(runningTime(f: heapSort(oneThousnadArray)).duration)
127 | print("\n")
128 | 
129 | print("тесты для массивов с 1 000 000 элементов")
130 | print("\n")
131 | 
132 | print("быстрая сортировка:")
133 | print(runningTime(f: quickSort(oneMillionArray)).duration)
134 | print("сортировка Шелла:")
135 | print(runningTime(f: shellSort(oneMillionArray)).duration)
136 | print("сортировка подсчётом:")
137 | print(runningTime(f: countingSort(oneMillionArray)).duration)
138 | print("пирамидальная сортировка:")
139 | print(runningTime(f: heapSort(oneMillionArray)).duration)
140 | print("сортировка слиянием:")
141 | print(runningTime(f: mergeSort(oneMillionArray)).duration)
142 | print("шейкерная сортировка:")
143 | print(runningTime(f: shakerSort(oneMillionArray)).duration)
144 | print("сортировка выбором:")
145 | print(runningTime(f: selectionSort(oneMillionArray)).duration)
146 | print("пузырьковая сортировка:")
147 | print(runningTime(f: bubleSort(oneMillionArray)).duration)
148 | print("\n")
149 | 
150 | */
151 | 
152 | 
153 | 
154 | 
155 | 
156 | 


--------------------------------------------------------------------------------