c nblogs.com/images/cnblogs_com/zhanlang/1295643/o_%e6%b1%9f%e6%b9%96.jpg””>https://www.cnblogs.com/image…;/c nblogs.com/images/cnblogs_com/zhanlang/1295643/o_江湖.jpg””>https://www.cnblogs.com/image…;/> s.com/image…;/> c nblogs.com/images/cnblogs_com/zhanlang/1295643/o_%e6%b1%9f%e6%b9%96.jpg””>https://www.cnblogs.com/image…;/c nblogs.com/images/cnblogs_com/zhanlang/1295643/o_江湖.jpg””>https://www.cnblogs.com/image…;/> s.com/image…;/> c nblogs.com/images/cnblogs_com/zhanlang/1295643/o_江湖.jpg””>https://www.cnblogs.com/image…;/> s.com/image…;/>
разделяй и властвуй
Что касается сортировки, то в Цзянху преобладает идея “разделяй и властвуй”, которая может значительно улучшить производительность метода сортировки. Так называемый принцип “разделяй и властвуй” означает превращение большого в малое, разделение и завоевание малого. Для достижения эффекта малого и большого. На протяжении многих лет, основываясь на идее разделения и управления, были выведены различные методы ментального упорядочения, но они никогда не изменятся.
Хотя в алгоритме много работы над реками и озерами, хороший редактор алгоритмов считает, что для того, чтобы действительно повысить силу практикующих, необходимо выполнить следующие условия.
Временная сложность (время выполнения)
В измерении временной сложности алгоритма мы в основном сравниваем количество сравнений и обменов, а другие некоммутативные элементы алгоритма будут в основном сравнивать количество посещений измерения массива.
На самом деле, многие практики немного смутно представляют временную сложность алгоритма. Они не могут сказать, что называется O (n), O (n logn), O (logn). Возможно, следующий рисунок имеет более интуитивное представление о некоторых людях.
Пространственная сложность (дополнительное использование памяти)
Не менее важны дополнительные затраты памяти и время работы алгоритма сортировки. Даже если временная сложность алгоритма превосходна, пространственная сложность очень мала, а используемая дополнительная память очень велика, я думаю, что это не очень хороший алгоритм.
Правильность результатов
Этот показатель добавляется самим овощем, и я всегда считаю, что конечный результат отличного алгоритма должен быть правильным. Даже если алгоритм имеет отличную временную и пространственную сложность, но результаты неверны, что приводит к развороту канала ученика, выстрелу в дьявола, в чем значение?
принцип
Основная идея: выберите элемент в качестве точки сегментации путем обхода, поместите элементы, меньшие, чем точка сегментации, с левой стороны точки сегментации и поместите элементы, большие, чем точка сегментации, с правой стороны элемента точки сегментации. Затем две части данных сортируются отдельно в соответствии с этим методом, и так далее, пока размер секционированного массива не составит 1. Весь процесс сортировки может быть выполнен рекурсивно, так что все данные могут быть преобразованы в упорядоченную последовательность.
процесс
Существует множество способов быстрой сортировки, среди которых наиболее распространенным является перемещение указателя. Почему это наиболее распространенное явление? Потому что его пространственная сложность равна O (1), то есть сортировка на месте.
- Мы выбираем запись (обычно первую) из последовательности записей, подлежащих сортировке, в качестве базового элемента (называемого ключом) [слева], а затем задаем две переменные. Левая указывает на крайнюю левую часть последовательности, а правая указывает на крайнюю правую часть данных.
- Если arr [справа] < клавиша, arr [справа] помещает меньшее число, чем клавиша, слева. Если arr [справа] > ключ, нам просто нужно сравнить right -, right––, а затем arr [справа] с ключом, пока arr [справа] < ключ не поменяется элементами.
- Если arr [справа] < ключ существует с правой стороны, являются [правыми], затем повернитесь на левую сторону и сравните arr [слева] с ключом. Если arr [слева] > ключ, то [слева], если arr [слева] < ключ, то просто сравните arr [слева] с ключом.
- Затем переместитесь вправо, чтобы повторить описанные выше шаги
- Наконец-то, {23 58 13 10 57 62} 65 {106 78 95 85} получается, а затем та же операция выполняется с левой подпоследовательностью и правой подпоследовательностью. Наконец, получается упорядоченная последовательность.
{23 58 13 10 57 62} 65 {106 78 95 85}
{10 13} 23 {58 57 62} 65 {85 78 95} 106
10 13 23 57 58 62 65 78 85 95 106Эксплуатационные характеристики
Что касается формул O (n), связанных со сложностью, я должен подчеркнуть здесь, что формулы представляют тенденцию к увеличению сложности алгоритма, а не конкретную формулу вычисления сложности. Например, сравнение O (n_) с O (n) показывает только, что тенденция роста O (n) быстрее, чем o (n), обратите внимание, что алгоритм O (n) занимает больше времени, чем другой алгоритм (n).
Временная сложность
Средняя временная сложность быстрой сортировки составляет O (nlogn), O (nlogn) в лучшем случае и O (n) в худшем.
Пространственная сложность
Основываясь на приведенных выше примерах, пространственная сложность быстрого планирования равна единице (1), то есть сортировке на месте.
стабильность
Например: Массив, подлежащий сортировке: int a []= {1, 2, 2, 3, 4, 5, 6};
В случайно выбранном компараторе (pivot) этап быстрой сортировки: Если в качестве компаратора выбран [2] (т. е. вторые 2 в массиве), и если число, большее или равное компаратору, помещено в большой массив, то a [1] (т. е. первые 2 в массиве) будет справа от pivot, то два 2 в массиве не являются примитивными (то есть нестабильными). Если в качестве компаратора выбран [1], и число, меньшее или равное компаратору, помещено в десятичный массив, то два порядка из двух в массиве не являются исходным порядком. Быстрая сортировка не является стабильной сортировкой.
Улучшение
С помощью приведенного выше анализа вы можете проанализировать недостатки быстрой сортировки?
- Дисбаланс деления: то есть выбранные нами элементы находятся далеко от элементов среднего значения массива. В крайних случаях они будут самыми большими или самыми маленькими элементами массива, что приведет к многократному разделению большого массива. Учитывая эту ситуацию, мы можем взять несколько элементов массива, чтобы сбалансировать эту ситуацию. Например, мы можем случайным образом выбрать три или пять элементов и взять элементы промежуточного значения в качестве элементов сегментации.
- Небольшие массивы: Когда быстрая сортировка разбивается на более мелкие массивы, она также вызывает себя рекурсивно. В этом случае некоторые базовые алгоритмы сортировки на самом деле быстрее, чем быстрая сортировка. Если массив невелик, попробуйте переключиться на сортировку вставки. Насколько он мал? Общие 5-15 бар, только для справки.
- Повторяющиеся элементы: В нашем практическом применении мы часто сталкиваемся с более повторяющимися элементами. Согласно идее быстрой очереди, одни и те же элементы будут часто перемещаться и разделяться. На самом деле в этом совершенно нет необходимости. Что нам следует делать? Мы можем разделить массив на три части: больше – равно – меньше трех частей массива, чтобы равная часть массива могла избежать перемещения, но сложность кода посадки намного выше, заинтересованные студенты могут это сделать.
Сценарии использования
- Когда размер массива превышает порядок величины, овощи считают, что можно использовать быструю сортировку, и при непрерывном увеличении массива производительность быстрой сортировки имеет тенденцию к среднему времени выполнения. Что касается размера массива для средних размеров, то обычно он считается 50 + бар, только для справки.
- Быстрая сортировка также подходит, когда массив неупорядочен и в нем мало повторяющихся элементов. Зачем выдвигать тезис о повторяющихся элементах? Поскольку, если повторяющихся элементов слишком много, исходные повторяющиеся элементы не нужно сортировать, но быструю сортировку все равно необходимо разделить на большее количество поддиапазонов для сравнения, на данный момент, возможно, более подходящей является сортировка вставкой.
Дай ему попробовать.
Издание оружия C#
static void Main(string[] args)
{
List data = new List();
for (int i = 0; i < 11; i++)
{
data.Add(new Random(Guid.NewGuid().GetHashCode()).Next(1, 100));
}
// Print the original array value
Console. WriteLine ($"raw data: {string. Join (", "data)}");
quickSort(data, 0, data.Count - 1);
// Print sorted arrays
Console. WriteLine ($"Sort data: {string. Join (", "data)}");
Console.Read();
}
public static void quickSort(List source, int left, int right)
{
int pivot = 0;
if (left < right)
{
pivot = partition(source, left, right);
quickSort(source, left, pivot - 1);
quickSort(source, pivot + 1, right);
}
}
// Sort an array/list by grouping the first element, returning the location index of the key after the sort
private static int partition(List source, int left, int right)
{
int key = source[left];
while (left < right)
{
// Select a fixed value larger than the selected value from the right side and a swap position smaller than the key
while (left < right && source[right] >= key)
{
right--;
}
source[left] = source[right];
while (left < right && source[left] <= key)
{
left++;
}
source[right] = source[left];
}
source[left] = key;
return left;
} Готовящееся издание Оружия
package main
import (
"fmt"
"math/rand"
)
func main() {
var data []int
for i := 0; i < 10; i++ {
data = append(data, rand.Intn(100))
}
fmt.Println(data)
quickSort(data[:], 0, len(data)-1)
fmt.Println(data)
}
func quickSort(source []int, left int, right int) {
var pivot = 0
if left < right {
pivot = partition(source, left, right)
quickSort(source, left, pivot-1)
quickSort(source, pivot+1, right)
}
}
func partition(source []int, left int, right int) int {
var key = source[left]
for left < right {
for left < right && source[right] >= key {
right--
}
source[left] = source[right]
for left < right && source[left] <= key {
left++
}
source[right] = source[left]
}
source[left] = key
return left
}
Результаты операции:
[81 87 47 59 81 18 25 40 56 0] [0 18 25 40 47 56 59 81 81 87]
Привлекайте внимание, просматривайте более изысканные версии, собирайте более захватывающие