Помогите пожалуйста, очень надо!
Даны 3 алгоритма, самы алгоритмы объяснять не буду, не в них суть. Надо найти сложность каждого алгоритма. (я так предпологаю, что сложностькаждого будет n!) Нужно красивое объяснение нахождения этой сложности.
Алгоритмы:

1. Генерирование всех последовательностейв антилексикографичеком порядке.
Данные: n
Результат: Пеоследовательность перестановок множества {1,…,n} в антилексикографическом порядке.
(написано на VB)

Private Sub REVERSE(m As Integer)
Dim i, j, tmp As Integer
i = 1
j = m
While i < j
tmp = P(i)
P(i) = P(j)
P(j) = tmp
i = i + 1
j = j - 1
Wend
End Sub
----------------------------------------------------
Private Sub ANTYLEX(m As Integer)
Dim i, tmp, k As Integer
Dim A As String

If m = 1 Then
A = ""
For k = 1 To n
A = A + Str(P(k))
Next k
lstAntylex.AddItem A
Else
For i = 1 To m
ANTYLEX (m - 1)
If i < m Then
tmp = P(i)
P(i) = P(m)
P(m) = tmp
REVERSE (m - 1)
End If
Next i
End If
End Sub
----------------------------------------------------
Private Sub cmdBegin_Click() ' вводится число n заполняется массив начальными значениями,
lstAntylex.Clear ' последовательность будет выводится в ListBox - lstAntylex
n = txtN.Text
ReDim P(n)

For i = 1 To n
tmp = P(i)
P(i) = i
i = tmp
Next
ANTYLEX (n)
End Sub

2. Генерирование всех перестановок за минимальное число транспозиций.

Function B(m As Integer, j As Integer) As Integer
Dim tmp As Integer

If (m Mod 2 = 0) And (m > 2) Then
If j < m - 1 Then B = j Else B = m - 2
Else
B = m - 1
End If
End Function
------------------------------------------------------------
Private Sub PERM(m As Integer)
Dim tmp, k, i As Integer
Dim A As String

If m = 1 Then
A = ""
For k = 1 To n
A = A + Str(P(k))
Next k
lstAntylex.AddItem A
Else
For i = 1 To m
PERM (m - 1)
If i < m Then
tmp = P(B(m, i))
P(B(m, i)) = P(m)
P(m) = tmp
End If
Next i
End If
End Sub
------------------------------------------------------------
Private Sub cmdBegin_Click()
lstAntylex.Clear
n = txtN.Text
ReDim P(n)

For i = 1 To n
tmp = P(i)
P(i) = i
i = tmp
Next
PERM (n)
End Sub

3. Генерирование всех перестановок с минимальным числом транспозиций соседних элементов.

Private Sub cmdBegin_Click()
Dim i, k, tmp, j As Integer

lstAntylex.Clear
n = txtN.Text
ReDim P(n), C(n), PR(n)

For i = 1 To n
P(i) = i
C(i) = 1
PR(i) = True
Next i
C(n) = 0
A = ""
For j = 1 To n
A = A + Str(P(j))
Next j
lstAntylex.AddItem A
i = 1
While i < n
m = m + 1
i = 1
x = 0
While C(i) = n - i + 1
If PR(i) = True Then PR(i) = False Else PR(i) = True
C(i) = 1
If PR(i) Then x = x + 1
i = i + 1
Wend

If i < n Then
If PR(i) Then k = C(i) + x Else k = n - i + 1 - C(i) + x
tmp = P(k)
P(k) = P(k + 1)
P(k + 1) = tmp
A = ""
For j = 1 To n
A = A + Str(P(j))
Next j
lstAntylex.AddItem A
C(i) = C(i) + 1
End If
Wend
End Sub


СПАСИБО!
С Уважением MINX

При оценке сложности алгоритма выбирают самую сложную элементарную алгебраическую операцию, зачастую - умножение (*). В твоем случае - это "+" и "-". Считаем количество сложений и вычитаний при выполнении функции - это число и есть оценка сложности... Иногда говорят не о самой сложности, а о её порядке...

А ты напиши программу, которая бы запускала этот алгоритм и считала количество итераций. Далее составь массив вида: (входное число n, количество итераций) и проинтерполируй, а лучше построй линию регрессии (по графику будет понятно какой). Если алгоритм прямой и независим от генерации случайных чисел, обе величины в массиве четко коррелируют.

Есть метрики, позволяющие оценить сложность программы и алгоритма,
например, - цикломатическая сложность программы (число Маккейба). Для этого алгоритм рисуют в виде ориентированного графа, где вершины - простые оперции(+,-, циклы...), а дуги - переходы от одной к другой.
Z(G) = E-V+2p, где Е - количество дуг графа G, V-число вершин, p- количество дуг, котор. надо добавть в граф, что бы он был сильно связан(в хорошо спланированных прогах =1).
Метрика Джимба более проста
cl- абсолютная сложность проги - кол-во условных операторов
CL - относительн. сложность -сl/общее кол-во операторов.
Есть оценка программы по методу граничных значений.- целый алгоритм...