Мы поговорим, что такое оценка сложности алгоритма и сложность алгоритмов, а также расскажем что такое Большое О.
Расшифровка видео
0:01
добрый день меня зовут юрий я являюсь
0:05
преподавателем курсов кронид сегодня мы
0:07
поговорим с вами о теме которая волнует
0:10
многих программистов особенно новичков
0:12
тема называется beko прежде чем начать
0:17
что-то изучать человек должен понимать
0:19
зачем ему это изучать потому как если
0:22
нет веских причин для изучения той или
0:24
иной темы
0:25
эта тема является бесполезной и таких
0:27
тем стоит избегать
0:29
существуют три причины по которым
0:31
следует изучать веков причина первая
0:34
концепцию become
0:36
необходимо понимать чтобы уметь видеть и
0:38
исправлять не оптимальный код зная
0:41
концепцию bykov
0:42
вы сможете увидеть код который является
0:44
неоптимальным а также вы сможете
0:46
оптимизировать его причина вторая ни
0:49
один серьезный проект как они одно
0:50
серьезное собеседование не могут
0:52
обойтись без вопросов big o что это
0:55
значит допустим вы проходите
0:57
собеседование и вы идеально написали код
1:00
полностью решил задачу вы уверены что
1:03
код работает правильно и максимально
1:04
быстро проблема кроется в следующем
1:07
после того как вы написали код
1:09
interviewer попросит вас пожалуйста
1:12
оцените ваш алгоритм в рамках become
1:14
случае если вы допустите хотя бы одну
1:17
маленькую ошибку вы не пройдете
1:19
собеседование и важно как быстро
1:21
работает вошел дай вам потому как если
1:23
вы не умеете оценивать его в рамках beko
1:25
это значит одно вы не понимаете что вы
1:28
написали то же самое касается серьезных
1:31
крупных компаний на каждом проекте такой
1:34
компании существует процедура кадре view
1:36
code review
1:37
это проверка вашего кода более опытным
1:40
коллегой допустим ваш коллега нашел не
1:43
оптимальное место вашим алгоритме он
1:46
попросит его исправить
1:47
он это сделает 12 может быть три раза но
1:51
на четвертый раз у него возникнут
1:53
вопросы
1:53
она 5 вас могут просто уволить причина
1:56
третья непонимание become ведет к
1:59
серьезные потери производительности в
2:00
ваших алгоритмов сегодня в течение этого
2:03
видео я вам это докажу с причинами
2:06
изучения разобрались и необходимо понять
2:08
какую цель преследуют это видео
2:11
потому как если у видение цели она тоже
2:13
является бесполезным и таких видео стоит
2:15
избегать
2:15
цель просто научиться применять
2:18
основой концепции big o прежде чем
2:22
двигаться дальше необходимо привести
2:24
пример из реального мира который
2:26
касается big wool дело в том что
2:28
человеку порой и невозможно в голове
2:30
представить математическую модель а
2:32
веков является именно математической
2:35
моделью и для этого нужен пример из
2:37
реального мира представьте ситуацию
2:40
допустим вы живете в москве и вам нужно
2:44
передать файл другу который живет за
2:46
десять тысяч километров от вас допустим
2:49
во владивостоке как это лучше сделать
2:51
первый вопрос который вы должны задать
2:54
это чему равен размер файла ясное дело
2:58
что если мы хотим передать картинку
3:00
которая весит 100 килобайт то интернет
3:03
является лучшим способом передачи
3:05
информации но этот вариант хорош и для
3:08
маленьких файлов допустим google решила
3:12
перекачать все свои данные в москву это
3:15
уже не терабайт данных это гораздо
3:17
больше ясное дело что интернет в этом
3:19
случае не подходит вот здесь возникает
3:22
вопрос как это лучше сделать на самом
3:25
деле все данные google легко можно
3:27
перевести на самолете медленнее вот
3:30
этого лететь не станет запомнить этот
3:32
пример
3:32
мы к нему еще вернемся теперь я хочу
3:36
поговорить с вами об оценке работы
3:38
программы с точки зрения времени в
3:41
прошлом веке на заре программирование
3:43
возникла проблема как решить какой
3:45
алгоритм быстрее и эффективнее работает
3:48
дональд кнут был первым кто предоставил
3:51
решение этой проблемы чем была сама
3:54
проблема допустим у нас есть алгоритму
3:56
он сортирует массив из 10 тысяч
3:58
элементов согласитесь что если выполнить
4:01
из долга ритм на современном компьютере
4:03
то он отработает за 000 000
4:06
одну секунду если же взять старый
4:09
процессов например pentium 2 1997 года
4:12
выпуска
4:13
то на нем алгоритм отработает скажем на
4:16
2 секунды и вот здесь кроется проблема
4:19
мы не можем оценивать скорость работы
4:21
алгоритма с точки зрения времени потому
4:24
как один и тот же алгоритм на разных
4:26
машинах выполняется за разное время
4:28
выход из сложившегося положения был
4:31
очень простым любой алгоритм включает
4:33
себя какое-то число шагов или говоря
4:36
более точно количество тактов которая
4:38
выполняет процессор прежде чем алгоритм
4:40
закончится таким образом и важно на
4:43
старой или на новой машине выполняется
4:45
алгоритм
4:46
так как количество шагов на обеих
4:48
машинах будет одинаковым то есть идеи
4:51
big o это показать какое количество
4:53
шагов необходимо сделать чтобы алгоритм
4:55
закончил свое выполнение если мы
5:00
посмотрим определение becau википедии то
5:02
вы увидим следующее big o
5:04
это математическое обозначение для
5:06
сравнения а синтетического поведения
5:08
функции к сожалению это определение
5:10
фактически ничего не даёт нам с точки
5:12
зрения понимания как мы можем
5:14
оптимизировать
5:15
или оценивать алгоритмы но мы можем
5:17
переписать данное определение используя
5:20
суть которую в него вкладывал of the big
5:23
o показывает верхнюю границу зависимости
5:26
между входными параметрами функции и
5:28
количеством операций которая выполнит
5:30
процессор поэтому определение появилось
5:33
новое словосочетания верхняя граница про
5:36
него
5:37
мы поговорим чуть-чуть попозже главное
5:40
что вы здесь должны понять
5:41
эта фраза зависимость между входными
5:44
параметрами и количеством операций эта
5:46
фраза означает что big ol показывает
5:49
зависимость между допустим массивом на
5:52
1000 элементов которые подаются на вход
5:55
функции и количеством тактов процессора
5:57
которое необходимо выполнить чтобы
5:59
алгоритм обработал эти 1000 элементов
6:02
вернемся к нашему примеру с самолетом
6:05
если представить что ось x это
6:08
количество бит а ось y это количество
6:11
времени которые необходимо на передачу
6:13
данных
6:13
то мы можем сделать вывод что для
6:16
передачи файлов по сети мы видим что чем
6:18
больше бит тем дольше их передавать то
6:21
есть зависимость прямо пропорционально
6:23
или просто н
6:25
при передаче данных на самолёте нам не
6:27
важен размер файла скорость самолета от
6:30
этого не изменится или просто можно
6:32
писать это как у от одного здесь может
6:35
возникнуть вопрос что означает буквы о и
6:37
н
6:38
буква о это принято и обозначение
6:41
концепции becau
6:42
скобках указывается формула которая
6:44
описывает поведение алгоритма для
6:47
первого случая сложность является прямо
6:49
пропорциональной и зависит от количества
6:51
передаваемых бит больше бит дольше
6:53
передавать зависимость является линейной
6:55
в рамках big o зависимость принято
6:58
описывать
6:59
используя букву н если же у нас есть
7:03
другие переменная то это будет
7:04
млк и другие буквы второй случай
7:08
от одного представляет собой постоянную
7:10
величину может возникнуть вопрос почему
7:12
от одного
7:14
они от 0 ведь нет зависимости между
7:16
размером файла и скоростью самолета на
7:19
самом деле один это символизация того
7:22
что что то происходит если бы самолет и
7:24
летел файлы не передавались значит
7:27
сложность была бы
7:27
о0 то же самое касается алгоритмов если
7:31
мы не исполняем никакой код значит
7:34
ничего не происходит а значит сложность
7:35
равна о от 0 если же хотя бы мы вызвали
7:39
функцию которая ничего не выполняет то
7:42
вы уже совершили одно действие вызов
7:44
функции следовательно сложить равно о
7:46
от одного на самом деле под скобкой
7:49
может стоять совершенно любое выражение
7:51
наша задача на сегодня глядя на код
7:54
научиться выводить формулы описывающие
7:56
сложность алгоритма давайте рассмотрим
7:58
пример у нас есть функция она является
8:01
рекурсивной и считает сумму чисел
8:03
если мы вызовем ее сын равным 3 то ответ
8:07
будет 1 плюс 2 плюс 3 равно 6 если мы
8:11
передадим
8:11
n равное 4 то ответ будет 1 плюс 2 плюс
8:14
3 плюс 4 равно 10 и так далее возникает
8:19
вопрос такая зависимость между значением
8:22
входного параметра n количество в 1
8:24
сколько функция вызовет сама себя
8:27
если n равно 3 то функция вызывая тебя 3
8:31
раза потому что мы начинаем выполнять
8:34
функцию от 3 и каждый раз отнимаем
8:36
единицу пока не дойдем до
8:38
c то есть мы вызываем функцию от трех
8:41
вызываем функцию от двух затем от одного
8:43
и того функция вызвало сама себя 3 раза
8:47
если n равно 10 то функция выполняется
8:50
10 раз если n равно 100 функция
8:53
вызывается в себя 100 раз другими
8:56
словами быстродействия этой функции
8:58
прямо пропорционально входному значение
9:00
параметра n чем больше n тем больше раз
9:03
функция вызовет сама себя посмотрим на
9:06
вторую функцию она складывает какие-то
9:09
пара чисел нам не суть важно что она
9:11
делает для того чтобы решить эту задачу
9:15
нам необходимо понимать чему равна
9:17
сложность нижней функции пресса
9:20
функция выполняет сложение a + b
9:22
в ней нет ни циклов и рекурсии она
9:25
всегда выполняет константное количество
9:27
операций следовательно сложность функции
9:29
перса
9:30
равна от одного главная функция пароль
9:34
сам секунд цикле складывает какие-то
9:36
пары чисел вызывая функцию пирса
9:39
цикл выполняется от 0 до n другими
9:41
словами чем больше and тем больше раз
9:43
выполнится цикл если он равен трем то
9:47
цикл выполняется от 0 до 2 для нуля или
9:50
единицы и двойки и того три раза если n
9:54
равно 10 цикл выполнится 10 раз если n
9:57
равно 100 то цикл выполнится в сто раз
10:00
другими словами данная сложность
10:02
выполнения данной функции тоже о от n
10:05
этим примерам мы получили первое
10:08
впечатление о том как оценивать скорость
10:10
выполнения функции прежде чем двигаться
10:12
дальше мы должны понять некоторые
10:14
математические особенности оценки
10:16
сложности выполнения функций в рамках
10:18
beko
10:18
язык-то слайдов назад мы дали
10:21
определение bykov поэтому определение
10:23
фигурировала фраза верхняя граница на
10:26
самом деле фраза верхняя граница и
10:28
отбрасывая констант это одно и то же что
10:31
это значит и оценки скорости выполнения
10:34
алгоритма мы не говорим о каких-то
10:36
конечных входных значениях допустим за
10:39
сколько выполнится алгоритм если входной
10:41
массив имеет три элемента такая оценка
10:44
имеет смысла поскольку ответ будет
10:46
мгновенно 3 это слишком мало чтобы
10:48
оценить алгоритм
10:50
когда возникает вопрос какое число это
10:51
много тысяч десять тысяч элементов на
10:55
самом деле мы говорим о том как будет
10:57
себя вести алгоритму на бесконечности и
10:59
если алгоритм для n элементов выполняет
11:02
контактов + 1 такт для допустим вывода
11:05
информации на экран то сложность такого
11:08
алгоритма все равно n так как
11:10
бесконечность гораздо больше единицы
11:12
то же самое касается алгоритмов которые
11:15
выполняются за 2n за 3 n или за 5 н д
11:19
бесконечности 3 бесконечности 5 без
11:21
конфессий по сути это одно и то же это
11:24
все равно
11:25
бесконечность таким образом big o
11:28
описывает только скорость роста поэтому
11:32
мы отбрасываем константы при оценке
11:34
сложности по этому алгоритму описываемый
11:37
как о 2n сложно описывается как о н с
11:42
берем пример у нас есть две функции
11:44
левая и правая обе функции находят
11:47
минимум и максимум в массиве
11:49
у меня к вам вопрос какая из этих
11:52
функций работает быстрее
11:53
логично ответить что левая потому что
11:57
там одна инициализация цикла и один
11:59
проход по циклам и на самом деле если
12:02
посмотреть команды процессора то второй
12:04
пример медленнее но это неверный подход
12:08
к решению big o показывает как ведут
12:11
себя эти алгоритмы для обоих случаев это
12:14
а вот следующее о чем необходимо
12:18
поговорить
12:18
чтобы понять big ol это неважная
12:21
сложность допустим у нас есть выражение
12:25
n квадрат плюс н.н. не является
12:29
константой
12:30
как с этим быть на самом деле мы знаем
12:33
что н квадрат плюс n квадрат равно n
12:36
квадрат так как мы отбрасываем константы
12:37
и мы точно знаем что н квадрат
12:40
значительно больше н здесь стоит
12:43
уточнить что значит слово значительно с
12:45
точки зрения be cool значительно это
12:47
значит в два раза если n в два раза
12:50
больше другого числа м значит он
12:53
значительно больше чем
12:55
м и пасу
12:58
1 н значительно меньше чем n квадрат она
13:01
не влияет на темп роста функции то есть
13:04
и сложность является неважной и ей можно
13:07
пренебречь
13:08
следовательно н квадрат плюс n это
13:11
просто н квадрат давайте разберем
13:14
несколько примеров для лучшего понимания
13:15
отброс менее важной сложности н квадрат
13:18
плюс n уже знаем это н квадрат n плюс
13:22
логарифм н это просто н потому что
13:25
логарифм намного меньше чем n 5 умножить
13:30
на 2 степени n плюс 10 умножить на m
13:32
степени 100
13:34
вот здесь прежде чем решать такие
13:37
сложные выражения необходимо подумать
13:38
что можно выбрать и сразу пятеркой и
13:41
десятка являются константами
13:42
поэтому от них можно избавиться остаются
13:45
двое х в степени n и n степени 100 на
13:48
самом деле степенная функция растет
13:50
гораздо гораздо быстрее чем м степени
13:54
100 таким образом ответ будет 2 в
13:56
степени n и последний пример н квадрат
14:00
плюс b на самом деле ответ будет n
14:03
квадрат плюс б так как мы ничего не
14:06
знаем об b может быть равным n может
14:10
просто числом 3 а может быть
14:12
какой-нибудь другой буквой а пока мы
14:14
ничего не знаем о нашей переменной мы не
14:16
можем выбросить ее из нашей формулы
14:20
на предыдущих формула мы видели знаки
14:24
сложения и умножения давайте попробуем
14:26
научиться их расставлять правильно на
14:30
самом деле практически у всех новичков
14:31
возникает главный вопрос складывать и
14:35
умножать сложности выполнения и
14:39
почему-то они не могут понять как должна
14:42
складывать когда нужно уважать
14:44
ответ очень простой давайте рассмотрим
14:46
пример у нас есть кот он проходит массив
14:50
длиной а затем проходит массив длины б
14:54
сложность выполнения данного кода будет
14:56
равна a + b так как в коде проход к
14:59
массивам выполняется последовательно то
15:02
есть выполнение первого цикла совершенно
15:05
не зависит от выполнения второго цикла
15:07
есть другой код сначала мы проходим
15:10
массива
15:10
а внутри этого цикла проходим василина и
15:13
b и вот здесь мы уже будем выполнять
15:16
умножение потому что функция print
15:18
выполняется b раз и из этих b раз она
15:21
выполнится еще раз другими словами цикл
15:25
по б зависим от цикла по а если вы
15:31
откроете википедии любой алгоритм
15:33
сортировки или поиска вы наверняка
15:36
увидите что оценка сложности данного
15:37
алгоритма содержит выражение log n на
15:42
самом деле вопрос появление данного
15:44
логарифмов формулах сводит с ума многих
15:46
людей и люди не понимают откуда он
15:49
берется прежде чем носить разбирать
15:51
откуда берется look and давайте вспомним
15:54
примерный алгоритм бинарного поиска
15:56
отсортированном массиве шаг 1 мы берем
16:00
середину массива если искомое число
16:02
меньше середина массива идем в левый под
16:05
массив больше в правый повторяем тоже
16:08
самое для под массива алгоритм
16:12
заканчивается если мы нашли искомое
16:14
значение допустим у нас есть массив из
16:17
16 элементов то есть n равно 16
16:20
если мы хотим найти число то мы должны
16:23
сначала искать в 16 элементах потом 8
16:26
потом 4 потом в двух потом в одном если
16:29
этот один оставшийся элемент не равен
16:31
искомому то элемент не существует
16:33
давайте посмотрим на цифры они
16:36
отображают как массив уменьшается в
16:38
своем размере при поиске элемента а
16:40
теперь сделаем фокус мы перевернем ряд
16:44
16 8 421 наоборот то есть это будет 1248
16:50
16 или если записать в степени двойки то
16:54
2 0 2 в 1 дома 2 2 в 3 2 в четвёртой
16:58
сколько раз нужно умножить 1 на 2 чтобы
17:01
получить 16 4 раза
17:06
нам нужно умножить 1 на 2 ровно 4 раза
17:09
чтобы получить 16
17:12
то с другими словами 4 это максимальное
17:14
количество операций которое необходимо
17:16
выполнить алгоритму при n равно 16 чтобы
17:20
найти ответ то есть четыре
17:24
это и есть pick up а теперь давайте
17:27
запишем нашу зависимость между четверкой
17:29
16 немножко в другом видео 2 в четвёртой
17:32
это 16 перепишем это в общем виде зная
17:36
что 16 это
17:37
на4 допустим это к то есть это будет 2 в
17:42
степени k равно n или если вспомнить
17:44
математику и школы к равно логарифму
17:47
двоичный от n получается что на самом-то
17:51
деле к это big ol тогда мы можем сказать
17:53
что у от k равно о от логарифм в
17:55
двоичную н тройка в основание логарифма
17:57
является константы
17:59
а константы при оценке сложности не
18:00
играют роли следовательно при оценке
18:03
сложностей двоичный логарифм
18:04
записывается просто как log вот здесь мы
18:08
можем сделать главный вывод для
18:11
алгоритма где на каждой итерации берется
18:14
половина элементов
18:16
сложность будет включать log n ключевое
18:18
слово здесь включать сложность алгоритма
18:21
не обязательно будет равна
18:23
именно логарифм н она может быть равна n
18:25
умножить на log n или n + log n или а
18:29
умножить на логарифм н главное здесь то
18:32
что если на каждой итерации мы берем
18:34
половину элементов
18:35
то формула оценки сложности выполнения
18:37
алгоритма всегда будет включать в себя
18:40
логарифм н а теперь давайте прорешаем с
18:44
вами некоторые типовые примеры оценки
18:47
сложности big ol слева у нас всегда
18:52
будет дан какой-то код нам не всегда
18:54
важно что он делает главное какова
18:57
сложность его выполнение чтобы было
18:59
проще оценивать этот код мы можем его
19:01
записать в псевдо варианте здесь у нас
19:04
есть два цикла каждый проходит массив
19:06
длиной n 2 цикла последовательно
19:09
следовательно сложность будет равна н
19:12
плюс или просто о от n
19:17
пример 2 у нас во вложенных цикла каждый
19:21
из которых работает от 0 до n
19:24
таким образом сложность будет n умножить
19:27
на n или н квадрат пример номер три
19:32
вот здесь у нас первый цикл работает от
19:37
0 до n
19:38
а второй от dji равное и то есть это уже
19:42
вопрос если записать этот код псевдокоде
19:45
получится что внешний цикл
19:47
отрабатывает n 1 а внутренние n 1 и
19:49
минус 1 1 из 2
19:51
бла-бла-бла 21 раз почему каждый раз он
19:55
уменьшается на яичку потому что каждый
19:57
раз и увеличивается на единичку таким
20:01
образом мы можем сказать что на самом-то
20:04
деле сложность будет равна n + 1 + n2 +
20:08
бла-бла-бла плюс два плюс один вопрос
20:11
как упростить данное выражение
20:13
ответ на самом деле простой для того
20:16
чтобы его понять нужно рассмотреть
20:17
пример наш старый пример где сложность
20:21
выполнения равна n квадрат поскольку и
20:23
равно 0 жиров на ноль и мы проходим
20:25
что-то n 1 это мы можем представить в
20:29
виде 16 кружков 16 кружков это для ядро
20:34
nova 4 будет квадратичная сложность или
20:36
по-другому это н квадрат а теперь фокус
20:39
вот наш код мы знаем что если бы
20:44
сложность была равная квадратичное это
20:46
был бы вот такой квадрат и состоящий из
20:48
16 элементов но на каждом шаге n
20:51
уменьшительно на единичку
20:52
таким образом у нас будет n равно 3 d
20:55
равно 2n равно 1 то есть другими словами
20:58
мы видим визуально что квадрат стал
21:02
ровно на половину меньше по диагонали
21:05
таким образом сложность равна n
21:06
подразделить на два или просто н квадрат
21:11
эта техника позволяет вам в голове
21:13
видеть код и оценивать его потому как
21:16
математически посчитать такие выражения
21:18
порой сложно и долго она интервью у вас
21:21
есть буквально несколько минут чтобы
21:24
понять чему равна сложность пример номер
21:28
4 у нас есть код который выполняется
21:32
сначала для массива длиной а затем для
21:35
массива длиною b
21:37
получается псевдокоде это два вложенных
21:40
циклов по a и b и того сложность будет
21:43
равна а умножить на b
21:45
пример номер пять код является точной
21:50
копией предыдущего кроме того что внутри
21:52
выполняется цикл 100000 раз конечно
21:55
100000 это большое число на самом деле
21:57
это константа а значит сложность
21:59
выполнения будет точно такой же как в
22:02
прошлом коне или а умножить на b
22:06
пример номер шесть вот здесь мы проходим
22:11
массив ровно до половины в некоторых
22:14
людей может возникнуть сомнения или
22:17
вопросы мы берем половину элементов на
22:20
итерации по идее должен быть в.н. на
22:23
самом деле это заблуждение здесь мы
22:25
просто идём до половины массива а это
22:28
значит что сложность равна n делить на
22:30
два или просто о пример номер семь у нас
22:37
есть функция которая сортирует с начала
22:39
строки а потом сортирует массив строк
22:41
вот здесь очень интересный момент цикл
22:46
работает от 0 до n то есть n 1 далее
22:50
происходит сортировка строк
22:51
длина каждой строки будем считать равна
22:53
l сортировка самое обычное l умножить на
22:56
логарифм а вот сортировка массива
23:00
казалось бы тоже обычная n умножить на
23:03
логарифм н но здесь мы должны учитывать
23:05
еще буковку м что это значит компьютер
23:09
не может сравнивать строки за один так
23:12
процессора он может сравнивать числа
23:14
допустим 3 больше двух это один такт это
23:17
просто числа но компьютер не может
23:20
сравнить две строки такие как a b c и а
23:23
б д
23:24
дин так потому как для сравнения этих
23:26
строки нужно сравнить сначала а
23:28
eгo b и b c и d и только здесь он может
23:32
дать правильный ответ равный строки или
23:35
нет то есть получается при сравнении
23:37
двух строк процессор в любом случае
23:39
выполняет количество тактов равное
23:42
количеству
23:44
меньшей строки то есть он должен пройти
23:46
всю строку длиной l и поэтому при
23:50
сортировки массива мы должны учитывать
23:52
не только саму сложность алгоритма но и
23:54
саму сложность сравнения строк и вот
23:56
отсюда появляется буковка л
23:58
таким образом это доказывает что не зная
24:01
big o вы можете в l 1 просесть по
24:05
производительности в вашем коде
24:07
если подводить итог то сложность
24:09
выполнения данного алгоритма будет равна
24:11
n умножить на n умножить на логарифм н
24:15
плюс логарифм
24:19
далее мы должны сделать выводы
24:21
нашего видео потому что если нет выводов
24:23
то в голове у вас ничего не останется
24:25
а видео будет бесполезным вот первый миг
24:30
показывает темп роста функции
24:32
следовательно мы не учитываем константы
24:34
и неважную сложность тут 2
24:37
последовательность действий сложения
24:38
вложенное действие умножения и вывод
24:41
третье для алгоритма и на каждой
24:43
итерации берется половина элементов
24:45
сложность будет включать логарифм на
24:48
самом деле это базовое понятие о beko
24:53
мы не рассмотрели видео рекурсию мы не
24:55
рассмотрели построения дерева или курсе
24:57
и мы не посмотрели как оценивать память
24:59
для рекурсии на самом деле тема big o
25:02
очень обширна и мы рассмотрели только
25:05
какие-то базовые вещи полностью мы
25:08
рассматривали тему на нашем курсе кранец
25:10
спасибо что посмотрели это видео и до
25:13
новых встреч