как рассчитать сложность времени сортировки пузырьков
Я пытался понять структуру данных и другой алгоритм, затем я запутался, чтобы измерить сложность времени сортировки пузыря.
for (c = 0; c < ( n - 1 ); c++) {
for (d = 0; d < n - c - 1; d++) {
if (array[d] > array[d+1]) /* For descending order use < */
{
swap = array[d];
array[d] = array[d+1];
array[d+1] = swap;
}
}
}
теперь каждый большой O говорит лучший случай O(n), случай Avg(n2) и худший случай (n2).Но когда я вижу код, найденный в первой фазе внутреннего цикла запуска n раз, то во второй фазе n-1, и n - 2 и так далее. Это означает, что в каждой итерации его значение уменьшается. Например, если у меня есть[] = {4, 2, 9, 5, 3, 6, 11} таким образом, общее число сравнений будет -
1st Phase - 7 time
2nd phase - 6 time
3rd Phase - 5 time
4th Phase - 4 time
5th Phase - 3 time
6th Phase - 2 time
7th Phase - 1 time
поэтому, когда я вычисляю время, оно выглядит так = (7 + 6 + 5 + 4 + 3 + 2 + 1) + 7 = 35, но худшая сложность времени-n2 согласно doc.
Так может кто-нибудь сказать мне, как рассчитать правильное значение.
6 ответов
давайте рассмотрим случаи для Big O для Bubble Sort
Случай 1) O (n) (лучший случай) На этот раз сложность может возникнуть, если массив уже отсортирован, а это означает, что своп не произошел и только 1 итерация из n элементов
случай 2) O (n^2) (Худший случай) В худшем случае если массив уже отсортирован, но в порядке убывания. Это означает, что на первой итерации он должен был бы смотреть на n элементов, затем после этого он будет выглядеть n - 1 элементов (так как самый большой integer находится в конце) и так далее и так далее, пока не произойдет сравнение 1. Big-O = n + n-1 + n-2 ... + 1 = (n*(n + 1))/2 = O (n^2)
в вашем примере он может не рассматривать эти многие элементы в каждой фазе, поскольку массив не находится в порядке убывания.
Итак, вы заметили, что общее количество проведенных сравнений равно n + (n - 1) + ... + 2 + 1. Эта сумма равна n * (Н + 1) / 2 (см. Треугольные Числа), который равен 0.5 n^2 + 0.5 n, что явно O(n^2).
Он делает сравнение между двумя элементами. так в 1-й этап-сравнение n-1. Я. e, 6 2-й этап-сравнение n-2. Я. e, 5 и так до 1. и, таким образом, sum = n(n-1)/2 i.e O (n^2).
Если есть любые ошибки можно исправить.....
O(n^2) = n(n-1)/2 является правильным.
как в приведенном выше примере 5 элементов.
5(5-1)/2 == 10.
5(5+1)/2 != 10.
объяснение наихудшего случая здесь:
elements = raw_input("enter comma separated elements : ")
elements = elements.split(',')
elements = map(int, elements)
length = len(elements)
for i in xrange(length - 1):
print "outer pass : ", i
for j in xrange(length - i - 1):
print "inner pass : ", j
if elements[j] > elements[j + 1]:
elements[j + 1], elements[j] = elements[j], elements[j + 1]
print "elements : ", elements
print elements
выход :
введите разделенные запятыми элементы: 5,4,3,2,1
внешний проход : 0
внутренний пропуск : 0
элементы : [4, 5, 3, 2, 1]
внутренний пропуск : 1
элементы : [4, 3, 5, 2, 1]
внутренний проход : 2
элементы : [4, 3, 2, 5, 1]
внутренний пропуск : 3
элементов : [4, 3, 2, 1, 5]
внешний пропуск: 1
внутренний пропуск : 0
элементы : [3, 4, 2, 1, 5]
внутренний пропуск : 1
элементы : [3, 2, 4, 1, 5]
внутренний проход : 2
элементы : [3, 2, 1, 4, 5]
внешний проход : 2
внутренний пропуск : 0
элементы : [2, 3, 1, 4, 5]
внутренний пропуск : 1
элементы : [2, 1, 3, 4, 5]
внешний проход : 3
внутренний пропуск : 0
элементы : [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
таким образом, первая итерация все n элементов сканируются, он будет сканировать n - 1 элементов в следующей итерации. Так далее для всех элементов.
n + n-1 + n-2 ... + 1 = (n * (n + 1))/2 = O (n^2)
для n чисел общее количество проведенных сравнений будет (n-1)+... + 2 + 1. Эта сумма равна (n-1) * n / 2 (см. треугольные числа), которая равна 0,5 N^2 - 0,5 n, т. е. O(n^2)