Sorting Techniques¶

Списки Python мають вбудований метод list.sort() , який змінює список на місці. Існує також вбудована функція sorted() , яка створює новий відсортований список із ітерованого.

У цьому документі ми досліджуємо різні техніки сортування даних за допомогою Python.

Основи сортування¶

Просте сортування за зростанням дуже просте: просто викличте функцію sorted() . Він повертає новий відсортований список:

>>> sorted([5, 2, 3, 1, 4]) [1, 2, 3, 4, 5] 

Ви також можете використовувати метод list.sort() . Він змінює список на місці (і повертає None , щоб уникнути плутанини). Зазвичай це менш зручно, ніж sorted() , але якщо вам не потрібен оригінальний список, це трохи ефективніше.

>>> a = [5, 2, 3, 1, 4] >>> a.sort() >>> a [1, 2, 3, 4, 5] 

Ще одна відмінність полягає в тому, що метод list.sort() визначено лише для списків. На відміну від цього, функція sorted() приймає будь-яку ітерацію.

>>> sorted(1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'>) [1, 2, 3, 4, 5] 

Ключові функції¶

І list.sort() , і sorted() мають параметр key для вказівки функції (або іншого виклику), яка буде викликана для кожного елемента списку перед проведенням порівнянь.

Наприклад, ось порівняння рядків без урахування регістру:

>>> sorted("This is a test string from Andrew".split(), key=str.casefold) ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This'] 

Значення параметра key має бути функцією (або іншою можливістю виклику), яка приймає один аргумент і повертає ключ для використання в цілях сортування. Ця техніка є швидкою, оскільки ключова функція викликається рівно один раз для кожного вхідного запису.

Загальним шаблоном є сортування складних об’єктів за допомогою деяких індексів об’єктів як ключів. Наприклад:

>>> student_tuples = [ . ('john', 'A', 15), . ('jane', 'B', 12), . ('dave', 'B', 10), . ] >>> sorted(student_tuples, key=lambda student: student[2]) # sort by age [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Така ж техніка працює для об’єктів з іменованими атрибутами. Наприклад:

>>> class Student: . def __init__(self, name, grade, age): . self.name = name . self.grade = grade . self.age = age . def __repr__(self): . return repr((self.name, self.grade, self.age)) >>> student_objects = [ . Student('john', 'A', 15), . Student('jane', 'B', 12), . Student('dave', 'B', 10), . ] >>> sorted(student_objects, key=lambda student: student.age) # sort by age [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Objects with named attributes can be made by a regular class as shown above, or they can be instances of dataclass or a named tuple .

Operator Module Functions and Partial Function Evaluation¶

The key function patterns shown above are very common, so Python provides convenience functions to make accessor functions easier and faster. The operator module has itemgetter() , attrgetter() , and a methodcaller() function.

Використовуючи ці функції, наведені вище приклади стають простішими та швидшими:

>>> from operator import itemgetter, attrgetter >>> sorted(student_tuples, key=itemgetter(2)) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] >>> sorted(student_objects, key=attrgetter('age')) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Функції модуля оператора дозволяють сортувати кілька рівнів. Наприклад, щоб відсортувати за класом, а потім за віком:

>>> sorted(student_tuples, key=itemgetter(1,2)) [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)] >>> sorted(student_objects, key=attrgetter('grade', 'age')) [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)] 

The functools module provides another helpful tool for making key-functions. The partial() function can reduce the arity of a multi-argument function making it suitable for use as a key-function.

>>> from functools import partial >>> from unicodedata import normalize >>> names = 'Zoë Åbjørn Núñez Élana Zeke Abe Nubia Eloise'.split() >>> sorted(names, key=partial(normalize, 'NFD')) ['Abe', 'Åbjørn', 'Eloise', 'Élana', 'Nubia', 'Núñez', 'Zeke', 'Zoë'] >>> sorted(names, key=partial(normalize, 'NFC')) ['Abe', 'Eloise', 'Nubia', 'Núñez', 'Zeke', 'Zoë', 'Åbjørn', 'Élana'] 

Висхідний і спадний¶

І list.sort() , і sorted() приймають параметр reverse із логічним значенням. Це використовується для позначення сортування за спаданням. Наприклад, щоб отримати дані про студентів у зворотному порядку віку:

>>> sorted(student_tuples, key=itemgetter(2), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] >>> sorted(student_objects, key=attrgetter('age'), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 

Стійкість сортування та складні сорти¶

Сортування гарантовано буде стабільним. Це означає, що коли кілька записів мають однаковий ключ, їхній початковий порядок зберігається.

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >>> sorted(data, key=itemgetter(0)) [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)] 

Зверніть увагу, як два записи для blue зберігають свій початковий порядок, тому (‘blue’, 1) гарантовано передує (‘blue’, 2) .

Ця чудова властивість дозволяє вам створювати складні сорти за допомогою серії кроків сортування. Наприклад, щоб відсортувати дані студента за зменшенням оцінки, а потім за зростанням віку, спочатку виконайте сортування за віком, а потім знову за допомогою оцінки:

>>> s = sorted(student_objects, key=attrgetter('age')) # sort on secondary key >>> sorted(s, key=attrgetter('grade'), reverse=True) # now sort on primary key, descending [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Це можна абстрагувати у функцію-обгортку, яка може брати список і кортежі полів і впорядковувати їх, щоб сортувати їх за кілька проходів.

>>> def multisort(xs, specs): . for key, reverse in reversed(specs): . xs.sort(key=attrgetter(key), reverse=reverse) . return xs >>> multisort(list(student_objects), (('grade', True), ('age', False))) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Алгоритм Timsort, що використовується в Python, ефективно виконує багаторазове сортування, оскільки він може використовувати будь-яке впорядкування, яке вже є в наборі даних.

Decorate-Sort-Undecorate¶

Ця ідіома називається Decorate-Sort-Undecorate після трьох кроків:

• По-перше, початковий список прикрашається новими значеннями, які контролюють порядок сортування.
• По-друге, оформлений список сортується.
• Нарешті, декорації видаляються, створюючи список, який містить лише початкові значення в новому порядку.

Наприклад, щоб відсортувати дані студента за класом за допомогою підходу DSU:

>>> decorated = [(student.grade, i, student) for i, student in enumerate(student_objects)] >>> decorated.sort() >>> [student for grade, i, student in decorated] # undecorate [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 

Ця ідіома працює, тому що кортежі порівнюються лексикографічно; порівнюються перші предмети; якщо вони однакові, то порівнюються другі елементи і так далі.

Не обов’язково в усіх випадках включати індекс i в оформлений список, але це дає дві переваги:

• Сортування є стабільним — якщо два елементи мають однаковий ключ, їхній порядок буде збережено у відсортованому списку.
• Оригінальні елементи не обов’язково мають бути порівнянними, тому що порядок оформлених кортежів визначатиметься щонайбільше першими двома елементами. Так, наприклад, вихідний список може містити комплексні числа, які неможливо відсортувати безпосередньо.

Інша назва цієї ідіоми — перетворення Шварца, на честь Рендала Л. Шварца, який популяризував її серед програмістів на Perl.

Тепер, коли сортування Python надає ключові функції, ця техніка не часто потрібна.

Comparison Functions¶

Unlike key functions that return an absolute value for sorting, a comparison function computes the relative ordering for two inputs.

For example, a balance scale compares two samples giving a relative ordering: lighter, equal, or heavier. Likewise, a comparison function such as cmp(a, b) will return a negative value for less-than, zero if the inputs are equal, or a positive value for greater-than.

It is common to encounter comparison functions when translating algorithms from other languages. Also, some libraries provide comparison functions as part of their API. For example, locale.strcoll() is a comparison function.

To accommodate those situations, Python provides functools.cmp_to_key to wrap the comparison function to make it usable as a key function:

sorted(words, key=cmp_to_key(strcoll)) # locale-aware sort order 

Обривки¶

• For locale aware sorting, use locale.strxfrm() for a key function or locale.strcoll() for a comparison function. This is necessary because «alphabetical» sort orderings can vary across cultures even if the underlying alphabet is the same.
• Параметр reverse усе ще підтримує стабільність сортування (щоб записи з однаковими ключами зберігали вихідний порядок). Цікаво, що цей ефект можна моделювати без параметра, використовуючи двічі вбудовану функцію reversed() :

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >>> standard_way = sorted(data, key=itemgetter(0), reverse=True) >>> double_reversed = list(reversed(sorted(reversed(data), key=itemgetter(0)))) >>> assert standard_way == double_reversed >>> standard_way [('red', 1), ('red', 2), ('blue', 1), ('blue', 2)] 

>>> Student.__lt__ = lambda self, other: self.age  other.age >>> sorted(student_objects) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

>>> students = ['dave', 'john', 'jane'] >>> newgrades = 'john': 'F', 'jane':'A', 'dave': 'C'> >>> sorted(students, key=newgrades.__getitem__) ['jane', 'dave', 'john'] 

Partial Sorts¶

Some applications require only some of the data to be ordered. The standard library provides several tools that do less work than a full sort:

• min() and max() return the smallest and largest values, respectively. These functions make a single pass over the input data and require almost no auxiliary memory.
• heapq.nsmallest() and heapq.nlargest() return the n smallest and largest values, respectively. These functions make a single pass over the data keeping only n elements in memory at a time. For values of n that are small relative to the number of inputs, these functions make far fewer comparisons than a full sort.
• heapq.heappush() and heapq.heappop() create and maintain a partially sorted arrangement of data that keeps the smallest element at position 0 . These functions are suitable for implementing priority queues which are commonly used for task scheduling.

Table of Contents

• Sorting Techniques
  • Основи сортування
  • Ключові функції
  • Operator Module Functions and Partial Function Evaluation
  • Висхідний і спадний
  • Стійкість сортування та складні сорти
  • Decorate-Sort-Undecorate
  • Comparison Functions
  • Обривки
  • Partial Sorts

  Алгоритми сортування в теорії та на практиці

  Сортування — одне із базових видів активності чи дій, виконуваних над предметами. Ще в дитинстві дітей вчать сортувати, розвиваючи мислення. Комп’ютери та програми теж не виняток. Існує безліч алгоритмів. Пропоную подивитися, які є та як вони працюють. Крім того, раптом вас запитають про одного з них на співбесіді?

  Вступ

  Сортування елементів – одна з категорій алгоритмів, до яких розробник має звикнути. Якщо колись, коли я навчався, інформатика не сприймалася так серйозно, то зараз уже в школі повинні вміти реалізовувати алгоритми сортування та розуміти їх. Базові алгоритми, найпростіші, реалізовані за допомогою циклу for . Звичайно, щоб відсортувати колекцію елементів, наприклад, масив, потрібно по цій колекції якось пройти. Наприклад:

  int[] array = 10, 2, 10, 3, 1, 2, 5>; for (int i = 0; i  array.length; i++)  System.out.println(array[i]); >

  Що можна сказати про цю ділянку коду? Ми маємо цикл, у якому змінюємо значення індексу ( int i ) з 0 до останнього елемента у масиві. Фактично ми просто беремо кожен елемент у масиві і друкуємо його вміст. Чим більше елементів у масиві, тим довше виконуватиметься код. Тобто, якщо n — кількість елементів, при n=10 програма виконуватиметься довше, ніж за n=5, у 2 рази. Коли в нашій програмі є один цикл, час виконання зростає лінійно: що більше елементів, то довше виконання. Виходить, що алгоритм коду працює за лінійний час (n). У разі говорять, що ” складність алгоритму ” дорівнює O(n). Це позначення ще називають “велике” або “асимптотичне поведінка”. Але можна запам’ятати просто “складність алгоритму”.

  Найпростіше сортування (Bubble Sort)

  Отже, ми маємо масив і можемо ним ітеруватися. Чудово. Давайте спробуємо його відсортувати за зростанням. Що це означає для нас? Це означає, що маючи два елементи (наприклад, a=6, b=5), ми повинні переставити місцями a та b, якщо a більше ніж b (якщо a > b). Що для нас це означає при роботі з колекцією за індексом (як у випадку з масивом)? Це означає, якщо елемент з індексом а більше, ніж елемент з індексом b, (array[a] > array[b]), такі елементи треба поміняти місцями. Зміну місць часто називають swap. Існують різні способи зміни місць. Але ми використовуємо простий, зрозумілий код, що легко запам’ятовується:

  private void swap(int[] array, int ind1, int ind2)  int tmp = array[ind1]; array[ind1] = array[ind2]; array[ind2] = tmp; >

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); for (int i = 1; i  array.length; i++)  if (array[i]  array[i - 1])  swap(array, i, i-1); > > System.out.println(Arrays.toString(array));

  Як бачимо, елементи дійсно помінялися місцями. Ми почали із одного елемента, т.к. якщо масив буде всього з одного елемента, вираз 1 < 1 не поверне true і тим самим ми убезпечимо себе від випадків масиву в один елемент або зовсім без них, а код буде виглядати краще. Але наш підсумковий масив не відсортовано однаково, т.к. за один прохід не вдається відсортувати всіх. Прийде додати ще цикл, в якому ми будемо виконувати проходи один за одним до тих пір, поки не отримаємо відсортований масив:

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); boolean needIteration = true; while (needIteration)  needIteration = false; for (int i = 1; i  array.length; i++)  if (array[i]  array[i - 1])  swap(array, i, i-1); needIteration = true; > > > System.out.println(Arrays.toString(array));

  Сортування вибором (Selection Sort)

  Інше сортування – сортування вибором. Вона також має квадратичну складність, але про це трохи згодом. Отже, ідея проста. Кожен прохід вибиратиме найменший елемент і зміщувати його на початок. При цьому кожен новий прохід починати зрушуючи праворуч, тобто перший прохід – з першого елемента, другий прохід – з другого. Виглядати це буде так:

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); for (int left = 0; left  array.length; left++)  int minInd = left; for (int i = left; i  array.length; i++)  if (array[i]  array[minInd])  minInd = i; > > swap(array, left, minInd); > System.out.println(Arrays.toString(array));

  Сортування вставками (Insertion Sort)

  Сортування вставками також має квадратичну складність, тому що у нас знову цикл у циклі. У чому на відміну від сортування вибором? Дане сортування є “стійким”. Це означає, що однакові елементи змінять свій порядок. Поодинокі з погляду характеристики, за якою ми сортуємо.

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); for (int left = 0; left  array.length; left++)  // Витягуємо значення елемента int value = array[left]; // Переміщаємося елементами, які перед витягнутим елементом int i = left - 1; for (; i >= 0; i--)  // Якщо витягли менше значення — пересуваємо більший елемент далі if (value  array[i])  array[i + 1] = array[i]; > else  // Якщо витягнутий елемент більше - зупиняємось break; > > // У місце, що звільнилося, вставляємо витягнуте значення array[i + 1] = value; > System.out.println(Arrays.toString(array));

  Човникове сортування (Shuttle Sort)

  Серед простих сортувань є ще одне – човникове сортування. Але мені більше подобається шатл сорт. Мені здається, ми рідко говоримо про космічні човники, а човниковий у нас скоріше біг. Тому простіше уявити, як у космос запускаються шатли. Ось вам асоціація із цим алгоритмом. У чому полягає суть алгоритму? Суть алгоритму в тому, що ми ітеруємося ліворуч, при цьому при виконанні swap елементів ми виконуємо перевірку всіх інших елементів, які залишабося позаду, чи не потрібно повторити swap.

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); for (int i = 1; i  array.length; i++)  if (array[i]  array[i - 1])  swap(array, i, i - 1); for (int z = i - 1; (z - 1) >= 0; z--)  if (array[z]  array[z - 1])  swap(array, z, z - 1); > else  break; > > > > System.out.println(Arrays.toString(array));

  Сортування Шелла

  Ще одним простим сортуванням є сортування Шелла. Суть її схожа на сортування бульбашкою, але кожну ітерацію ми маємо різний проміжок між елементами, що порівнюються. Кожну ітерацію він зменшується вдвічі. Ось приклад реалізації:

  int[] array = 10, 2, 10, 3, 1, 2, 5>; System.out.println(Arrays.toString(array)); // Вираховуємо проміжок між елементами, що перевіряються. int gap = array.length / 2; // Поки що різниця між елементами є while (gap >= 1)  for (int right = 0; right  array.length; right++)  // Зміщуємо правий покажчик, доки зможемо знайти такий, що // між ним та елементом до нього не буде потрібного проміжку for (int c = right - gap; c >= 0; c -= gap)  if (array[c] > array[c + gap])  swap(array, c, c + gap); > > > // Перераховуємо розрив gap = gap / 2; > System.out.println(Arrays.toString(array));

  Сортування злиттям (merge sort)

  Крім зазначених простих сортувань є сортування і складніше. Наприклад, сортування злиттям. По-перше, нам допоможе прийде рекурсія. По-друге, складність у нас буде вже не квадратична, як ми з вами звикли. Складність даного алгоритму – логарифмічна. Записується як O(n log n). Отже, зробимо це. Спочатку напишемо рекурсивний виклик методу сортування:

  public static void mergeSort(int[] source, int left, int right)  // Виберемо роздільник, тобто. розділимо навпіл вхідний масив int delimiter = left + ((right - left) / 2) + 1; // Виконаємо рекурсивно цю функцію для двох половинок (якщо зможемо розбити ( if (delimiter > 0 && right > (left + 1))  mergeSort(source, left, delimiter - 1); mergeSort(source, delimiter, right); > >

  Тепер, давайте до нього додамо основну дію. Ось приклад нашого суперметоду з реалізацією:

  public static void mergeSort(int[] source, int left, int right)  // Виберемо роздільник, тобто. розділимо навпіл вхідний масив int delimiter = left + ((right - left) / 2) + 1; // Виконаємо рекурсивно цю функцію для двох половинок (якщо зможемо розбити ( if (delimiter > 0 && right > (left + 1))  mergeSort(source, left, delimiter - 1); mergeSort(source, delimiter, right); > // Створюємо тимчасовий масив із потрібним розміром int[] buffer = new int[right - left + 1]; // Починаючи від зазначеної лівої межі йдемо по кожному елементу int cursor = left; for (int i = 0; i  buffer.length; i++)  // Ми використовуємо delimeter щоб вказувати на елемент з правої частини // Якщо delimeter > right, отже, у правій частині не залишилося недоданих елементів if (delimiter > right || source[cursor] > source[delimiter])  buffer[i] = source[cursor]; cursor++; > else  buffer[i] = source[delimiter]; delimiter++; > > System.arraycopy(buffer, 0, source, left, buffer.length); >

  Сортування підрахунком (Counting Sort) та Порозрядне сортування (Radix Sort)

  Іншим цікавим алгоритмом сортування є сортування підрахунком (Counting Sort). Алгоритмічна складність у разі буде O(n+k), де n — кількість елементів, а k — максимальне значення елемента. Є з алгоритмом одна невдача: нам потрібно знати мінімальне та максимальне значення у масиві. Ось приклад реалізації сортування підрахунком:

  public static int[] countingSort(int[] theArray, int maxValue)  // Масив із "лічильниками" розміром від 0 до максимального значення int numCounts[] = new int[maxValue + 1]; // У відповідному осередку (індекс = значення) збільшуємо лічильник for (int num : theArray)  numCounts[num]++; > // Підготовляємо масив для відсортованого результату int[] sortedArray = new int[theArray.length]; int currentSortedIndex = 0; // йдемо масивом з "лічильниками" for (int n = 0; n  numCounts.length; n++)  int count = numCounts[n]; // йдемо за кількістю значень for (int k = 0; k  count; k++)  sortedArray[currentSortedIndex] = n; currentSortedIndex++; > > return sortedArray; >

  Як ми розуміємо, дуже незручно, коли ми повинні знати наперед мінімальне та максимальне значення. І тут є інший алгоритм – Radix Sort. Я тут наведу алгоритм лише візуально. Реалізацію див. у матеріалах:

  Швидке сортування Java (Quick Sort)

  Ну і на солодке — один із найвідоміших алгоритмів: швидке сортування. Вона має алгоритмічну складність, тобто маємо O(n log n). Це сортування ще називають сортуванням Хоара. Цікаво, що алгоритм придумали Хоар під час його перебування в Радянському Союзі, де він навчався в Московському університеті комп’ютерного перекладу і займався розробкою російсько-англійського розмовника. А ще даний алгоритм у більш складній реалізації використовується в Arrays.sort Java. А що із Collections.sort? Пропоную подивитися самостійно, як вони сортуються “під капотом”. Отже, код:

  public static void quickSort(int[] source, int leftBorder, int rightBorder)  int leftMarker = leftBorder; int rightMarker = rightBorder; int pivot = source[(leftMarker + rightMarker) / 2]; do  // Рухаємо лівий маркер зліва направо поки що елемент менше, ніж pivot while (source[leftMarker]  pivot)  leftMarker++; > // Рухаємо правий маркер, поки елемент більше ніж pivot while (source[rightMarker] > pivot)  rightMarker--; > // Перевіримо, чи не потрібно обміняти місцями елементи, на які вказують маркери if (leftMarker  rightMarker)  // Лівий маркер буде менше правого, тільки якщо ми повинні виконати swap if (leftMarker  rightMarker)  int tmp = source[leftMarker]; source[leftMarker] = source[rightMarker]; source[rightMarker] = tmp; > // Зрушуємо маркери, щоб отримати нові кордони leftMarker++; rightMarker--; > > while (leftMarker  rightMarker); // Виконуємо рекурсивно для елементів if (leftMarker  rightBorder)  quickSort(source, leftMarker, rightBorder); > if (leftBorder  rightMarker)  quickSort(source, leftBorder, rightMarker); > >

  Підсумок

  Вище ми розглянули “джентльменський” набір алгоритмів сортування, реалізованих на Java. Алгоритми взагалі штука корисна як з прикладної точки зору, так і з точки зору розвитку мислення. Деякі з них простіші, деякі складніші. За якимись розумні люди захищали різні роботи на ступені, а за іншими писали товсті-товсті книги. Сподіваюся, прикладений до статті матеріал дозволить вам дізнатися ще більше, оскільки це оглядова стаття, яка і так вийшла важкою. І мета її – дати невеликий вступ. Про введення в алгоритми можна також прочитати ознайомитися з книгою ” Грочаємо Алгоріми ” . Також мені подобається плейлист від Jack Brown – AQA Decision 1 1.01 Tracing an Algorithm . Заради інтересу можна побачити візуалізацію алгоритмів на sorting.atі visualgo.net . Ну і весь Youtube до ваших послуг.

  Характеристика постраждалих відповідно до кольорових позначок при первинному сортуванні

  з футболу (надалі Концепція), схваленої розпорядженням Кабінету Міністрів України від 7 травня 2009 р. № 563-р, особи, що потребують медичної допомоги, поділяють на чотири сортувальні категорії за станом здоров’я та потребою в однорідних лікувальних та евакуаційних заходах відповідно до медичних показань. Кожній категорії відповідає певний колір (табл. 6.1).

  Таблиця 6.1. Кольорові позначення при медичному сортуванні

  Стан здоров’я постраждалого

  Загроза для життя.

  Безпосередня загроза для життя може бути усунена за умови негайного надання медичної допомоги, евакуації та подальшого лікування

  Надання негайної медичної допомоги та госпіталізація в першу чергу

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

  Надання медичної допомоги та госпіталізація в другу чергу

  Легко поранений або хворий. Незначні ушкодження здоров’я із задовільним станом постраждалого з можливістю очікування отримання медичної допомоги в довший термін

  Надання допомоги у третю чергу з подальшим (амбулаторним) лікуванням

  Немає шансів на життя. Ушкодження здоров’я постраждалого, що не сумісні 3 життям

  Надання домедичної допомоги живому. Догляд. Паліативна медична допомога. Якщо людина жива, її евакуйовують у стаціонар у другу чергу

  Ідентифікація. Констатація смерті

  Етапність дій працівників ДСНС у процедурі сортування та організації ліквідації медичних наслідків масових випадків

  Перші прибулі на місце подій рятувальники Державної служби надзвичайних ситуацій здійснюють вступне, а пізніше і первинне сортування. Вступне сортування полягає у визначенні показників життєдіяльності, які передбачає відповідна сортувальна система, та визначення пріоритету в евакуації. Після оцінки ситуації (розміри надзвичайної ситуації, кількість постраждалих, рельєф місцевості, місця під’їзду, розвертання різних служб) рятувальники здійснюють вступне сортування і виводять постраждалих, які самостійно ходять. Відповідно до більшості сортувальних систем такі постраждалі належать до легко уражених – “зелених”. Вступне сортування полягає в тому, що у вогнищі ураження працівник ДСНС голосно оголошує про прибуття фахівців для надання допомоги кожному постраждалому, а після цього голосно дає команду: “Всі, хто може самостійно ходити, виходьте” і вказує місце виходу. У темному задимленому приміщенні вказує ліхтариком місце виходу. Постраждалих зустрічають і виводять в безпечну зону, де контролюють їх загальний стан здоров’я, надають психологічну допомогу, оскільки більшість з них мають психологічні порушення.

  Після обстеження місця події, рятувальники евакуюють інших постраждалих. Серед них одні мовчать, інші стогнуть, плачуть, кашляють, благають про допомогу. Першими рятувальники підходять до постраждалих у непритомному стані (кома, шок). їм визначають дихальні шуми біля зовнішніх дихальних шляхів (протягом 10 с). Якщо постраждалий не дихає, відновлюють прохідність дихальних шляхів (виведення нижньої щелепи вперед, в окремих випадках – закидання голови назад) і повторно визначають наявність дихання. При 2-х і більше дихальних рухах за 10 с констатують наявність дихання. Такого постраждалого евакуюють в першу чергу в безпечну зону – пункт збору. В ході вступного сортування рятувальник також зупиняє кровотечу з магістральних судин джгутом.

  Винесення постраждалих проводять за допомогою транспортувальних дощок, а при їх відсутності – нош. Постраждалих, які не дихають після забезпечення прохідності дихальних шляхів, залишають на місці події і виносять в останню чергу. З юридичних та етичних міркувань рятувальники ДСНС не мають права встановлювати смерть. Інших постраждалих евакуюють у другу чергу.

  У разі неможливості проведення вступного сортування, евакуйовують найбільшу кількість постраждалих поза зону небезпеки, в якій відбудеться вступне сортування. Розмістити постраждалих у цій зоні слід таким чином, щоб існував вільний доступ як для сортування, так і надання медичної допомоги (оскільки територія є безпечною), зокрема на відстані приблизно 1,5 метра один від одного.

  Непритомним при транспортуванні на спині вводять ротогорлову трубку. Якщо такі постраждалі самостійно дихають, можна вкласти в безпечне (стабільне) положення на боці до приїзду бригад екстреної (швидкої) медичної допомоги. З моменту прибуття БЕ(Ш)МД в безпечну зону біля місця виникнення надзвичайної ситуації, куди рятувальники евакуювали постаждалих, починається медичне сортування, яке проводять медичні працівники (лікарі, фельдшер, медичні сестри). При медичному сортуванні позначається належність кожного постраждалого до відповідної сортувальної категорії сортувальним браслетом.

  Визнання події масовою означає впровадження певних рятувальних процедур, згідно з якими осіб без пульсу не реанімують і лікарі вважають їх загиблими. Цей принцип має фундаментальне значення у ситуаціях, коли на місце події першими прибувають рятувальники ДСНС, не уповноважені надавати медичну допомогу та за обставин, коли постраждалі знаходяться в зоні загрози, недоступної для лікаря медицини невідкладних станів.

  Керівник першої БЕ(Ш)МД, що прибув до кордону надзвичайної ситуації (безпечна зона), бере на себе обов’язки керівника і постійно співпрацює з рятувальниками ДСНС. Керівник бригади призначає відповідального за сортування (сортувальник) лікаря, фельдшера, який проводить первинне медичне сортування із визначенням “червоних”, “жовтих”, “зелених” і “чорних” постраждалих (табл. 6.2).

  Таблиця 6.2. Умовний розподіл частки постраждалих різних сортувальних груп від загальної кількості постраждалих

  постраждалих різних сортувальних груп