background top icon
background center wave icon
background filled rhombus icon
background two lines icon
background stroke rhombus icon
header logo icon

Скачать "// Алгоритмизация #5 // Односвязный список //"

input logo icon
"videoThumbnail // Алгоритмизация #5 // Односвязный список //
Похожие ролики из нашего каталога
|

Похожие ролики из нашего каталога

Теги видео
|

Теги видео

алгоритмизация
#
односвязный
список
Субтитры
|

Субтитры

subtitles menu arrow
  • enАнглийский
Скачать
00:00:02
по алгоритмизации в данном видео мы
00:00:04
разберем что представляют себе 1
00:00:05
связанные списки и это видео будет
00:00:07
разделено на две части первая часть
00:00:10
будет являться теоретической вторая
00:00:11
часть будет являться практической в
00:00:13
теоретической части мы разберем сначала
00:00:15
что представляют себе массивы долины от
00:00:18
массивов мы перейдем непосредственно к
00:00:20
спискам и разберем отличие массивов и
00:00:23
списков далее мы попробуем разобрать для
00:00:28
чего вообще нужны 1 связанные списки ну
00:00:30
и закончим это все мы непосредственно
00:00:32
практической частью где попробуем
00:00:35
реализовать и тип данных лист на языке
00:00:37
программирования си и при помощи этого
00:00:39
типа данных мы реализуем две функции и
00:00:41
to push & pop то есть мы будем
00:00:43
имитировать по факту стек в но уже не
00:00:46
при помощи массива а при помощи списка
00:00:48
ну что же давайте непосредственно
00:00:50
приступать ну и как говорилось минутой
00:00:53
ранее
00:00:54
нам необходимо для начала понять что
00:00:56
представляет из себя массивом чтобы
00:00:59
впоследствии более легко определять
00:01:03
что представляют из себя уже
00:01:05
односвязанны списки вот так вот на чем
00:01:08
мы пожалуй с того как представляется из
00:01:10
себя массив по факту массив назовем его
00:01:13
как рей представляет себя линейную
00:01:17
область памяти
00:01:18
который идет последовательно таким вот
00:01:21
образом массивы идут всегда
00:01:24
последовательно и непрерывно то есть и
00:01:26
каждый ячейкам следующий ячейка памяти
00:01:29
идет за предыдущий
00:01:31
то есть не бывает таких разрывов то есть
00:01:34
у нас допустим вот здесь первое ячейка
00:01:37
памяти далее 2 3 4 но и здесь допустим 5
00:01:42
стоит сказать то что каждая ячейка
00:01:45
памяти хранит как адрес то есть в данном
00:01:48
случае допустим у нас будет ноль один
00:01:52
два три четыре это будет представляться
00:01:56
адрес от начала то есть вот вот этой вот
00:01:58
позиции
00:02:00
это скажем так начальной позиции и язык
00:02:04
программирования си именует ее в
00:02:06
зависимости от указанного имени
00:02:08
то есть соответственно чтобы получить
00:02:10
какое-то значение точнее какой какую-то
00:02:13
ячейку памяти нам необходимо сделать
00:02:15
следующим образом то есть
00:02:17
указать сначала ray это говорит о том
00:02:19
что мы начинаем вот с этой вот
00:02:21
позиции чтения и соответственно если нам
00:02:24
необходимо узнать точнее получить ячейку
00:02:28
памяти по вот этому адресу нам
00:02:30
необходимо указать плюс 0 то есть
00:02:32
сдвинуть и рейна плюс ноль
00:02:34
соответственно это будет аналогично тому
00:02:36
что мы указываем просто ярый ну как вы
00:02:40
понимаете сложение и вычитание с нулем
00:02:43
дают тот же самый результат
00:02:45
соответственно чтобы получить допустим 3
00:02:47
ячейку нам необходимо указать рей и
00:02:51
сдвинуть адрес на три позиции вперед то
00:02:54
есть 1 2 и 3 в итоге мы получаем вот эту
00:02:58
ячейку памяти + 3
00:03:01
но для того чтобы получить не адрес вот
00:03:05
этой памяти о получить значение которое
00:03:08
хранит ну допустим здесь у нас будет
00:03:10
хранится значение x для того чтобы
00:03:13
получить это значение нам необходимо
00:03:15
разыменовать указатель то есть
00:03:18
разыменовывает эту область памяти и в
00:03:21
итоге мы получаем значение x
00:03:23
то есть мы получаем изначально адрес на
00:03:28
который мы указываем и далее мы хотим
00:03:30
получить по этому адресу значение
00:03:33
которое этот самый адрес сохранив таким
00:03:36
вот образом реализованы массивы они
00:03:38
соответственно могут в данном случае
00:03:40
продолжаться они могут расширяться если
00:03:42
они являются динамическими но в данном
00:03:44
случае мы будем рассматривать только
00:03:46
статические массивы
00:03:48
которые допустим выделяются именно по
00:03:51
заранее указанному количеству ну
00:03:54
допустим данном случае этот массив был
00:03:56
выделен для пяти элементов таким вот
00:03:59
образом ну и как вы понимаете здесь
00:04:02
существуют определенные плюсы у таких
00:04:05
массивов и существуют определенные
00:04:07
минусы самым главным плюсом массивов
00:04:11
является то что индексация алиментов
00:04:13
происходит за константное время и это
00:04:16
константное время отображают как о
00:04:18
большую от
00:04:19
и c это говорит о том что мы можем любой
00:04:22
элемент этого массива взять сразу же без
00:04:28
всякого перебора
00:04:29
самого массива как мы сделали допустим
00:04:32
здесь
00:04:33
то есть нам необходимо просто знать
00:04:34
индекс того элемента который мы хотим
00:04:38
взять и все
00:04:39
этого уже достаточно но существует у
00:04:42
массивов также определенные минусы и
00:04:46
в качестве основного минуса выделяют
00:04:49
добавление и удаление элементов
00:04:51
представим что нам необходимо добавить
00:04:54
некий элемент
00:04:55
y между вот этими двумя элементами то
00:04:59
есть между адресом допустим 2 которые
00:05:01
хранить значение z и между адресом 3
00:05:04
который хранит значение x нам необходимо
00:05:06
вот этот элемент добавить внутрь что в
00:05:09
итоге у нас происходит а происходит то
00:05:11
что необходимо сдвинуть вот этот элемент
00:05:14
на одну позицию вперед а вот этот
00:05:16
элемент
00:05:17
еще на одну позицию вперед для того
00:05:19
чтобы занести значение y в итоге это все
00:05:24
сводится к тому что мы затрачиваем не
00:05:26
константное время добавления
00:05:28
а мы затрачиваем линейное время
00:05:30
добавления то есть большой от н это
00:05:33
говорит о том что нам необходимо по
00:05:34
факту перебирать наш массив
00:05:37
вот такая вот время для добавления
00:05:41
элементов является достаточно
00:05:43
скажем так плохим результатом далее
00:05:46
точно также происходит и удаление
00:05:49
представим что мы хотим удалить значение
00:05:51
z ну то есть пытаемся вот так сделать в
00:05:54
итоге у нас производится почти штат
00:05:57
аналогичные действия только вместо того
00:05:59
чтобы сдвигать и все элементы вправо мы
00:06:01
сдвигаем их влево то есть нам необходимо
00:06:04
сдвинуть стройку влево нам необходимо
00:06:06
сдвинуть
00:06:07
четверку влево таким образом удаление
00:06:11
точно так же как и добавления будет за
00:06:13
линейное время происходить помимо всего
00:06:17
прочего массивов также есть еще один
00:06:20
минус а именно то что что если нам
00:06:22
необходимо найти значение x
00:06:24
если мы не знаем его индексом
00:06:27
в итоге нам по факту перри придется
00:06:29
перебирать все элементы это точно также
00:06:32
является линейным временем то есть
00:06:36
большой от н нам придется перебирать
00:06:38
этот самый массив и вот такие вот минусы
00:06:41
и плюс обладает такими минусами и
00:06:45
плюсами обладают массивы соответственно
00:06:48
теперь зная то как организована память
00:06:51
массивов и какие у него у них есть плюс
00:06:54
и минус мы попробуем разобрать что
00:06:55
представляете себя непосредственно уже
00:06:57
списке ну и вот списке на самом деле
00:07:02
представляют из себя совершенно другой
00:07:04
вид памяти то есть вид хранения данных
00:07:08
суть здесь теперь заключена в том что
00:07:10
представим что у нас есть некая
00:07:12
переменная лист теперь она хранится
00:07:16
память непоследовательно а совершенно в
00:07:19
произвольном порядке но соответственно
00:07:21
возникает вопрос если память будет
00:07:23
храниться в произвольном порядке как нам
00:07:26
достать нужный элемент
00:07:28
то есть список может хранить наши данные
00:07:32
совершенно в разнообраз то есть где-то в
00:07:35
оперативной памяти в одной хранится
00:07:39
ячейки где-то в другой и так далее и при
00:07:41
этом они не являются последователями и
00:07:43
суть заключается в указателях
00:07:46
то есть представим что у нас есть некий
00:07:50
элемент в этом самом списке и самая
00:07:54
минимальная модель списка выглядит
00:07:56
следующим образом у нас есть само
00:07:58
значение и у нас есть указатель
00:08:03
указатель по факту является тем же самым
00:08:05
что им адрес адрес вот этой самой ячейке
00:08:09
но суть здесь немного и еще и иная вот
00:08:13
этот указатель способен указывать еще и
00:08:16
на другую ячейку
00:08:18
этого самого списка представим что у нас
00:08:20
здесь еще есть некий элемент
00:08:22
называем его как y и вот здесь есть
00:08:25
указатель ptr2 и при этом вот вот эта
00:08:32
линия не является последовательный то
00:08:33
есть здесь еще какие то могут данные
00:08:35
располагаться допустим еще какой-то
00:08:37
массив выделяться программы
00:08:40
могут еще какие то там перемены могут
00:08:44
указать или еще какие-то выделяться и
00:08:46
так далее то есть вот эта область памяти
00:08:49
является по факту для нас туманной и
00:08:52
списку при реализации списка совершенно
00:08:56
не нужно знать что находится между этими
00:08:58
двумя элементами
00:08:59
потому что указатель он дает понимание
00:09:03
того какой следующий элемент идет после
00:09:07
него соответственно это является
00:09:09
основной концепции списка но есть также
00:09:13
второй вопрос как нам понять чем
00:09:16
ограничен список если у нас один
00:09:19
указатель должен указывать на другой
00:09:21
указатель а что вот этот указатель
00:09:23
должен делать на что он должен указывать
00:09:26
если допустим этот список состоит всего
00:09:28
из двух элементов и суть здесь заключена
00:09:30
в том что вот этот указатель должен
00:09:32
указывать на нулевое значение
00:09:34
назначением ул если он указывает на
00:09:37
значение null
00:09:38
это говорит о том что список был
00:09:40
полностью завершён то есть и в нем уже
00:09:43
нет элементов кроме этих двух
00:09:47
таким образом вот такая концепция списка
00:09:50
она достаточно хороша именно в плане
00:09:53
динамичности то есть мы можем распор
00:09:56
создавать элементы по факту бесконечны и
00:09:59
мы ограничены лишь
00:10:00
операционной системой которая способна
00:10:02
выделять память ну либо непосредственно
00:10:05
самой памятью компьютера при этом эти
00:10:09
элементы могут в памяти располагаться
00:10:11
как угодно в отличие от массива которому
00:10:14
нужно именно определенное конкретное
00:10:17
число для выделенных элементов
00:10:21
соответственно в данном случае вопросы
00:10:24
возникают следующие в чем плюсы вот
00:10:28
таких списков от массивов во-первых
00:10:32
добавление элементов список может быть
00:10:35
разным то есть в то время как в
00:10:39
массиве мы можем допустим только в конец
00:10:42
добавляйте
00:10:44
хорошо спит ну какой либо элементы за
00:10:47
константное время если этот
00:10:49
если эта ячейка не было нечем заняться
00:10:52
то здесь же в списках мы можем по факту
00:10:55
добавлять совершенно в любую позицию за
00:10:58
время о 1 то есть большое от единицы но
00:11:03
с оговоркой с оговоркой того что если мы
00:11:05
знаем указатель вот эти два указателя
00:11:09
это первая оговорка соответственно если
00:11:14
мы не знаем вообще указателей то есть
00:11:18
мне не располагаем ими сразу же в
00:11:21
программе то в итоге добавления будет
00:11:23
занимать
00:11:24
линейное время то есть от большой от n
00:11:28
при этом стоит сказать то что линейное
00:11:31
время точно также как допустим в массиве
00:11:33
может характеризоваться как о большой от
00:11:36
единицы если мы добавляем элемент в
00:11:38
начало то есть список всегда указывает
00:11:42
на начальный указатель при этом
00:11:45
соответственно мы обязаны всегда знать
00:11:48
этот самый начальный указатель если мы
00:11:50
его знаем и мы добавляем только самое
00:11:53
начало то мы будем всегда добавлять за
00:11:55
константное время это точно так же
00:11:58
справедливо для массива но в данном
00:12:00
случае мы должны будем тогда в конец
00:12:02
добавлять если элемент не был занят ну
00:12:04
как вы понимаете если мы выделяем массив
00:12:07
статичный то элемент рано или поздно
00:12:10
закончится но здесь списке являются
00:12:14
динамическими и по факту мы можем
00:12:16
добавлять теоретически до бесконечности
00:12:19
это первый момент второй момент поиск
00:12:23
элементов занимает точно также линейное
00:12:26
время ну то есть если мы не знаем какой
00:12:28
либо яндекс но иисус здесь заключена в
00:12:31
том что в списках нет индексации как бы
00:12:35
это странно не звучало то есть мы знаем
00:12:37
только указатели
00:12:38
но индексов как таковых здесь не
00:12:40
существует потому что памяти разбросана
00:12:42
по участкам оперативной памяти и
00:12:44
соответственно о никакой индексации речи
00:12:47
здесь и не может быть дано именно
00:12:49
конкретно для ада связных списков
00:12:52
соответственно как индексации алиментов
00:12:56
таки поиск элемента будет за
00:12:58
линейное время ну и стоит сказать про
00:13:02
удаления элементов и удаление здесь
00:13:07
точно также как и добавление то есть она
00:13:10
может быть как за константное время так
00:13:13
и за линейное время все зависит от того
00:13:15
каким какой информацией мы обладаем по
00:13:18
факту доения может точно также быть на
00:13:20
первый элемент и если это так то это
00:13:23
будет всегда являться констант нам
00:13:25
временем если же удаление элемента будет
00:13:27
где-то в конце либо где то в середине
00:13:29
это будет занимать линейное время вот в
00:13:33
принципе таким образом списке и
00:13:35
характеризуется соответственно мы
00:13:36
разобрали основные плюсы и минусы
00:13:39
массивов плюсы-минусы списков ost
00:13:42
основной плюс списков это то что они
00:13:44
являются динамическими и то что можно
00:13:46
легко добавлять в элементов где ибо
00:13:50
внутрь допустим этого самого списка в
00:13:53
начала в конец так далее без заморочек
00:13:57
насчет того что список будет как либо
00:14:00
переполнен это первый момент в принципе
00:14:03
ну и последний ну и соответственно
00:14:09
вопрос заключён в том для чего нужны вот
00:14:12
эти самые 1 связанные списки сами по
00:14:14
себе не используется достаточно редко то
00:14:17
есть как самостоятельный тип данных они
00:14:20
используются редко но вот как составной
00:14:23
тип данных допустим для создания
00:14:26
деревьев либо для создания хэш-таблица
00:14:29
не используются достаточно частым и как
00:14:32
раз вот эти типы данных подобие деревьев
00:14:34
и хэш-таблиц мы так же попробуем в
00:14:36
следующих видео разобрать ну и в
00:14:38
принципе все стёре более-менее закончили
00:14:41
то есть здесь ничего так сильно много о
00:14:44
них рассказывайте и следует приступать
00:14:46
уже больше к практике и к пониманию того
00:14:49
как это все у нас будет реализовываться
00:14:52
ну и что ж давайте приступать вот мы и
00:14:56
здесь и мы попробуем как и в прошлом
00:14:59
видео с бедной арифметикой попробуем
00:15:01
изначально создать интерфейс твой
00:15:03
функции то есть те функции как
00:15:05
будет являться по факту основными для
00:15:07
нашей реализации 1 связанного списка в
00:15:12
первую очередь нам необходимо понять как
00:15:14
будет выглядеть структура то есть в
00:15:16
данном случае пишем той dfs тракт
00:15:18
лист ну и вот здесь вот у нас будет так
00:15:21
же лист вот так назовем этот тип данных
00:15:23
далее что в нем должно располагаться во
00:15:26
первых должна располагаться
00:15:29
и та же самая структура как бы это
00:15:31
странно не звучало суть здесь больше
00:15:33
заключена в том что одна связанные
00:15:35
списки являются по факту рекурсивными
00:15:37
списками то есть они способны указывать
00:15:40
сами на себя и вот это выглядит
00:15:43
следующим образом то есть по факту
00:15:45
односвязный список характеризуется одним
00:15:48
элементом который способен указывать на
00:15:52
следующий элемент который точно также
00:15:55
способен указывает на следующий элемент
00:15:56
и так далее и соответственно это
00:15:59
является в большей мере
00:16:00
рекурсивный способ выражения этих самых
00:16:03
1 связанных списков помимо всего прочего
00:16:05
здесь должен храниться какие-либо
00:16:08
элементы для упрощения мы конечно могли
00:16:11
бы использовать здесь какой-то элемент x
00:16:14
какого-то конкретного типа данных и так
00:16:17
далее но интерес 1 связанных списков
00:16:20
заключен в том что они способны хранить
00:16:22
не только один тип данных
00:16:24
они способны хранить по идее сразу
00:16:27
несколько типов данных
00:16:29
разнородных то есть они могут хранить
00:16:31
одновременно как string так и intel и и
00:16:34
значения float' значение и так далее и
00:16:36
вот и в этом заключается ещё одно
00:16:39
великолепие
00:16:40
списков ну и давайте это попробуем
00:16:43
реализовать мы попробуем реализовать
00:16:46
такой такой вид данных при помощи union
00:16:49
of june вам очень схожи со структурой но
00:16:55
есть одна
00:16:56
исключительная особенность а именно то
00:16:58
что union способен хранить различные
00:17:00
типы данных в одной области памяти то
00:17:04
есть он выделяет лишь одну область
00:17:05
памяти для хранения всех значений
00:17:08
которые он способен содержать ну и в
00:17:10
данном случае мы его
00:17:12
охарактеризуем следующим образом
00:17:13
допустим в л.ю. лист то это будет у нас
00:17:17
в данном случае
00:17:18
тип данных и соответственно это будет
00:17:21
представлять себя
00:17:22
значение которое хранит этот самый
00:17:25
список ну и здесь мы можем хранить
00:17:27
давайте подключим библиотеку с today and
00:17:30
std tags и таким вот образом и здесь у
00:17:36
нас могут храниться следующий типы
00:17:37
данных допустим или 64
00:17:39
де смол то есть целочисленное значение у
00:17:43
нас будет храниться далее здесь у нас
00:17:44
будет хранится значение реал то есть
00:17:48
вещественные
00:17:49
и далее здесь у нас будет допустим
00:17:51
хранится строка нд
00:17:52
назовем следующим образом указатель на
00:17:55
строку
00:17:56
вот в принципе таким образом у нас будет
00:17:59
храниться какой-либо тип данных ну как я
00:18:02
говорил ранее union вот эти все типы
00:18:05
данных вот эти все значения хранит в
00:18:07
одной области памяти соответственно если
00:18:09
мы перезапишем децл перри запишется и
00:18:12
вот эти данные соответственно здесь
00:18:15
необходимо хранить иш изначально
00:18:19
выбранный тип данных ну и соответственно
00:18:21
чтобы понимать списку с каким типом
00:18:24
данных мы имеем значения нам необходимо
00:18:27
создать некую некие константы которые будут
00:18:29
характеризовать то что это является
00:18:31
целочисленным значением то что это
00:18:33
является вещественным значением то что
00:18:36
это является строкой
00:18:37
соответственно в данном случае мы
00:18:39
создаем константы при помощи и вот здесь
00:18:44
мы указываем это следующим образом
00:18:45
допустим в той дальней лист т но в этой
00:18:49
пт well you time в данном случае мы
00:18:51
указываем следующие константы у нас
00:18:53
будет константой и нет элем это
00:18:57
константа будет по факту
00:18:59
единственный в своем роде оно будет
00:19:01
характеризовать то что список был создан
00:19:05
то есть в данном случае мы представим
00:19:07
таким вот образом то есть у нас здесь
00:19:09
есть а и нет список то есть создание
00:19:15
списка и у нас есть конец этого самого
00:19:17
списка мы будем придерживаться примерно
00:19:20
такой логике далее у нас что здесь будет
00:19:23
ещё находиться но здесь у нас будет
00:19:25
децима этим то есть то что это число
00:19:28
является
00:19:29
целочисленным то что это число является
00:19:31
вещественным это что это число является
00:19:33
as начать то что этот элемент является
00:19:37
страховым и стоит сказать то что здесь я
00:19:41
начинаю все с нижнего подчеркивание
00:19:43
чтобы не было никаких казусов если вдруг
00:19:46
вы будете использовать все эти функции
00:19:50
как библиотека ну то есть вынести их
00:19:52
дуге теку соответственно в данном случае
00:19:54
я сделал специально с нижним
00:19:56
подчёркиванием чтобы не было никаких
00:19:58
конфликтов
00:19:59
типов ну и все теперь давайте попробуем
00:20:02
разобрать какие у нас должны будут
00:20:04
реализованы функции
00:20:06
ну во первых у нас будет функция
00:20:08
создание этого самого списка то есть в
00:20:11
данном случае пишем не юрист и вот здесь мы должны
00:20:14
принимать формат строкой и
00:20:18
неограниченное количество элементов
00:20:20
то есть что это говорит мы будем по идее
00:20:22
писать следующим образом то есть
00:20:24
допустим мы создаём некий тип данных
00:20:27
лист который будет выглядеть следующим
00:20:29
образом допустим я хочу добавить значение dds
00:20:32
мол далее хочу добавить значение реал
00:20:35
хочу добавить значения string у нас
00:20:39
будут следующие обозначения то есть
00:20:41
всего и будет в данном случае 3 ну и
00:20:44
соответственно далее я допустим здесь
00:20:46
ввожу значение 555 далее допустим 1.23 и
00:20:52
вот здесь ввожу значение
00:20:54
хеллоу ворлд таким вот образом и вот так
00:21:00
должен будет создаваться у нас список
00:21:03
в итоге в этом списке будет по идее три
00:21:05
элемента если мы не будем учитывать
00:21:08
инициализирующий элемент он будет
00:21:10
представлять себя просто пустой элемент
00:21:12
который не отображается и не более того
00:21:15
ну и в конце будет еще хранится
00:21:17
указатели на 0 в этом самом списке
00:21:21
но это для обычного пользователя или
00:21:24
просто для программиста который будет
00:21:26
использовать вот эту мини библиотеку
00:21:29
скажем так для него это не будет
00:21:32
проблемой в том плане что он не будет по
00:21:34
идее
00:21:35
знать о том что где-то там хранится
00:21:37
нулевое значение где-то хранится
00:21:39
инициализирующий элементов и тому
00:21:41
подобное для него это будет
00:21:42
абстрагировано вот мы определению лист
00:21:46
далее у нас должна быть еще одна функция
00:21:49
соответственно если мы создаем список
00:21:51
нам необходимо еще его и освобождать то
00:21:54
есть иметь возможность освобождения но и
00:21:55
в данном случае у нас будет функция
00:21:57
friis который будет принимать лишь
00:21:59
указатель на этот самый список лист
00:22:02
далее как и говорил ранее мы будем
00:22:05
реализовывать две функции to push & pop
00:22:08
соответственно в данном случае мы
00:22:11
реализуем функцию push лист который
00:22:13
будет достаточно похожи на не юрист но
00:22:17
здесь еще будет добавлен один аргумент
00:22:19
вот такой то есть нам необходимо указать
00:22:23
в какой список нам необходимо добавлять
00:22:26
вот эти самые элементы ну и далее у нас
00:22:28
будет так же toplist
00:22:30
давайте сделаем следующим образом и вот
00:22:34
здесь мы должны указать только сам этот
00:22:36
список можно задаться вопросом для чего
00:22:40
нам необходимо возвращать в данном
00:22:42
случае при пуше указатель на лист судьи
00:22:46
заключена в том что при пуше мы будем
00:22:50
каждый раз возвращать на самый последний
00:22:52
элемент то есть как только мы затушили
00:22:55
некое значение допустим число 5 в итоге
00:22:58
вернется список с указанием позиции на
00:23:01
эту самую пятерку
00:23:02
для чего это нужно это нужно для того
00:23:05
чтобы добавление элементов было за
00:23:07
константное время
00:23:08
то есть если мы знаем указатель то есть
00:23:12
смотрите если мы знаем указатель на
00:23:14
самый последний элемент то добавление
00:23:17
нового элемента будет происходить за
00:23:19
константное время
00:23:20
а если бы мы не знали нам бы не
00:23:23
необходимо было добраться до последнего
00:23:25
элемента которые указывают на значения
00:23:27
null и только потом уже добавлять
00:23:29
то есть как вы понимаете есть
00:23:31
определенная логика между константам
00:23:33
временем и линейным временем
00:23:35
соответственно в данном случае у нас
00:23:37
будет указывать всегда на последний
00:23:39
элемент по крайней мере возвращать этот
00:23:41
самый последний элемент список же то чая
00:23:45
функция же поп будет возвращать нам
00:23:47
указатель на последней
00:23:49
лента а далее этот элемент приравнивать
00:23:53
к окну таким вот образом то есть вот
00:23:58
этот элемент будет уже указывать не на y
00:24:02
она ну вы и так далее то есть если
00:24:04
второй раз мы сделаем поп и не будет уже
00:24:07
указывать на ну и при этом возвращаться
00:24:10
будет вот это вот эти данные то есть
00:24:13
первое допустим ячейка будет
00:24:15
возвращаться там 2 4 так далее
00:24:17
соответственно поп это удаление элемента
00:24:20
push это добавление элемента ну и далее
00:24:23
у нас конечно же должна быть еще функция
00:24:28
печатание этого самого списка в данном
00:24:31
случае нам необходимо указать лишь сам
00:24:34
список ну и все то есть с основными
00:24:36
интерфейсами мы разобрались теперь
00:24:38
давайте посмотрим как это должно у нас
00:24:40
выглядеть в данном случае у нас будет
00:24:42
лист давайте это скопирую
00:24:46
таким вот образом не юрист далее
00:24:49
допустим мы захотим добавить в него то
00:24:53
есть мы делаем уж лист далее здесь
00:24:55
указываем лист здесь указываем допустим
00:24:58
что мы хотим еще добавить ну допустим d
00:25:01
здесь 5 1 как пример мы добавляем далее
00:25:06
здесь у нас возвращает указатель на
00:25:08
самый последний элемент тэн и дать и вот
00:25:11
этот указатель мы можем использовать для
00:25:13
последующего добавления то есть давайте
00:25:16
вот следующим образом сделаем здесь у
00:25:19
нас будет допустим 123 добавляться стоит
00:25:23
кстати заметить что мы бы могли также
00:25:25
сделать следующим образом допустим 23
00:25:28
никто бы это нам не мешал сделать когда
00:25:30
мы это все производим следующим образом
00:25:32
ну так или иначе я просто в данном
00:25:34
случае показываю что вот такой пример он
00:25:37
будет более валидным если бы мы всегда
00:25:39
указывали лист
00:25:40
то есть в данном случае если мы
00:25:42
указываем темп тотем всегда указывает на
00:25:44
самый последний элемент соответственно
00:25:46
все при добавлении происходит за
00:25:47
константы за константы время
00:25:50
если бы мы указывали всегда лист здесь
00:25:53
ну то есть здесь лист здесь лист здесь
00:25:56
несли тогда не in the все бы происходило
00:25:58
за линейное время то есть нам бы
00:26:00
необходимо было от венеции инициирующего
00:26:04
значение идти до самого последнего все
00:26:07
здесь надеюсь более-менее разобрались но
00:26:10
и давайте допустим print лист напишем и
00:26:12
вот здесь нам необходимо указать лист
00:26:14
потому что темп указывает на самый
00:26:16
последний элемент есть указывает на
00:26:18
корневой элемент то есть на и нет все
00:26:21
наконец то мы в данном случае с
00:26:23
интерфейсной частью разобрались теперь
00:26:25
нам необходимо лишь понять как нам
00:26:27
создавать этот самый слизь а кстати
00:26:30
здесь я забыл нам необходимо конечно же
00:26:32
его освободить этот самый список все
00:26:35
теперь давайте попробуем разобраться с
00:26:37
тем как создать нам первоначальную
00:26:40
версию не юрист в данном случае все достаточно
00:26:42
просто то есть мы должны создать эти в
00:26:46
данных лист для которого мы должны
00:26:48
выделить память при помощи функции малак
00:26:51
в данном случае
00:26:52
чтобы ее использовать нам необходимо
00:26:55
подключить библиотеку с т.д.
00:26:56
клип . нам необходимо использовать малак
00:27:01
и далее необходимо сделать размер под
00:27:04
лист таким образом мы создали переменную
00:27:07
этого самого типа данных
00:27:09
далее нам необходимо указать еще они ст
00:27:13
бтр назовем его так
00:27:16
который будет указывать на вот этот
00:27:19
самый листинг и мы должны вернуть сам
00:27:23
лист а в данном случае для чего нужен
00:27:25
нам вот это вот этот указатель будет
00:27:29
просто у нас всегда сдвигаться ну то
00:27:31
есть когда мы будем читать вот эту
00:27:33
форматированию строку у нас этот
00:27:35
указатель будет каждый раз указывать на
00:27:36
самый последний элемент добавленный в то
00:27:40
время как вот этот вот эта перемена
00:27:43
будет указывать всегда на и nitzyy
00:27:45
инициирующий элемент поэтому нам
00:27:48
необходимо указать не самые последние
00:27:50
добавленные элементы а самый первый а
00:27:53
созданный элемент вот и все далее нам
00:27:57
здесь необходимо указать во-первых тип
00:28:01
которые у нас также
00:28:03
тип элемента в данном случае так как мы
00:28:07
создаем новый список то мы должны
00:28:09
указать вот этот инициирующий элемент
00:28:12
дании что нам необходимо сделать это
00:28:14
указать то что он следующий список
00:28:17
является по факту нулевым то есть он еще
00:28:20
не определен
00:28:21
соответственно у нас будет и нет пока
00:28:23
что указывать просто на ну таким вот
00:28:25
образом далее здесь мы делаем в люк лист
00:28:33
который будет хранить все различные
00:28:37
элементы ну как мы видели здесь этот тип
00:28:41
данных способен хранить все различные
00:28:43
элементы то есть как интеджер дабл
00:28:46
и строку теперь мы должны при помощи во
00:28:51
лист создать перебор всех тех элементов
00:28:56
которые являются неопределёнными по их
00:28:59
количеству соответственно в данном
00:29:01
случае нам необходимо воспользоваться
00:29:03
тремя функциями во первых эта функция
00:29:06
вас старт который указывает фактор то
00:29:09
есть вот этого типа во лист и далее нам
00:29:12
необходимо указать форма то есть от
00:29:14
которых от какого элемента мы начинаем
00:29:16
считывание не определенного количества
00:29:18
аргументов таким вот образом но и далее
00:29:22
в конце мы также должны сделать функцию
00:29:24
в and чтобы сразу уж не забыть и должны
00:29:27
указать это все нам фактор все теперь
00:29:31
что мы должны будем сделать нам
00:29:35
необходимо во-первых перебирать всю ту
00:29:37
строку форматируем который мы указали
00:29:40
это можно сделать следующим образом
00:29:42
пока формат делать следующие plus plus
00:29:46
формат в данном случае вот это значение
00:29:50
говорит о том что мы разыменовывает
00:29:51
каждый раз по одному символу
00:29:53
то есть посмотрели первый символ
00:29:55
посмотрели второй символ посмотрели 3
00:29:58
символ и так как строка всегда
00:30:00
оканчивается нулевым символом то есть
00:30:02
который равен
00:30:05
нулевым символом который равен просто
00:30:07
мою
00:30:08
томас в итоге вызовется фолз потому что
00:30:11
в языке программирования си фолз равен
00:30:14
нулю
00:30:15
ну то есть
00:30:16
следующим образом фолз равен нулю
00:30:18
соответственно у нас этот цикл сразу же
00:30:20
прекратится
00:30:21
ну и далее мы должны проверять какое же
00:30:23
значение было взято то есть форма switch
00:30:27
формат и далее здесь во-первых мы должны
00:30:29
указать д м то есть это целочисленное
00:30:33
значение мы также сделаем еще синоним то
00:30:36
есть int интеджер или
00:30:38
и так далее далее но здесь укажем
00:30:41
сначала брик далее точно так же кейс
00:30:44
rifle ну либо кейс
00:30:47
флоп точно так же сделаем синоним здесь
00:30:50
у нас точно так же будет брик и далее
00:30:52
здесь делаем мы просто как с это без
00:30:56
всяких синонимов уже будет это будет
00:30:58
характеризоваться строкой то есть
00:31:00
давайте здесь указан dexmo далее здесь
00:31:03
укажем рио
00:31:05
ну и здесь укажем string стоит заметить
00:31:09
то что нет никаких элементов для и
00:31:11
нецелевых инициирующего элемента потому
00:31:14
что он не является по факту никаким
00:31:16
элементом он просто представляет себя
00:31:19
начало списка и не более того
00:31:21
ну и соответственно делаем следующее
00:31:24
во-первых мы указываем well you
00:31:27
далее указываем то что это является dc
00:31:31
мол целочисленное значение и далее
00:31:33
указываем в арк то есть берем из фактора
00:31:38
элемент типа int64 т в итоге мы из не
00:31:44
определенного количества элемента взяли
00:31:45
вот это самый тип данных
00:31:48
точнее значением с этим типом данных
00:31:51
далее мы указываем listed r равняется и
00:31:55
в данном случае мы будем пользоваться
00:31:56
функцией push лист в данном случае
00:31:59
пушист лист поттер и здесь мы укажем d и
00:32:04
сюда передадим в мдц move таким вот
00:32:07
образом ну и точно так же делаем со
00:32:09
всеми остальными частями то есть здесь
00:32:12
мы указываем rifle здесь мы указываем
00:32:15
дабл здесь мы указываем точно также реал
00:32:19
здесь мы указываем
00:32:20
р
00:32:22
далее переходим сюда строку здесь мы
00:32:25
указываем
00:32:26
string следующим образом здесь точно
00:32:29
также string здесь мы указываем
00:32:31
указатель на uint8 т ну и здесь мы
00:32:34
указываем с все
00:32:36
вот в принципе таким образом мы создали
00:32:40
не юрист ну и как вы понимаете нам
00:32:42
необходимо реализовать для
00:32:44
функционирования этой функции
00:32:46
функцию push лист ну и давайте сначала
00:32:49
сначала давайте попробуем реализовать
00:32:52
фрист то есть фризе ст будет являться
00:32:57
достаточно легкой функции по своей
00:32:59
натуре то есть мы точно также сделана externa
00:33:02
будет free лист далее здесь показываем
00:33:04
вниз здесь суть заключена в том что нам
00:33:08
точно также необходимо сначала сохранить
00:33:10
указатель то есть лист поттер далее пока
00:33:16
не ст не равняется ну то есть пока мы не
00:33:19
дойдем до вот этого самого нулевого
00:33:21
значения нам необходимо
00:33:23
перебирать этот самый список но суть
00:33:27
здесь заключена в следующем то есть нам
00:33:29
во первых с началом необходимо сохранить
00:33:31
это значение которое мы берем то есть
00:33:34
сохраняем его
00:33:35
далее освобождаем значении у это а мы
00:33:39
берем не просто они ст мы берем лист
00:33:42
next
00:33:43
то есть мы указываем на следующий
00:33:46
элемент который хранится в этом списке
00:33:51
ну то есть указываем по факту следующий
00:33:54
элемент этого списка далее мы
00:33:55
освобождаем элемент лист то есть теперь
00:34:00
памяти это ячейки освобождена и далее мы
00:34:03
указываем мистером лист бтр ну то есть
00:34:06
просто переходим на следующую ячейку и
00:34:08
так далее то есть представим что у нас
00:34:10
здесь
00:34:12
представим что давайте здесь представим
00:34:15
что у нас идет первые chayka 2 ч и к
00:34:17
но и 3 очень к соответственно мы сначала
00:34:20
берем первую ячейку
00:34:21
далее а мы сохраняем значение вот этой
00:34:25
ячейки то есть ptr1 next сохраняем это
00:34:29
значение далее удаляем эту ячейку и
00:34:32
далее переносим переносим ее с равными
00:34:36
лист поттер то есть на вот эту ячейку
00:34:39
далее мы точно так же делаем переносим
00:34:42
значения сохраняем а вот здесь удаляем
00:34:44
эту ячейку переносимся на эту ячейку и
00:34:47
смотрим если лист равняется нулю тогда
00:34:49
прекратите этот тогда прекратить этот
00:34:52
цикл и в принципе все в итоге у нас
00:34:54
освобождение памяти просто заканчивается
00:34:56
и эта функция достаточно в данном случае
00:35:01
как понимать им легкое по сравнению со
00:35:04
всеми другими ну и давайте попробуем
00:35:05
реализовать функцию push лес функция
00:35:08
push лист будет достаточно похожа по
00:35:10
своей структуре на вот эту функцию
00:35:12
давайте сразу скопируем в данном случае
00:35:14
напишем пушист здесь распишем лист
00:35:18
просто ну и и в данном случае во-первых
00:35:20
давайте вот это сначала все удалим вот
00:35:26
это удаляем далее здесь мы пишем
00:35:29
если лист равняется нулю то есть если он
00:35:34
уже по умолчанию указывает назначения 0
00:35:38
значит здесь мы делаем следующее
00:35:40
указываем ошибку но и здесь пишем просто
00:35:44
лист из ну ну и возвращаем значение в
00:35:48
итоге у нас ошибка будет плеваться в
00:35:51
стандартный поток вывода ошибок о том
00:35:55
что мы пытаемся внести значение в 0
00:35:59
список ну то есть список который у
00:36:02
которого даже не существует
00:36:03
инициирующего элемента
00:36:04
это первое значение далее если же список
00:36:07
не равняется нулю тогда мы должны
00:36:09
перебор его перебирать то есть если лист
00:36:13
next не равняется нулю мы должны идти по
00:36:18
списку то есть ест + +
00:36:23
так точнее не лист плюс плюс они
00:36:25
сравняются ест next
00:36:29
вот таким образом это будет лучше так
00:36:31
далее здесь мы это оставляем фактор
00:36:35
оставляем форма поставляем далее вот
00:36:37
здесь точно также оставляем вот это нам
00:36:39
надо будет изменить
00:36:41
давайте здесь сделаем следующее то есть
00:36:44
во первых у нас точно так же должен быть
00:36:46
в лёд далее здесь мы должны точно также
00:36:50
взять значение work
00:36:52
далее здесь указать фактор далее здесь
00:36:55
из 64
00:36:56
все указали далее нам необходимо
00:36:58
освободить ее память под лист next то
00:37:02
есть так как лист next указывает
00:37:04
назначению ну как вы понимаете то есть
00:37:06
мы всегда перебирать это мы делаем вот
00:37:09
такой перебор мы делаем для того чтобы
00:37:10
определить самый последний элемент
00:37:12
который не равен нулю и вот этот элемент
00:37:15
не равен нулю а следующие за ним
00:37:17
значения как раз равняется значение мол
00:37:21
соответственно необходимо освободить
00:37:23
память для вот этой ячейки мы это делаем
00:37:26
следующим образом точно также vest
00:37:29
далее используем функцию малак здесь
00:37:31
указываем side of mist
00:37:34
мы и в принципе всем далее мы
00:37:37
переносимся на вот эту самую позицию то
00:37:41
есть указываем лист нет далее мы что
00:37:43
делаем мы указываем тип тип в данном
00:37:46
случае будет dismal элем далее мы
00:37:48
указываем значение которое должно здесь
00:37:51
хранится в л.ю.
00:37:53
здесь указываем де смол и вот здесь мы
00:37:56
указываем в люб small таким вот образом
00:38:00
ну и соответственно указываем теперь на
00:38:03
следующий элемент как на ну все теперь
00:38:06
вот это все мы должны будем скопировать
00:38:09
и перенести сюда здесь заменить на реал
00:38:13
здесь изменить точно также налил и здесь
00:38:17
изменить на реал далее здесь мы должны
00:38:19
изменить на бабу конечно же ну и в
00:38:23
принципе все теперь тоже самое делаем со
00:38:26
строкой
00:38:27
то кстати здесь тоже самое у нас будет
00:38:30
три а далее здесь у нас будет string
00:38:34
здесь у нас будет string string далее
00:38:36
здесь у нас будет кстати вот здесь вот
00:38:38
так и вот здесь у нас будет
00:38:42
строковый тип данных далее указываем
00:38:45
лист и в принципе вроде как а вот здесь
00:38:48
еще uint8 т и указатель указатель на
00:38:55
символы все и в принципе вроде как с
00:39:00
пушем мы разобрались теперь нам
00:39:03
необходимо реализовать лишь последнюю
00:39:05
функцию а именно функцию поп и как бы
00:39:08
странно это ни звучало оно является
00:39:11
достаточно легкой то есть она является
00:39:13
даже легче чем не юрист и давайте
00:39:15
попробуем ее реализовать в данном случае
00:39:17
пишем экстерн далее здесь указываем wise
00:39:20
pop nist следующим образом
00:39:25
далее мы должны указать этот самый
00:39:28
список ну и вот здесь мы должны точно
00:39:31
также во-первых проверить значения то
00:39:33
есть если список уже был равен нулю
00:39:35
тогда оповестить то что здесь есть
00:39:38
существует по крайней мере ошибка далее
00:39:42
если лист next равен нулю тогда мы
00:39:48
должны будем вернуть лист в данном
00:39:53
случае это говорит о том что мы не можем
00:39:55
взять по факту предыдущий элемент если
00:39:58
мы возьмем предыдущие мы не знаем адрес
00:40:01
предыдущего элемента который хранится за
00:40:03
этим потому что поп удаляет вот этот как
00:40:06
раз элемент и он является в данном
00:40:09
случае для этого списка последним если
00:40:12
мы его удалим тогда мы не можем не
00:40:14
сможем для предыдущего элемента указать
00:40:17
то что вот этот элемент является нулевым
00:40:19
и соответственно у нас будет
00:40:20
определенная ошибка памяти
00:40:22
соответственно нужно знать как минимум
00:40:25
предыдущие элементы этого элемента иными
00:40:29
словами представим что вот этот элемент
00:40:33
вот эта функция аргумент который мы
00:40:36
передали в эту функцию указывает на вот
00:40:38
эту ячейку памяти если мы ее удалим эту
00:40:43
ячейку памяти
00:40:44
то вот здесь мы не сможем никак указать
00:40:47
на знать
00:40:48
нему в итоге что будет происходить мы
00:40:52
когда будем перебирать значения вот эта
00:40:55
ячейка памяти по идее будет еще
00:40:56
сохранена в оперативной памяти и это
00:41:00
будет являться проблемой даже если эта
00:41:04
ячейка памяти была освобождена ну и
00:41:06
соответственно нам необходимо знать как
00:41:10
минимум еще и предыдущий предыдущую
00:41:13
ячейку то есть вот эту идем далее далее
00:41:17
нам необходимо сохранить во первых
00:41:19
привез не ст ну как вы понимаете то есть
00:41:23
предыдущую ячейку соответственно это
00:41:26
будет как сохраняться как лист и далее
00:41:28
нам необходимо сохранить
00:41:31
по ст лист это последнее последние
00:41:35
чей-то непосредственно на будет
00:41:37
заключаться как лист next далее пока
00:41:41
посты ст next не будет равняться нулю то
00:41:45
есть мы будем перебирать все значения
00:41:48
но если вы вот эта ячейка меры не
00:41:50
указывает на нуль
00:41:52
соответственно мы должны дойти до самого
00:41:55
последнего элемента и соответственно мы
00:41:57
должны каждый раз изменять previously ст
00:41:59
на в данном случае ost лист и далее
00:42:02
изменяем по ст mist
00:42:04
на fascist next в данном случае next
00:42:09
указывает как раз на следующий элемент
00:42:14
который идет до который идет и после
00:42:19
этого же самого посредством мы в
00:42:22
принципе далее мы что делаем мы
00:42:24
указываем previously ст равняется next
00:42:27
равняется ну то есть в данном случае
00:42:29
если бы вот эта ячейка является previews
00:42:33
лист это является поста есть
00:42:35
соответственно мы указываем previously
00:42:37
ст next то есть мы указываем на
00:42:38
следующие то что она равняется нулю
00:42:40
теперь то есть мы банально удаляем эту
00:42:43
самую чайку ну и соответственно все что
00:42:45
мы делаем в последующем это уже
00:42:49
возвращаем после ст то есть вот эту
00:42:51
самую удаленную ячейку ну и программист
00:42:55
уже должен сам обеспечить доступ к этой
00:42:58
память то есть а именно освобожден
00:43:00
этой самой последней ячейке он должен
00:43:02
сам произвести то есть указать просто
00:43:04
free на эту самую ячейку
00:43:05
ну и в принципе все то есть мы
00:43:09
реализовали не юрист уж лист toplist
00:43:12
free не ст ну и осталось последнее
00:43:13
функция наконец-то чтобы мы рассмотрели
00:43:17
будет ли это у нас работать или же не
00:43:19
будет соответственно эта функция будет
00:43:20
представлять себя print лист давайте
00:43:23
здесь print лист 0 здесь укажем лист
00:43:26
nist
00:43:27
здесь сначала мы укажем ну более менее
00:43:30
красивым то есть следующим образом будут
00:43:36
у нас скобочки далее пока лист не
00:43:40
равняется 0 то есть мы будем перебирать
00:43:43
этот самый список соответственно мы
00:43:47
должны будем вист
00:43:49
равняется ест next
00:43:52
делаем вот все сделали теперь мы должны
00:43:57
сравнить то есть при помощи switch on
00:43:59
сравниваем nist type и вот здесь теперь
00:44:03
смотрим если тип равен децл
00:44:06
элем тогда делать следующие действия
00:44:08
допустим брик далее если это равняется
00:44:12
riu el им тогда делать следующее
00:44:14
действие и соответственно если это
00:44:17
равняется
00:44:18
string элем тогда делать следующее
00:44:21
действие брик соответственно в данном
00:44:24
случае если это dismal элемент тогда мы
00:44:26
должны сделать printf так извиняюсь
00:44:31
printf в данном случае укажем дэн здесь с
00:44:34
пробелом здесь мы укажем лист
00:44:36
далее белую и здесь dismal далее мы
00:44:41
укажем на реал элемент далее здесь мы
00:44:44
укажем реал далее мы укажем нас
00:44:48
строковый то есть укажем string и в
00:44:51
принципе все в конце мы здесь закрываем
00:44:55
эти самые квадратные скобки в данном
00:44:59
случае как вы понимаете квадратные
00:45:01
скобки не совсем то и нужны но
00:45:03
принята как как принято списке вас на
00:45:07
вам всегда отображаются как квадратные
00:45:09
скобки ну и соответственно всем давайте
00:45:11
попробуем запустить пишем мейк и смотрим
00:45:15
так во первых ритер навесного л.ю.
00:45:19
так это где это 122 on да кстати здесь
00:45:25
нам необходимо в данном случае указать
00:45:27
как давайте здесь да как ну скорее всего
00:45:32
укажем потому что здесь у нас
00:45:35
указатель возвращается далее здесь у нас
00:45:37
также возвращается указатель
00:45:39
соответственно мы пишем точно так же ну
00:45:40
0 давайте проверим что у нас еще здесь
00:45:44
так так так так так так у нас на 49 49
00:45:52
так смотрим лист
00:45:55
type и вот здесь был ли стоит ну-ка
00:46:01
давайте посмотрим извиняюсь здесь у нас
00:46:07
еще я не вел этот
00:46:10
эту ячейку все давайте проверим и здесь
00:46:15
у нас еще определенные несостыковки
00:46:20
coloration а старт так смотрим а ну да
00:46:27
кстати для того чтобы воспользоваться
00:46:28
этими функциями нам необходимо еще за им
00:46:31
платить одну библиотеку это будет с т д
00:46:34
арк .
00:46:35
проверяем все наконец-то мы сделали но в
00:46:41
данном случае у нас есть какие то ошибки
00:46:44
давайте посмотрим здесь один-два-три
00:46:47
у нас не отобразилась нормальная у нас
00:46:50
не отобразилась нормально строка
00:46:52
вы давайте я сейчас попробую посмотреть
00:46:54
в чем у нас были ошибки до ошибка
00:46:57
достаточно глупо и как вы понимаете
00:46:59
здесь нам необходимо лишь указать string
00:47:02
и не более того
00:47:04
вот здесь нам необходимо указать loong
00:47:06
float чтобы мы отобразили легко
00:47:09
тип дабл еще давайте проверим мейк и как
00:47:13
выведем
00:47:15
нас все успешно отображается и при этом
00:47:17
хранения данных произошло совершенно
00:47:19
разных типов то есть целочисленные
00:47:23
вещественные и строковые кстати строками
00:47:25
можно отобразить немного иначе то есть
00:47:27
более красивым обвести как в кавычки вот
00:47:32
теперь мы можем легко отображать
00:47:34
следующие типы данных
00:47:35
ну и соответственно давайте попробуем
00:47:37
это все еще следующим образом
00:47:40
допустим 123 проверяем все верно далее
00:47:46
мы можем точно так же делать с поп
00:47:49
элементами то есть мы указываем
00:47:52
во-первых клоп лист далее указываем темп
00:47:54
далее указываем а точнее просто
00:47:58
указываем темп непосредственно и вот
00:48:00
здесь у нас будет возвращаться элементы
00:48:03
мы можем в принципе указывать арист
00:48:05
далее указывать print лист мы давайте
00:48:09
посмотрим как это будет выглядеть вот
00:48:11
такая запись не является хорошей потому
00:48:13
что у нас не будет производиться
00:48:16
освобождение памяти но для примера это в
00:48:19
принципе подойдет вот у нас вернулось
00:48:25
значение 3 далее давайте вот это сначала
00:48:29
сначала будем следующим образом
00:48:33
отображать ну и соответственно мы можем
00:48:35
сделать следующий следующий вид давайте
00:48:38
смотрим вот 3 далее 2157 один город 1.23
00:48:46
555 теперь если мы еще разок сделай то
00:48:50
есть у нас как вы понимаете не хранится
00:48:51
там никаких элементов
00:48:53
ну и соответственно у нас вернулся
00:48:54
пустой список то есть здесь уже будет
00:48:58
всегда возвращаться у нас пустой список
00:49:01
и при этом никакой ошибки у нас не
00:49:03
возникает но почему скажите вы а суть-то
00:49:06
заключена в том что мы хранилище
00:49:08
инициирующий и элемент который
00:49:10
представляет в себе по факту пустой
00:49:12
список и не более того но будет грамотно
00:49:15
делать под него таким образом а
00:49:18
следующим то есть в данном случае мы
00:49:19
указываем темп равняется toplist
00:49:22
далее пишем этот самый темп и далее мы
00:49:26
здесь должны освободить темп и в
00:49:30
принципе это уже будет куда более
00:49:32
грамотно вот ну и соответственно мы
00:49:35
можем в это все в цикл сделать то есть
00:49:38
сайт ted и равняется нулю и меньше
00:49:41
допустим 5 + + и это все в цикл кидаем и
00:49:45
посмотрим как это у нас будет
00:49:47
вычисляться 32 1571 доехал у ворот мы
00:49:53
можем так сделать в принципе даже до 10
00:49:55
у нас ничего а нет извиняюсь и ничего не
00:49:59
будет у нас действия освобождение памяти
00:50:02
для 0 ячейки производится поэтому у нас
00:50:05
в данном случае вызвалась ошибка потому
00:50:10
что мы пытаемся освободить то что уже по
00:50:13
идее освобождено потому что в данном случае
00:50:15
давайте посмотрим по priest потому что в
00:50:19
данном случае мы возвращаем уже лист
00:50:23
который указывает на нуль
00:50:25
и по факту мы его уже никак не сможем
00:50:28
освободить и вот такая вот такой способ
00:50:31
записи освобождение пустого списка он
00:50:33
является неприемлемым в данном случае
00:50:37
поэтому все здесь уже зависит
00:50:39
непосредственно от программиста и от
00:50:42
того как он будет это все сортировать то
00:50:46
есть ему необходимо будет уже
00:50:48
контролировать элементы по крайней мере
00:50:50
чтобы он не были за пределы и чтобы не
00:50:53
было никакой подобной ошибки но здесь
00:50:55
как вы понимаете в принципе точно сама
00:50:59
то же самое если вы пытаетесь там и
00:51:01
из окон вы пушить какое какое-то
00:51:04
значение которого уже не существует ну
00:51:06
то есть с стык уже в стеке уже ничего
00:51:09
допустим не хранится и вы хотите что-то
00:51:11
вы пушить оттуда здесь примерно то же
00:51:13
самое происходит ну и на этом пожалуй
00:51:15
все в качестве домашнего задания кстати
00:51:18
можно сделать следующие три интересные
00:51:21
функции в данном случае попробуйте
00:51:25
реализовать следующую функцию как
00:51:27
допустим ддл buy один лист в данном
00:51:34
случае и вот здесь мы должны
00:51:36
знать по идее указатель на лист далее
00:51:39
указать сам этот индекс
00:51:42
либо едешь ник далее похожие же функция
00:51:47
будет только здесь уже будет добавлением
00:51:49
то есть it buy айден и вот здесь будет
00:51:52
добавление элемента но здесь не просто
00:51:55
одного элемента добавления будет а
00:51:57
добавлением нескольких то есть мы
00:52:00
указываем по идее
00:52:01
формат и следующим образом
00:52:05
ну и в качестве 3 функции попробуйте
00:52:07
реализовать
00:52:09
давайте здесь запишем следующим образом
00:52:12
element in list
00:52:14
ну и как по названием вы понимаете нам
00:52:17
необходимо определить находится не этот
00:52:19
самый выбранный элемент в этом списке в
00:52:22
данном случае чтобы чтобы не иметь и
00:52:27
всяких проблем с void указателей не
00:52:29
тогда не и мы в принципе можем сделать
00:52:31
точно самое то есть формат и далее
00:52:34
передайте не определенное количество
00:52:36
аргументов ну и обработать лишь всего
00:52:38
лишь один аргумент и все это как самая
00:52:42
упрощенная запись в принципе будет здесь
00:52:44
вы указываете там то что это является dc
00:52:49
малый string или же флот домов ну и на
00:52:54
этом пожалуй все то есть как вы
00:52:57
понимаете списке они достаточно далеки в
00:52:59
своем понимании то есть они лишь хранят
00:53:02
значение они лишь указывают на следующий
00:53:04
элемент в этом списке но и
00:53:06
соответственно у нас идет о расширении
00:53:07
того что значение может быть разных
00:53:11
типов соответственно здесь еще и
00:53:12
необходимо указывать тип хранимого
00:53:15
элемента ну и на этом пожалуй все
00:53:17
надеюсь более менее понятно объяснила
00:53:19
если есть какие то вопросы пишите в
00:53:22
коментариях попробую на них
00:53:23
непосредственно ответить по этом пожалуй
00:53:25
все всем удачи всем пока

Описание:

list: https://github.com/Number571/C/blob/master/Templates/list.c

Готовим варианты загрузки

popular icon
Популярные
hd icon
HD видео
audio icon
Только звук
total icon
Все форматы
* — Если видео проигрывается в новой вкладке, перейдите в неё, а затем кликните по видео правой кнопкой мыши и выберите пункт "Сохранить видео как..."
** — Ссылка предназначенная для онлайн воспроизведения в специализированных плеерах

Вопросы о скачивании видео

mobile menu iconКак можно скачать видео "// Алгоритмизация #5 // Односвязный список //"?mobile menu icon

  • Сайт http://unidownloader.com/ — лучший способ скачать видео или отдельно аудиодорожку, если хочется обойтись без установки программ и расширений. Расширение UDL Helper — удобная кнопка, которая органично встраивается на сайты YouTube, Instagram и OK.ru для быстрого скачивания контента.

  • Программа UDL Client (для Windows) — самое мощное решение, поддерживающее более 900 сайтов, социальных сетей и видеохостингов, а также любое качество видео, которое доступно в источнике.

  • UDL Lite — представляет собой удобный доступ к сайту с мобильного устройства. С его помощью вы можете легко скачивать видео прямо на смартфон.

mobile menu iconКакой формат видео "// Алгоритмизация #5 // Односвязный список //" выбрать?mobile menu icon

  • Наилучшее качество имеют форматы FullHD (1080p), 2K (1440p), 4K (2160p) и 8K (4320p). Чем больше разрешение вашего экрана, тем выше должно быть качество видео. Однако следует учесть и другие факторы: скорость скачивания, количество свободного места, а также производительность устройства при воспроизведении.

mobile menu iconПочему компьютер зависает при загрузке видео "// Алгоритмизация #5 // Односвязный список //"?mobile menu icon

  • Полностью зависать браузер/компьютер не должен! Если это произошло, просьба сообщить об этом, указав ссылку на видео. Иногда видео нельзя скачать напрямую в подходящем формате, поэтому мы добавили возможность конвертации файла в нужный формат. В отдельных случаях этот процесс может активно использовать ресурсы компьютера.

mobile menu iconКак скачать видео "// Алгоритмизация #5 // Односвязный список //" на телефон?mobile menu icon

  • Вы можете скачать видео на свой смартфон с помощью сайта или pwa-приложения UDL Lite. Также есть возможность отправить ссылку на скачивание через QR-код с помощью расширения UDL Helper.

mobile menu iconКак скачать аудиодорожку (музыку) в MP3 "// Алгоритмизация #5 // Односвязный список //"?mobile menu icon

  • Самый удобный способ — воспользоваться программой UDL Client, которая поддерживает конвертацию видео в формат MP3. В некоторых случаях MP3 можно скачать и через расширение UDL Helper.

mobile menu iconКак сохранить кадр из видео "// Алгоритмизация #5 // Односвязный список //"?mobile menu icon

  • Эта функция доступна в расширении UDL Helper. Убедитесь, что в настройках отмечен пункт «Отображать кнопку сохранения скриншота из видео». В правом нижнем углу плеера левее иконки «Настройки» должна появиться иконка камеры, по нажатию на которую текущий кадр из видео будет сохранён на ваш компьютер в формате JPEG.

mobile menu iconСколько это всё стоит?mobile menu icon

  • Нисколько. Наши сервисы абсолютно бесплатны для всех пользователей. Здесь нет PRO подписок, нет ограничений на количество или максимальную длину скачиваемого видео.