[{"data":1,"prerenderedAt":1130},["ShallowReactive",2],{"navigation":3,"\u002Fblog\u002Fpython\u002Fst26":386,"\u002Fblog\u002Fpython\u002Fst26-surround":1125},[4],{"title":5,"path":6,"stem":7,"children":8,"page":114},"Blog","\u002Fblog","blog",[9,115,184,329],{"title":10,"path":11,"stem":12,"children":13,"page":114},"Ege","\u002Fblog\u002Fege","blog\u002Fege",[14,18,22,26,30,34,38,42,46,50,54,58,62,66,70,74,78,82,86,90,94,98,102,106,110],{"title":15,"path":16,"stem":17},"ЕГЭ Задание 1","\u002Fblog\u002Fege\u002Ftask1","blog\u002Fege\u002Ftask1",{"title":19,"path":20,"stem":21},"ЕГЭ Задание 10","\u002Fblog\u002Fege\u002Ftask10","blog\u002Fege\u002Ftask10",{"title":23,"path":24,"stem":25},"ЕГЭ Задание 11","\u002Fblog\u002Fege\u002Ftask11","blog\u002Fege\u002Ftask11",{"title":27,"path":28,"stem":29},"ЕГЭ Задание 12","\u002Fblog\u002Fege\u002Ftask12","blog\u002Fege\u002Ftask12",{"title":31,"path":32,"stem":33},"ЕГЭ Задание 13","\u002Fblog\u002Fege\u002Ftask13","blog\u002Fege\u002Ftask13",{"title":35,"path":36,"stem":37},"ЕГЭ Задание 14","\u002Fblog\u002Fege\u002Ftask14","blog\u002Fege\u002Ftask14",{"title":39,"path":40,"stem":41},"ЕГЭ Задание 15","\u002Fblog\u002Fege\u002Ftask15","blog\u002Fege\u002Ftask15",{"title":43,"path":44,"stem":45},"ЕГЭ Задание 16","\u002Fblog\u002Fege\u002Ftask16","blog\u002Fege\u002Ftask16",{"title":47,"path":48,"stem":49},"ЕГЭ Задание 17","\u002Fblog\u002Fege\u002Ftask17","blog\u002Fege\u002Ftask17",{"title":51,"path":52,"stem":53},"ЕГЭ Задание 18","\u002Fblog\u002Fege\u002Ftask18","blog\u002Fege\u002Ftask18",{"title":55,"path":56,"stem":57},"ЕГЭ Задание 19, 20, 21","\u002Fblog\u002Fege\u002Ftask19_20_21","blog\u002Fege\u002Ftask19_20_21",{"title":59,"path":60,"stem":61},"ЕГЭ Задание 2","\u002Fblog\u002Fege\u002Ftask2","blog\u002Fege\u002Ftask2",{"title":63,"path":64,"stem":65},"ЕГЭ Задание 22","\u002Fblog\u002Fege\u002Ftask22","blog\u002Fege\u002Ftask22",{"title":67,"path":68,"stem":69},"ЕГЭ Задание 23","\u002Fblog\u002Fege\u002Ftask23","blog\u002Fege\u002Ftask23",{"title":71,"path":72,"stem":73},"ЕГЭ Задание 24","\u002Fblog\u002Fege\u002Ftask24","blog\u002Fege\u002Ftask24",{"title":75,"path":76,"stem":77},"ЕГЭ Задание 25","\u002Fblog\u002Fege\u002Ftask25","blog\u002Fege\u002Ftask25",{"title":79,"path":80,"stem":81},"ЕГЭ Задание 26","\u002Fblog\u002Fege\u002Ftask26","blog\u002Fege\u002Ftask26",{"title":83,"path":84,"stem":85},"ЕГЭ Задание 27","\u002Fblog\u002Fege\u002Ftask27","blog\u002Fege\u002Ftask27",{"title":87,"path":88,"stem":89},"ЕГЭ Задание 3","\u002Fblog\u002Fege\u002Ftask3","blog\u002Fege\u002Ftask3",{"title":91,"path":92,"stem":93},"ЕГЭ Задание 4","\u002Fblog\u002Fege\u002Ftask4","blog\u002Fege\u002Ftask4",{"title":95,"path":96,"stem":97},"ЕГЭ Задание 5","\u002Fblog\u002Fege\u002Ftask5","blog\u002Fege\u002Ftask5",{"title":99,"path":100,"stem":101},"ЕГЭ Задание 6","\u002Fblog\u002Fege\u002Ftask6","blog\u002Fege\u002Ftask6",{"title":103,"path":104,"stem":105},"ЕГЭ Задание 7","\u002Fblog\u002Fege\u002Ftask7","blog\u002Fege\u002Ftask7",{"title":107,"path":108,"stem":109},"ЕГЭ Задание 8","\u002Fblog\u002Fege\u002Ftask8","blog\u002Fege\u002Ftask8",{"title":111,"path":112,"stem":113},"ЕГЭ Задание 9","\u002Fblog\u002Fege\u002Ftask9","blog\u002Fege\u002Ftask9",false,{"title":116,"path":117,"stem":118,"children":119,"page":114},"Oge","\u002Fblog\u002Foge","blog\u002Foge",[120,124,128,132,136,140,144,148,152,156,160,164,168,172,176,180],{"title":121,"path":122,"stem":123},"ОГЭ Задание 1","\u002Fblog\u002Foge\u002Ftask1","blog\u002Foge\u002Ftask1",{"title":125,"path":126,"stem":127},"ОГЭ Задание 10","\u002Fblog\u002Foge\u002Ftask10","blog\u002Foge\u002Ftask10",{"title":129,"path":130,"stem":131},"ОГЭ Задание 11","\u002Fblog\u002Foge\u002Ftask11","blog\u002Foge\u002Ftask11",{"title":133,"path":134,"stem":135},"ОГЭ Задание 12","\u002Fblog\u002Foge\u002Ftask12","blog\u002Foge\u002Ftask12",{"title":137,"path":138,"stem":139},"ОГЭ Задание 13","\u002Fblog\u002Foge\u002Ftask13","blog\u002Foge\u002Ftask13",{"title":141,"path":142,"stem":143},"ОГЭ Задание 14","\u002Fblog\u002Foge\u002Ftask14","blog\u002Foge\u002Ftask14",{"title":145,"path":146,"stem":147},"ОГЭ Задание 15","\u002Fblog\u002Foge\u002Ftask15","blog\u002Foge\u002Ftask15",{"title":149,"path":150,"stem":151},"ОГЭ Задание 16","\u002Fblog\u002Foge\u002Ftask16","blog\u002Foge\u002Ftask16",{"title":153,"path":154,"stem":155},"ОГЭ Задание 2","\u002Fblog\u002Foge\u002Ftask2","blog\u002Foge\u002Ftask2",{"title":157,"path":158,"stem":159},"ОГЭ Задание 3","\u002Fblog\u002Foge\u002Ftask3","blog\u002Foge\u002Ftask3",{"title":161,"path":162,"stem":163},"ОГЭ Задание 4","\u002Fblog\u002Foge\u002Ftask4","blog\u002Foge\u002Ftask4",{"title":165,"path":166,"stem":167},"ОГЭ Задание 5","\u002Fblog\u002Foge\u002Ftask5","blog\u002Foge\u002Ftask5",{"title":169,"path":170,"stem":171},"ОГЭ Задание 6","\u002Fblog\u002Foge\u002Ftask6","blog\u002Foge\u002Ftask6",{"title":173,"path":174,"stem":175},"ОГЭ Задание 7","\u002Fblog\u002Foge\u002Ftask7","blog\u002Foge\u002Ftask7",{"title":177,"path":178,"stem":179},"ОГЭ Задание 8","\u002Fblog\u002Foge\u002Ftask8","blog\u002Foge\u002Ftask8",{"title":181,"path":182,"stem":183},"ОГЭ Задание 9","\u002Fblog\u002Foge\u002Ftask9","blog\u002Foge\u002Ftask9",{"title":185,"path":186,"stem":187,"children":188,"page":114},"Python","\u002Fblog\u002Fpython","blog\u002Fpython",[189,193,197,201,205,209,213,217,221,225,229,233,237,241,245,249,253,257,261,265,269,273,277,281,285,289,293,297,301,305,309,313,317,321,325],{"title":190,"path":191,"stem":192},"Знакомство с синтаксисом","\u002Fblog\u002Fpython\u002Fst1","blog\u002Fpython\u002Fst1",{"title":194,"path":195,"stem":196},"Отладка","\u002Fblog\u002Fpython\u002Fst10","blog\u002Fpython\u002Fst10",{"title":198,"path":199,"stem":200},"Модули и пакеты","\u002Fblog\u002Fpython\u002Fst11","blog\u002Fpython\u002Fst11",{"title":202,"path":203,"stem":204},"Кортежи","\u002Fblog\u002Fpython\u002Fst12","blog\u002Fpython\u002Fst12",{"title":206,"path":207,"stem":208},"Знакомство со списками","\u002Fblog\u002Fpython\u002Fst13","blog\u002Fpython\u002Fst13",{"title":210,"path":211,"stem":212},"Списки и циклы","\u002Fblog\u002Fpython\u002Fst14","blog\u002Fpython\u002Fst14",{"title":214,"path":215,"stem":216},"Использование списков ч.1","\u002Fblog\u002Fpython\u002Fst15","blog\u002Fpython\u002Fst15",{"title":218,"path":219,"stem":220},"Использование списков ч.2","\u002Fblog\u002Fpython\u002Fst16","blog\u002Fpython\u002Fst16",{"title":222,"path":223,"stem":224},"Использование списков ч.3","\u002Fblog\u002Fpython\u002Fst17","blog\u002Fpython\u002Fst17",{"title":226,"path":227,"stem":228},"Словари","\u002Fblog\u002Fpython\u002Fst18","blog\u002Fpython\u002Fst18",{"title":230,"path":231,"stem":232},"Множества","\u002Fblog\u002Fpython\u002Fst19","blog\u002Fpython\u002Fst19",{"title":234,"path":235,"stem":236},"Переменные","\u002Fblog\u002Fpython\u002Fst2","blog\u002Fpython\u002Fst2",{"title":238,"path":239,"stem":240},"Хеш-таблицы","\u002Fblog\u002Fpython\u002Fst20","blog\u002Fpython\u002Fst20",{"title":242,"path":243,"stem":244},"Решето Эратосфена","\u002Fblog\u002Fpython\u002Fst21","blog\u002Fpython\u002Fst21",{"title":246,"path":247,"stem":248},"Длинная арифметика","\u002Fblog\u002Fpython\u002Fst22","blog\u002Fpython\u002Fst22",{"title":250,"path":251,"stem":252},"Декораторы функций","\u002Fblog\u002Fpython\u002Fst23","blog\u002Fpython\u002Fst23",{"title":254,"path":255,"stem":256},"Знакомство с алгоритмами","\u002Fblog\u002Fpython\u002Fst24","blog\u002Fpython\u002Fst24",{"title":258,"path":259,"stem":260},"Бинарный поиск – примеры задач","\u002Fblog\u002Fpython\u002Fst25","blog\u002Fpython\u002Fst25",{"title":262,"path":263,"stem":264},"Сортировка выбором","\u002Fblog\u002Fpython\u002Fst26","blog\u002Fpython\u002Fst26",{"title":266,"path":267,"stem":268},"Рекурсия и стек","\u002Fblog\u002Fpython\u002Fst27","blog\u002Fpython\u002Fst27",{"title":270,"path":271,"stem":272},"Быстрая сортировка","\u002Fblog\u002Fpython\u002Fst28","blog\u002Fpython\u002Fst28",{"title":274,"path":275,"stem":276},"Поиск в ширину","\u002Fblog\u002Fpython\u002Fst29","blog\u002Fpython\u002Fst29",{"title":278,"path":279,"stem":280},"Работа со строками","\u002Fblog\u002Fpython\u002Fst3","blog\u002Fpython\u002Fst3",{"title":282,"path":283,"stem":284},"Поиск в глубину","\u002Fblog\u002Fpython\u002Fst30","blog\u002Fpython\u002Fst30",{"title":286,"path":287,"stem":288},"Сбалансированные деревья","\u002Fblog\u002Fpython\u002Fst31","blog\u002Fpython\u002Fst31",{"title":290,"path":291,"stem":292},"Алгоритм Дейкстры","\u002Fblog\u002Fpython\u002Fst32","blog\u002Fpython\u002Fst32",{"title":294,"path":295,"stem":296},"Жадные алгоритмы","\u002Fblog\u002Fpython\u002Fst33","blog\u002Fpython\u002Fst33",{"title":298,"path":299,"stem":300},"Динамическое программирование","\u002Fblog\u002Fpython\u002Fst34","blog\u002Fpython\u002Fst34",{"title":302,"path":303,"stem":304},"Алгоритм k ближайших соседей","\u002Fblog\u002Fpython\u002Fst35","blog\u002Fpython\u002Fst35",{"title":306,"path":307,"stem":308},"Типы данных","\u002Fblog\u002Fpython\u002Fst4","blog\u002Fpython\u002Fst4",{"title":310,"path":311,"stem":312},"О функциях","\u002Fblog\u002Fpython\u002Fst5","blog\u002Fpython\u002Fst5",{"title":314,"path":315,"stem":316},"Свойства и методы","\u002Fblog\u002Fpython\u002Fst6","blog\u002Fpython\u002Fst6",{"title":318,"path":319,"stem":320},"Определение функций","\u002Fblog\u002Fpython\u002Fst7","blog\u002Fpython\u002Fst7",{"title":322,"path":323,"stem":324},"Логика","\u002Fblog\u002Fpython\u002Fst8","blog\u002Fpython\u002Fst8",{"title":326,"path":327,"stem":328},"Циклы","\u002Fblog\u002Fpython\u002Fst9","blog\u002Fpython\u002Fst9",{"title":330,"path":331,"stem":332,"children":333,"page":114},"Toi","\u002Fblog\u002Ftoi","blog\u002Ftoi",[334,338,342,346,350,354,358,362,366,370,374,378,382],{"title":335,"path":336,"stem":337},"Информация и информационные процессы","\u002Fblog\u002Ftoi\u002Fst1","blog\u002Ftoi\u002Fst1",{"title":339,"path":340,"stem":341},"Электронные таблицы","\u002Fblog\u002Ftoi\u002Fst10","blog\u002Ftoi\u002Fst10",{"title":343,"path":344,"stem":345},"Система, её свойства и компоненты. Моделирование","\u002Fblog\u002Ftoi\u002Fst11","blog\u002Ftoi\u002Fst11",{"title":347,"path":348,"stem":349},"Представление информации в компьютере","\u002Fblog\u002Ftoi\u002Fst12","blog\u002Ftoi\u002Fst12",{"title":351,"path":352,"stem":353},"Средства информационно-коммуникационных технологий. Файловая система","\u002Fblog\u002Ftoi\u002Fst13","blog\u002Ftoi\u002Fst13",{"title":355,"path":356,"stem":357},"Комбинаторика","\u002Fblog\u002Ftoi\u002Fst2","blog\u002Ftoi\u002Fst2",{"title":359,"path":360,"stem":361},"Адресация в интернете","\u002Fblog\u002Ftoi\u002Fst3","blog\u002Ftoi\u002Fst3",{"title":363,"path":364,"stem":365},"Измерение количества информации","\u002Fblog\u002Ftoi\u002Fst4","blog\u002Ftoi\u002Fst4",{"title":367,"path":368,"stem":369},"Системы счисления","\u002Fblog\u002Ftoi\u002Fst5","blog\u002Ftoi\u002Fst5",{"title":371,"path":372,"stem":373},"Диаграммы Эйлера — Венна","\u002Fblog\u002Ftoi\u002Fst6","blog\u002Ftoi\u002Fst6",{"title":375,"path":376,"stem":377},"Условие Фано","\u002Fblog\u002Ftoi\u002Fst7","blog\u002Ftoi\u002Fst7",{"title":379,"path":380,"stem":381},"Теория графов","\u002Fblog\u002Ftoi\u002Fst8","blog\u002Ftoi\u002Fst8",{"title":383,"path":384,"stem":385},"Алгебра логики","\u002Fblog\u002Ftoi\u002Fst9","blog\u002Ftoi\u002Fst9",{"id":387,"title":262,"author":388,"body":393,"date":1115,"description":1116,"extension":1117,"image":1118,"meta":1119,"minRead":1120,"navigation":1121,"num":1122,"path":263,"seo":1123,"stem":264,"__hash__":1124},"python\u002Fblog\u002Fpython\u002Fst26.md",{"name":389,"avatar":390},"Штана Альберт Игоревич",{"src":391,"alt":392},"me.jpg","@ashtana",{"type":394,"value":395,"toc":1098},"minimark",[396,400,405,421,426,431,434,438,454,457,467,472,475,478,481,485,488,491,496,503,507,514,523,527,530,533,583,588,591,595,598,601,608,611,705,794,798,801,939,942,1068,1073,1077,1088,1091,1095],[397,398,262],"h2",{"id":399},"сортировка-выбором",[401,402],"card-collapsible",{":isList":403,"title":404},"[\"Вы познакомитесь с массивами и связанными списками – двумя основными структурами данных.\",\"Вы изучите алгоритм сортировки выбором.\"]","Из этой статьи вы узнаете",[406,407,408],"blockquote",{},[409,410,411,415,416,420],"p",{},[412,413,414],"em",{},"Что нужно знать прежде?"," В статье ранее про ",[417,418,419],"a",{"href":255},"бинарный поиск"," было рассмотрено такое понятие как\n\"О-большое\"(время выполнения алгоритма или объём используемой памяти который растёт с увеличением размера входных данных).\nЧтобы лучше понять эту статью, необходимо понимать смысл \"О-большого\" и логарифмов.",[409,422,423],{},[412,424,425],{},"Прежде чем разобрать сам алгоритм сортировки выбором, необходимо разобраться как работает память компьютера и как представлена такая структура данных как массив или список.",[427,428,430],"h3",{"id":429},"как-работает-память","Как работает память",[409,432,433],{},"Представьте, что вы пришли в кинотеатр и хотите оставить свою верхнюю одежду в гардеробе.\nДля хранения верхней одежды существуют специальные вешалки в гардеробе. На каждой вешалке помещается только одна вещь.\nВы хотите сдать к примеру две куртки, поэтому требуется выделить вам две вешалки(конечно можно попробовать обе куртки повесить на одну вешалку, но для примера представим что нельзя).\nВы оставляете свои две куртки, получаете два \"номера\" от вешалок и идёте смотреть кино.\nВ сущности, точно также работает память компьютера. Она представляет собой нечто вроде огромного гардероба со множеством вешалок и у каждой вешалки свой адрес.\nНапример: fc0addeb – адрес ячейки памяти.\nКаждый раз, когда вы хотите сохранить в памяти отдельное значение, вы запрашиваете у компьютера(процессор это делает за вас) место в памяти, а он выдаёт адрес для сохранения значения.\nЕсли же вам понадобится сохранить несколько элементов, это можно сделать двумя способами: воспользоваться массивом или списком.\nДалее рассмотрим массивы и списки, их достоинства и недостатки.\nНе существует единого мнения или единственно верного способа сохранения данных на все случаи жизни, поэтому нужно понимать различия между массивами и списками.",[427,435,437],{"id":436},"массивы-и-связанные-списки","Массивы и связанные списки",[406,439,440],{},[409,441,442,443,446,447,449,450,446,452],{},"Есть про списки в Python и как их использовать статьи:\n",[417,444,445],{"href":211},"Списки в циклы",", ",[417,448,214],{"href":215},",\n",[417,451,218],{"href":219},[417,453,222],{"href":223},[409,455,456],{},"Предположим вы хотите написать приложение для списка дел и управления ими. Описание дел должны храниться в виде списка или массива в памяти.\nЧто использовать — массив или связанный список? Для начала попробуем сохранить дела в массиве.\nПри использовании массива все дела хранятся в памяти непрерывно(то есть рядом друг с другом).\nТеперь предположим, что мы хотим добавить новое дело, но следующее место в памяти для него - занято(там уже что-нибудь есть)!\nПредставьте, что вы пошли в кинотеатр вместе с друзьями и нашли места для всей своей компании, но тут вдруг приходит ещё один друг, и ему уже сесть некуда.\nПриходится искать новые места, где смогли бы разместиться все сразу! В нашем случае вам придётся запросить у компьютера другой блок памяти, в котором смогут поместиться сразу все дела.\nЕсли вдруг придёт ещё один друг, места опять не хватит и вам всем придётся снова перемещаться в поиске новых мест! Сплошная суета получается!\nВыходит, что добавление новых элементов в массив – серьёзная проблема.\nЕсли свободного места нет и вам каждый раз приходится перемещаться всей компанией друзей в новые места(делам приходится перемещаться каждый раз в новую область памяти),\nоперация добавление нового элемента или элементов будет выполниться крайне медленно.\nПростейшее решение — это \"бронирование мест\" заранее! Таким образом, если ваш список состоит всего из 4 дел, вы запрашиваете у компьютера заранее памяти на 10 дел... просто на всякий случай \"про запас\".\nТогда в массив можно будет добавить до 10 дел и ничего перемещать не придётся. Это неплохое обходное решение проблемы с массивами, но у него есть пара недостатков:",[458,459,460,464],"ul",{},[461,462,463],"li",{},"Если в массив будет добавлено к примеру 11 дело, а памяти было лишь на 10, то перемещать всех всё равно придётся;",[461,465,466],{},"Лишнее место может и не понадобиться, и тогда память будет расходоваться неэффективно. Вы её зарезервировали, однако не использовали и никто другой её использовать не может.\nВ общем, приём неплохой, но нельзя назвать его идеальным. Связанные списки решают эту проблему.",[468,469,471],"h4",{"id":470},"связанные-списки","Связанные списки",[409,473,474],{},"При использовании связанного списка элементы могут размещаться где угодно в памяти.\nВ каждом элементе хранится адрес следующего элемента списка. Таким образом, набор произвольных адресов памяти объединяется в цепочку.\nВсё происходит как в игре \"Найди сокровище\". Нужно прийти по первому адресу, там записка: \"Следующий элемент находится по адресу 2\".\nИдём по второму адресу, там снова написано: \"Следующий элемент находится по адресу 3\" и т.д. Добавить элемент в связанный список не составляет труда:\nпросто размещаем его по любому адресу в памяти(на любое свободное место) и сохраняем этот адрес в предыдущем элементе списка.",[409,476,477],{},"Со связанными списками ничего перемещать в памяти не нужно. Также сама собой решается проблема, допустим вы прешли в кино с тремя друзьями.\nВы пытаетесь найти место на пятерых, но места в кинотеатре уже забиты, и найти соседних друг с другом пять мест невозможно.\nПохожая ситуация происходит также когда мы используем массив. Допустим мы пытаемся найти места на 10000 элементов.\nВ памяти можно найти места для 10000 элементов, но только не смежные друг с другом! И для создания массива уже не хватает места!\nНо при хранении данных в связанном списке вы фактически скажите: \"Окей, тогда садимся на любые свободные места и смотрим кино\".\nЕсли любое необходимое количество мест есть в памяти компьютера, вы сможете сохранить все данные в связанном списке.\nВ случае с массивом, если не можете разместить всё рядом друг с другом — \"вынуждены будите покинуть кинотеатр\"!",[409,479,480],{},"Если связанные списки так хороши, то зачем тогда массивы и чем они остаются также хороши?",[468,482,484],{"id":483},"массивы","Массивы",[409,486,487],{},"На сайтах со всевозможными рейтингами, тестами и хит-парадами применяется хитрая тактика для увеличения количества просмотров.\nВместо того чтобы вывести весь список на одной странице,\nтакие сайты размещают информацию по одному элементу на страницу и заставляют пользователей нажимать на кнопку \"Далее\" для перехода к следующему элементу.\nМожет быть так, например, что рейтинг новостей не выводится на одной странице.\nВ результате просмотра всего списка новостей сайту удаётся показать вам рекламу на всех страницах пока вы нажимаете \"Далее\" или \"Показать ещё\".\nБыло бы гораздо лучше в таких случаях увидеть сразу весь список.",[409,489,490],{},"Похожая проблема существует и у связанных списков. Допустим, вы хотите получить последний элемент связанного списка.\nПросто прочитать нужное значение не удастся, потому что вы не знаете, по какому адресу оно хранится.\nВместо этого в связанном списке сначала придётся обратиться к элементу №1 и узнать адрес элемента №2, потом обратиться к элементу №2 и узнать адрес элемента №3... и т.д., пока не доберёмся до последнего элемента.\nСвязанные списки отлично подходят в тех ситуациях, когда данные должны читаться последовательно: сначала вы читаете один элемент, по адресу переходите к следующему.\nНо если вы хотите \"прыгать\" по списку куда угодно, то нужно выбрать массив, а не связанный список.\nРаботая с массивом вы заранее знаете адрес каждого элемента. Допустим, массив содержит пять элементов и вы знаете, что он начинается с адреса 0.\nПо какому адресу будет храниться его пятый элемент?\nПростая математика подсказывает: это адрес 4. Массивы прекрасно подходят для чтения элементов в произвольных позициях, потому что обращение к любому элементу массива происходит сразу мгновенно.\nВ связанном списке элементы не хранятся рядом друг с другом, поэтому определить адрес или позицию i-го элемента в памяти невозможно — нужно обратиться к первому элементу, затем ко второму, и потом к третьему, пока не доберёмся до i-го элемента.",[492,493,495],"h5",{"id":494},"терминология","Терминология",[409,497,498,499,502],{},"Элементы массива пронумерованы, причём нумерация начинается с 0, а не с 1. Новичков этот факт может запутывать.\nТем не менее выбор нулевой начальной позиции упрощает написание кода при работе с массивом, поэтому программисты остановились на этом варианте.\nПочти во всех языках программирования нумерация элементов массива начинается с 0.\nПозиция элемента называется его ",[412,500,501],{},"индексом",". Таким образом, вместо того чтобы говорить, например, \"Значение 20 находится в позиции 1\", правильно сказать \"Значение 20 имеет индекс 1\".\nТермин \"индекс\" означает то же, что и \"позиция\" в случае с массивами.\nПредположим, вы хотите вставить элемент в начало массива. Сколько времени на это потребуется?",[492,504,506],{"id":505},"вставка-в-середину-списка","Вставка в середину списка",[409,508,509,510,513],{},"Предположим, вы хотите чтобы список дел напоминал календарь.\nПрежде данные добавлялись только в конец списка, а теперь они должны добавляться в порядке их выполнения.\nЧто лучше подойдёт для вставки элементов в середину: массив или список? Со списком задача решается изменением ",[412,511,512],{},"указателя"," в предыдущем элементе.\nА при работе с массивом придётся перемещать или сдвигать все элементы. Если свободного места не осталось, все данные придётся скопировать в новую область памяти!\nВ общем случае получается что списки больше подходят для вставки элементов в середину.",[406,515,516],{},[409,517,518,522],{},[519,520,521],"strong",{},"Указатели",". Именно с помощью указателей каждый элемент связанного списка указывает на следующий элемент списка.\nВ каждом элементе связанного списка выделяется некоторый объём памяти для хранения адреса следующего элемента.\nЭта часть элемента называется указателем.\nЕсли вы будите писать программы на низкоуровневом языке программирования очень полезно понимать что значит указатель на объект данных в памяти.",[492,524,526],{"id":525},"удаление","Удаление",[409,528,529],{},"Что, если вы заходите удалить элемент? И снова список лучше подходит для этой операции, потому что в нём достаточно изменить указатель в предыдущем элементе.\nВ массиве при удалении элемента все последующие элементы нужно будет сдвинуть.\nВ отличие от вставки, удаление возможно всегда. Попытка вставки может быть неудачной, если в памяти не осталось свободного места. С удалением подобных проблем нет.",[409,531,532],{},"Ниже приведены примеры времени выполнения основных операций с массивами и списками:",[534,535,536,551],"table",{},[537,538,539],"thead",{},[540,541,542,546,548],"tr",{},[543,544,545],"th",{},"-------",[543,547,484],{},[543,549,550],{},"Списки",[552,553,554,566,575],"tbody",{},[540,555,556,560,563],{},[557,558,559],"td",{},"Чтение",[557,561,562],{},"O(1)",[557,564,565],{},"O(n)",[540,567,568,571,573],{},[557,569,570],{},"Вставка",[557,572,565],{},[557,574,562],{},[540,576,577,579,581],{},[557,578,526],{},[557,580,565],{},[557,582,562],{},[406,584,585],{},[409,586,587],{},"O(n) – линейное время; O(1) – постоянное время.",[409,589,590],{},"Заметим, что вставка и удаление выполняются за время O(1) только в том случае, если вы можете мгновенно получить доступ к удаляемому элементу.\nНа практике обычно сохраняются ссылки на первый и последний элементы связанного списка, поэтому время удаления этих элементов составит всего O(1).",[468,592,594],{"id":593},"массивы-или-списки","Массивы или списки?",[409,596,597],{},"Массивы используются часто, поскольку имеют множество преимуществ перед списками. Во-первых, данные из них проще читать. Во-вторых, массивы поддерживают произвольный доступ.\nВсего существует два вида доступа: произвольный и последовательный. При последовательном доступе элементы читаются по одному, начиная с первого.\nСвязанные списки поддерживают только последовательный доступ.\nЕсли вы захотите прочитать 10-й элемент связанного списка, нам придётся прочитать первые 9 его элементов и перейти по ссылкам к 10-му элементу.\nМногие реальные ситуации требуют произвольного доступа, поэтому массивы часто применяются на практике.\nОднако даже безотносительно произвольного доступа массивы работают быстрее, поскольку могут использовать такой принцип как \"кэширование\".\nВозможно, вы представляете себе процесс чтения как восприятие одного элемента за раз.\nНо на самом деле компьютеры читают целыми разделами, поскольку это значительно ускоряет переход к следующему элементу.\nС массивами можно сделать то, что не получится со связанными списками.\nС помощью массива можно прочитать целый раздел элементов.\nВ связанном списке местоположение следующего элемента неизвестно.\nПридётся прочитать элемент, узнать, где находится следующий, а затем прочитать и его. Таким образом, массивы обеспечивают не только произвольный, но и более быстрый доступ к данным!",[409,599,600],{},"А как насчёт эффективного использования памяти? Помните, что в случае с массивами обычно выделяют больше памяти, чем нужно, и если в конечном итоге она окажется не нужна, то получается, ресурс расходуется впустую?\nНа деле конечно же(особенно сегодня и думаю в будущем) объём такой неиспользованной памяти получается не очень то большим(в сравнении с памятью современных устройств).\nС другой стороны, когда вы применяете связанный список, вы выделяете дополнительную память для каждого элемента, поскольку в ней сохраняется адрес следующего элемента.\nТаким образом данные в связанном списке занимают больше места, при аналогичной размерности массива, если их элементы относительно невелики.\nКонечно, если элементы массива крупные, то даже один слот неиспользованной памяти может оказаться очень большим, а объём дополнительной памяти, используемой для хранения указателей(адресов на последующий элемент), по сравнению с ним будет совсем незначительным.\nТаким образом, массивы используются чаще, чем связанные списки, за исключением особых случаев.",[602,603],"card-collapsible-num-answers",{":isAnswers":604,":isList":605,"title":606,"isText":607},"[\"В данном случае траты добавляются в списко ежедневно, а чтение всех данных происходит один раз в месяц. Для массивов характерно быстрое чтение и медленная вставка, а для связанных списков – медленное чтение и быстрая вставка. Связанный списк станет хорошим решением.\",\"Связанный список. Вставка происходит очень часто, а связанные списки эффективно выполняют эту операцию. Ни поиск, ни произвольный доступ вам не понадобятся, потому что повар всегда извлекает из очереди первый заказ.\",\"В виде отсортированного массива. Массивы обеспечивают произвольный доступ – можно мгновенно получить элемент из середины.\",\"Вставка в массив выполняется медленно. Кроме того, если мы используем бинарный поиск для нахождения имён пользователей, массив необходимо отсортировать. Предположим новый пользователь регистрируется на сайте. Его имя будет вставлено в конец массива. Следовательно, массив ещё нужно будет сортировать при каждой вставке нового имени!\",\"Поиск – медленнее чем для массивов, и быстрее, чем для связанных списков. Вставка – быстрее, чем для массивов, и с такой же скоростью для связанных списков. Гибридная структура уступает массиву по скорости поиска, но по крайней мере не хуже связанных списков для всего остального. Есть ещё такое понятие как хеш-таблица. Она даёт некоторое представление о том, как строить сложные структуры данных из простых. Вероятно, ВКонтакте использует разные базы данных, за которыми стоят разные структуры данных: хеш-таблицы, B-деревья и т.п. Массивы и связанные списки становятся структурными элементами для построения более сложных структур данных.\"]","[\"Допустим, вы строите приложение для управления финансами со множеством категорий трат. Ежедневно вы записываете все свои траты. В конце месяца вы анализируете расходы и вычисляете, сколько денег было потрачено. При работе с данными выполняется множество операций вставки и относительно немного операций чтения. Какую структуру данных лучше использовать массив или список?\",\"Допустим, вы пишите приложение для приёма заказов от посетителей ресторана. Приложение должно хранить список заказов. Официанты добавляют заказы в список, а повара читают заказы из списка и выполняют их. Заказы образуют очередь: официанты добавляют заказы в конец очереди, а повар берёт новый заказ из очереди и начинает его готовить. Какую структуру данных вы использовали бы для реализации этой очереди: массив или список?\",\"Проведём мысленный эксперимент. Допусти, ВКонтакте хранит список имён пользователей. Когда кто-то пытается зайти на сайт ВКонтакте, система пытается найти пользователя. Если имя входит в список имён зарегистрированных пользователей, то вход разрешается. Пользователи приходят на сайт достаточно часто, поэтому поиск по списку имён пользователей выполняется часто. Будем считать, что ВКонтакте использует бинарный поиск для поиска имён пользователей. Бинарному поиску необходим произвольный доступ — алгоритм должен мгновенно обращаться к среднему элементу среди всех имён. Зная это обстоятельство, как бы вы реализовали список пользователей: в виде массива или в виде связанного списка?\",\"Пользователи также довольно часто создают новые учётные записи на ВКонтакте. Предположим, вы решили использовать массив для хранения списка пользователей. Какими недостатками обладает массив для выполнения вставки? Допустим, вы используете бинарный поиск для нахождения учётных данных. Что произойдёт при добавлении новых пользователей в массив?\",\"В действительности ВКонтакте не использует ни массив, ни связанный список для хранения информации об именах пользователей. Он использует базу данных. Но мы представим гибридную структуру: массив связанных списков. Имеется массив из 30 элементов. Каждый элемент содержит ссылку на связанный список. Например, первый элемент массива указывает на связанный список всех имён пользователей, начинающихся на букву \\\"А\\\". Второй элемент указывает на связанный список всех имён пользователей, начинающихся на букву \\\"Б\\\", и т.д. Предположим, пользователь с именем \\\"Андрей В\\\" регистрируется на сайте и вы хотите добавить его в список. Вы обращаетесь к первому элементу массива, находите связанный список и добавляете пользователя \\\"Андрей В\\\" в конец этого списка. Теперь предположим, что на сайте зарегистрировался пользователь с именем \\\"Яков Н\\\". Вы также обращаетесь к элементу 30, который содержит связанный список всех имён, начинающихся на \\\"Я\\\", и проверяете, присутствует ли \\\"Яков Н\\\" в этом списке. Теперь сравните эту гибридную структуру данных с простым мыссивом и простым связанным списком. Будет ли она быстрее или медленнее каждой из них при поиске и\u002Fили вставке? Просто ответите выбрав одно из двух: \\\"будет быстрее\\\" или \\\"будет медленнее\\\".\"]","УПРАЖНЕНИЯ","Попробуйте ответить на следующие вопросы",[427,609,262],{"id":610},"сортировка-выбором-1",[409,612,613,614],{},"Объединим все знания выше для построения алгоритма: сортировка выбором.\nЧтобы понять этот алгоритм, представьте, у вас на компьютере хранится музыка и для каждого исполнителя хранится счётчик воспроизведений его звукозаписей.\nВы хотели бы отсортировать список по убыванию счётчика воспроизведений, чтобы самые любимые исполнители стояли на первых местах. Как это реализовать?\nОдно из возможных решений — пройти по списку, найти исполнителя с наибольшим количеством воспроизведений и добавить его в новый список.\nПотом нужно сделать те же действия, но уже со следующим по количеству воспроизведений исполнителем.\nПродолжаем действовать так до конца, пока последнего исполнителя не перенесём в новый отсортированный список.\nА теперь попробуем оценить происходящее с точки зрения теории вычислений и посмотрим, сколько времени будут занимать операции.\nНапомним, что время O(n) означает, что вы по одному разу обращаетесь к каждому элементу списка(или массива).\nНапример, при простом поиске по списку исполнителей каждый исполнитель будет проверен один раз.\nЧтобы найти исполнителя с наибольшим значением счётчика воспроизведений, необходимо проверить каждый элемент в списке.\nЭто получается сделать за время O(n).\nИтак, имеется операция, выполняемая за время O(n), и её необходимо выполнить n раз: всё это потребует времени O(n * n) или\n",[615,616,620],"mjx-container",{"className":617,"jax":619},[618],"MathJax","SVG",[621,622,631,655],"svg",{"style":623,"xmlns":624,"width":625,"height":626,"role":627,"focusable":628,"viewBox":629,"xmlnsXLink":630},"vertical-align: -0.566ex;","http:\u002F\u002Fwww.w3.org\u002F2000\u002Fsvg","5.832ex","2.452ex","img","false","0 -833.9 2577.6 1083.9","http:\u002F\u002Fwww.w3.org\u002F1999\u002Fxlink",[632,633,634,639,643,647,651],"defs",{},[635,636],"path",{"id":637,"d":638},"MJX-1-TEX-I-1D442","M740 435Q740 320 676 213T511 42T304 -22Q207 -22 138 35T51 201Q50 209 50 244Q50 346 98 438T227 601Q351 704 476 704Q514 704 524 703Q621 689 680 617T740 435ZM637 476Q637 565 591 615T476 665Q396 665 322 605Q242 542 200 428T157 216Q157 126 200 73T314 19Q404 19 485 98T608 313Q637 408 637 476Z",[635,640],{"id":641,"d":642},"MJX-1-TEX-N-28","M94 250Q94 319 104 381T127 488T164 576T202 643T244 695T277 729T302 750H315H319Q333 750 333 741Q333 738 316 720T275 667T226 581T184 443T167 250T184 58T225 -81T274 -167T316 -220T333 -241Q333 -250 318 -250H315H302L274 -226Q180 -141 137 -14T94 250Z",[635,644],{"id":645,"d":646},"MJX-1-TEX-I-1D45B","M21 287Q22 293 24 303T36 341T56 388T89 425T135 442Q171 442 195 424T225 390T231 369Q231 367 232 367L243 378Q304 442 382 442Q436 442 469 415T503 336T465 179T427 52Q427 26 444 26Q450 26 453 27Q482 32 505 65T540 145Q542 153 560 153Q580 153 580 145Q580 144 576 130Q568 101 554 73T508 17T439 -10Q392 -10 371 17T350 73Q350 92 386 193T423 345Q423 404 379 404H374Q288 404 229 303L222 291L189 157Q156 26 151 16Q138 -11 108 -11Q95 -11 87 -5T76 7T74 17Q74 30 112 180T152 343Q153 348 153 366Q153 405 129 405Q91 405 66 305Q60 285 60 284Q58 278 41 278H27Q21 284 21 287Z",[635,648],{"id":649,"d":650},"MJX-1-TEX-N-32","M109 429Q82 429 66 447T50 491Q50 562 103 614T235 666Q326 666 387 610T449 465Q449 422 429 383T381 315T301 241Q265 210 201 149L142 93L218 92Q375 92 385 97Q392 99 409 186V189H449V186Q448 183 436 95T421 3V0H50V19V31Q50 38 56 46T86 81Q115 113 136 137Q145 147 170 174T204 211T233 244T261 278T284 308T305 340T320 369T333 401T340 431T343 464Q343 527 309 573T212 619Q179 619 154 602T119 569T109 550Q109 549 114 549Q132 549 151 535T170 489Q170 464 154 447T109 429Z",[635,652],{"id":653,"d":654},"MJX-1-TEX-N-29","M60 749L64 750Q69 750 74 750H86L114 726Q208 641 251 514T294 250Q294 182 284 119T261 12T224 -76T186 -143T145 -194T113 -227T90 -246Q87 -249 86 -250H74Q66 -250 63 -250T58 -247T55 -238Q56 -237 66 -225Q221 -64 221 250T66 725Q56 737 55 738Q55 746 60 749Z",[656,657,661],"g",{"stroke":658,"fill":658,"stroke-width":659,"transform":660},"currentColor","0","scale(1,-1)",[656,662,664,672,680,698],{"dataMmlNode":663},"math",[656,665,667],{"dataMmlNode":666},"mi",[668,669],"use",{"dataC":670,"xLinkHref":671},"1D442","#MJX-1-TEX-I-1D442",[656,673,676],{"dataMmlNode":674,"transform":675},"mo","translate(763,0)",[668,677],{"dataC":678,"xLinkHref":679},"28","#MJX-1-TEX-N-28",[656,681,684,690],{"dataMmlNode":682,"transform":683},"msup","translate(1152,0)",[656,685,686],{"dataMmlNode":666},[668,687],{"dataC":688,"xLinkHref":689},"1D45B","#MJX-1-TEX-I-1D45B",[656,691,694],{"dataMmlNode":692,"transform":693},"mn","translate(633,363) scale(0.707)",[668,695],{"dataC":696,"xLinkHref":697},"32","#MJX-1-TEX-N-32",[656,699,701],{"dataMmlNode":674,"transform":700},"translate(2188.6,0)",[668,702],{"dataC":703,"xLinkHref":704},"29","#MJX-1-TEX-N-29",[409,706,707,708,793],{},"Алгоритмы сортировки очень полезны. Например, вы можете отсортировать: имена или фамилии в телефонной книге; даты; сообщения электронной почты и т.п.\nАлгоритм сортировки выбором легко объясняется, но медленно работает. Быстрая сортировка — более эффективный алгоритм сортировки, который выполняется за время:\n",[615,709,711],{"className":710,"jax":619},[618],[621,712,716,742],{"style":623,"xmlns":624,"width":713,"height":714,"role":627,"focusable":628,"viewBox":715,"xmlnsXLink":630},"9.983ex","2.262ex","0 -750 4412.4 1000",[632,717,718,721,724,727,731,735,739],{},[635,719],{"id":720,"d":638},"MJX-2-TEX-I-1D442",[635,722],{"id":723,"d":642},"MJX-2-TEX-N-28",[635,725],{"id":726,"d":646},"MJX-2-TEX-I-1D45B",[635,728],{"id":729,"d":730},"MJX-2-TEX-N-2217","M229 286Q216 420 216 436Q216 454 240 464Q241 464 245 464T251 465Q263 464 273 456T283 436Q283 419 277 356T270 286L328 328Q384 369 389 372T399 375Q412 375 423 365T435 338Q435 325 425 315Q420 312 357 282T289 250L355 219L425 184Q434 175 434 161Q434 146 425 136T401 125Q393 125 383 131T328 171L270 213Q283 79 283 63Q283 53 276 44T250 35Q231 35 224 44T216 63Q216 80 222 143T229 213L171 171Q115 130 110 127Q106 124 100 124Q87 124 76 134T64 161Q64 166 64 169T67 175T72 181T81 188T94 195T113 204T138 215T170 230T210 250L74 315Q65 324 65 338Q65 353 74 363T98 374Q106 374 116 368T171 328L229 286Z",[635,732],{"id":733,"d":734},"MJX-2-TEX-I-1D459","M117 59Q117 26 142 26Q179 26 205 131Q211 151 215 152Q217 153 225 153H229Q238 153 241 153T246 151T248 144Q247 138 245 128T234 90T214 43T183 6T137 -11Q101 -11 70 11T38 85Q38 97 39 102L104 360Q167 615 167 623Q167 626 166 628T162 632T157 634T149 635T141 636T132 637T122 637Q112 637 109 637T101 638T95 641T94 647Q94 649 96 661Q101 680 107 682T179 688Q194 689 213 690T243 693T254 694Q266 694 266 686Q266 675 193 386T118 83Q118 81 118 75T117 65V59Z",[635,736],{"id":737,"d":738},"MJX-2-TEX-I-1D44F","M73 647Q73 657 77 670T89 683Q90 683 161 688T234 694Q246 694 246 685T212 542Q204 508 195 472T180 418L176 399Q176 396 182 402Q231 442 283 442Q345 442 383 396T422 280Q422 169 343 79T173 -11Q123 -11 82 27T40 150V159Q40 180 48 217T97 414Q147 611 147 623T109 637Q104 637 101 637H96Q86 637 83 637T76 640T73 647ZM336 325V331Q336 405 275 405Q258 405 240 397T207 376T181 352T163 330L157 322L136 236Q114 150 114 114Q114 66 138 42Q154 26 178 26Q211 26 245 58Q270 81 285 114T318 219Q336 291 336 325Z",[635,740],{"id":741,"d":654},"MJX-2-TEX-N-29",[656,743,744],{"stroke":658,"fill":658,"stroke-width":659,"transform":660},[656,745,746,751,756,761,768,775,782,787],{"dataMmlNode":663},[656,747,748],{"dataMmlNode":666},[668,749],{"dataC":670,"xLinkHref":750},"#MJX-2-TEX-I-1D442",[656,752,753],{"dataMmlNode":674,"transform":675},[668,754],{"dataC":678,"xLinkHref":755},"#MJX-2-TEX-N-28",[656,757,758],{"dataMmlNode":666,"transform":683},[668,759],{"dataC":688,"xLinkHref":760},"#MJX-2-TEX-I-1D45B",[656,762,764],{"dataMmlNode":674,"transform":763},"translate(1974.2,0)",[668,765],{"dataC":766,"xLinkHref":767},"2217","#MJX-2-TEX-N-2217",[656,769,771],{"dataMmlNode":666,"transform":770},"translate(2696.4,0)",[668,772],{"dataC":773,"xLinkHref":774},"1D459","#MJX-2-TEX-I-1D459",[656,776,778],{"dataMmlNode":666,"transform":777},"translate(2994.4,0)",[668,779],{"dataC":780,"xLinkHref":781},"1D44F","#MJX-2-TEX-I-1D44F",[656,783,785],{"dataMmlNode":666,"transform":784},"translate(3423.4,0)",[668,786],{"dataC":688,"xLinkHref":760},[656,788,790],{"dataMmlNode":674,"transform":789},"translate(4023.4,0)",[668,791],{"dataC":703,"xLinkHref":792},"#MJX-2-TEX-N-29","\nНо об этом в следующей статье.",[468,795,797],{"id":796},"пример-кода","Пример кода",[409,799,800],{},"Напишем две функции. Выполним сортировку массива по возрастанию. Сначала напишем функцию для поиска наименьшего значения элемента массива:",[802,803,808],"pre",{"className":804,"code":805,"language":806,"meta":807,"style":807},"language-python shiki shiki-themes github-light","def findSmallestEl(arr):\n  smaller = arr[0]  # Для хранения наименьшего значения\n  smaller_i = 0  # Для хранения индекса наименьшего значения\n  for i in range(1, len(arr)):\n    if arr[i] \u003C smaller:\n      smaller = arr[i]\n      smaller_i = i\n  return smaller_i\n","python","",[809,810,811,828,850,864,893,908,919,930],"code",{"__ignoreMap":807},[812,813,816,820,824],"span",{"class":814,"line":815},"line",1,[812,817,819],{"class":818},"sD7c4","def",[812,821,823],{"class":822},"s7eDp"," findSmallestEl",[812,825,827],{"class":826},"sgsFI","(arr):\n",[812,829,831,834,837,840,843,846],{"class":814,"line":830},2,[812,832,833],{"class":826},"  smaller ",[812,835,836],{"class":818},"=",[812,838,839],{"class":826}," arr[",[812,841,659],{"class":842},"sYu0t",[812,844,845],{"class":826},"]  ",[812,847,849],{"class":848},"sAwPA","# Для хранения наименьшего значения\n",[812,851,853,856,858,861],{"class":814,"line":852},3,[812,854,855],{"class":826},"  smaller_i ",[812,857,836],{"class":818},[812,859,860],{"class":842}," 0",[812,862,863],{"class":848},"  # Для хранения индекса наименьшего значения\n",[812,865,867,870,873,876,879,882,885,887,890],{"class":814,"line":866},4,[812,868,869],{"class":818},"  for",[812,871,872],{"class":826}," i ",[812,874,875],{"class":818},"in",[812,877,878],{"class":842}," range",[812,880,881],{"class":826},"(",[812,883,884],{"class":842},"1",[812,886,446],{"class":826},[812,888,889],{"class":842},"len",[812,891,892],{"class":826},"(arr)):\n",[812,894,896,899,902,905],{"class":814,"line":895},5,[812,897,898],{"class":818},"    if",[812,900,901],{"class":826}," arr[i] ",[812,903,904],{"class":818},"\u003C",[812,906,907],{"class":826}," smaller:\n",[812,909,911,914,916],{"class":814,"line":910},6,[812,912,913],{"class":826},"      smaller ",[812,915,836],{"class":818},[812,917,918],{"class":826}," arr[i]\n",[812,920,922,925,927],{"class":814,"line":921},7,[812,923,924],{"class":826},"      smaller_i ",[812,926,836],{"class":818},[812,928,929],{"class":826}," i\n",[812,931,933,936],{"class":814,"line":932},8,[812,934,935],{"class":818},"  return",[812,937,938],{"class":826}," smaller_i\n",[409,940,941],{},"Затем напишем основную функцию алгоритма сортировки выбором:",[802,943,945],{"className":804,"code":944,"language":806,"meta":807,"style":807},"# Сортируем массив\ndef selectionSort(arr):\n  newArr = []  # Новый массив, как для результат сортировки\n  for i in range(len(arr)):\n      # Находим наименьший элемент в массиве с помощью вспомогательной функции\n      smallest = findSmallestEl(arr)\n      newArr.append(arr.pop(smallest))  # Добавляем наименьший элемент в новый массив\n  return newArr\n  \nprint(selectionSort([8, 1, 5, 2, 9, 4]))  # Пример работы функции\n",[809,946,947,952,961,974,990,995,1005,1013,1020,1026],{"__ignoreMap":807},[812,948,949],{"class":814,"line":815},[812,950,951],{"class":848},"# Сортируем массив\n",[812,953,954,956,959],{"class":814,"line":830},[812,955,819],{"class":818},[812,957,958],{"class":822}," selectionSort",[812,960,827],{"class":826},[812,962,963,966,968,971],{"class":814,"line":852},[812,964,965],{"class":826},"  newArr ",[812,967,836],{"class":818},[812,969,970],{"class":826}," []  ",[812,972,973],{"class":848},"# Новый массив, как для результат сортировки\n",[812,975,976,978,980,982,984,986,988],{"class":814,"line":866},[812,977,869],{"class":818},[812,979,872],{"class":826},[812,981,875],{"class":818},[812,983,878],{"class":842},[812,985,881],{"class":826},[812,987,889],{"class":842},[812,989,892],{"class":826},[812,991,992],{"class":814,"line":895},[812,993,994],{"class":848},"      # Находим наименьший элемент в массиве с помощью вспомогательной функции\n",[812,996,997,1000,1002],{"class":814,"line":910},[812,998,999],{"class":826},"      smallest ",[812,1001,836],{"class":818},[812,1003,1004],{"class":826}," findSmallestEl(arr)\n",[812,1006,1007,1010],{"class":814,"line":921},[812,1008,1009],{"class":826},"      newArr.append(arr.pop(smallest))  ",[812,1011,1012],{"class":848},"# Добавляем наименьший элемент в новый массив\n",[812,1014,1015,1017],{"class":814,"line":932},[812,1016,935],{"class":818},[812,1018,1019],{"class":826}," newArr\n",[812,1021,1023],{"class":814,"line":1022},9,[812,1024,1025],{"class":826},"  \n",[812,1027,1029,1032,1035,1038,1040,1042,1044,1047,1049,1052,1054,1057,1059,1062,1065],{"class":814,"line":1028},10,[812,1030,1031],{"class":842},"print",[812,1033,1034],{"class":826},"(selectionSort([",[812,1036,1037],{"class":842},"8",[812,1039,446],{"class":826},[812,1041,884],{"class":842},[812,1043,446],{"class":826},[812,1045,1046],{"class":842},"5",[812,1048,446],{"class":826},[812,1050,1051],{"class":842},"2",[812,1053,446],{"class":826},[812,1055,1056],{"class":842},"9",[812,1058,446],{"class":826},[812,1060,1061],{"class":842},"4",[812,1063,1064],{"class":826},"]))  ",[812,1066,1067],{"class":848},"# Пример работы функции\n",[409,1069,1070],{},[412,1071,1072],{},"P.S. Подробнее об остальных алгоритмов будет в следующих статьях.",[401,1074],{":isList":1075,"title":1076},"[\"Память компьютера для данных можно представить как гардероб для вещей\",\"Если вам необходимо сохранить набор элементов, для начала воспользуйтесь массивом или списком\",\"В массиве все элементы хранятся рядом друг с другом\",\"В связанном списке элементы распределяются в произвольных местах памяти, при этом в каждом элементе хранится адрес следующего элемента\",\"Массивы обеспечивают быстрое чтение\",\"Списки обеспечивают быструю вставку и удаление\"]","ШПАРГАЛКА",[409,1078,1079,1080,1083,1084,1087],{},"Попробуйте сами скопировать и запустить код в окне ниже с интерпретатором Python и повторите примеры из статьи чтобы самим увидеть и понять как всё это работает.\nДля этого в ячейке с кодом нажмите клавиши на клавиатуре ",[519,1081,1082],{},"Shift+Enter"," или запустите код через ",[519,1085,1086],{},"кнопку Run"," по значку ▶.",[1089,1090],"jypiter",{},[1092,1093,1094],"style",{},"\nmjx-container[jax=\"SVG\"] {\n  direction: ltr;\n}\n\nmjx-container[jax=\"SVG\"] > svg {\n  overflow: visible;\n  min-height: 1px;\n  min-width: 1px;\n}\n\nmjx-container[jax=\"SVG\"] > svg a {\n  fill: blue;\n  stroke: blue;\n}\n\nmjx-container[jax=\"SVG\"][display=\"true\"] {\n  display: block;\n  text-align: center;\n  margin: 1em 0;\n}\n\nmjx-container[jax=\"SVG\"][display=\"true\"][width=\"full\"] {\n  display: flex;\n}\n\nmjx-container[jax=\"SVG\"][justify=\"left\"] {\n  text-align: left;\n}\n\nmjx-container[jax=\"SVG\"][justify=\"right\"] {\n  text-align: right;\n}\n\ng[data-mml-node=\"merror\"] > g {\n  fill: red;\n  stroke: red;\n}\n\ng[data-mml-node=\"merror\"] > rect[data-background] {\n  fill: yellow;\n  stroke: none;\n}\n\ng[data-mml-node=\"mtable\"] > line[data-line], svg[data-table] > g > line[data-line] {\n  stroke-width: 70px;\n  fill: none;\n}\n\ng[data-mml-node=\"mtable\"] > rect[data-frame], svg[data-table] > g > rect[data-frame] {\n  stroke-width: 70px;\n  fill: none;\n}\n\ng[data-mml-node=\"mtable\"] > .mjx-dashed, svg[data-table] > g > .mjx-dashed {\n  stroke-dasharray: 140;\n}\n\ng[data-mml-node=\"mtable\"] > .mjx-dotted, svg[data-table] > g > .mjx-dotted {\n  stroke-linecap: round;\n  stroke-dasharray: 0,140;\n}\n\ng[data-mml-node=\"mtable\"] > g > svg {\n  overflow: visible;\n}\n\n[jax=\"SVG\"] mjx-tool {\n  display: inline-block;\n  position: relative;\n  width: 0;\n  height: 0;\n}\n\n[jax=\"SVG\"] mjx-tool > mjx-tip {\n  position: absolute;\n  top: 0;\n  left: 0;\n}\n\nmjx-tool > mjx-tip {\n  display: inline-block;\n  padding: .2em;\n  border: 1px solid #888;\n  font-size: 70%;\n  background-color: #F8F8F8;\n  color: black;\n  box-shadow: 2px 2px 5px #AAAAAA;\n}\n\ng[data-mml-node=\"maction\"][data-toggle] {\n  cursor: pointer;\n}\n\nmjx-status {\n  display: block;\n  position: fixed;\n  left: 1em;\n  bottom: 1em;\n  min-width: 25%;\n  padding: .2em .4em;\n  border: 1px solid #888;\n  font-size: 90%;\n  background-color: #F8F8F8;\n  color: black;\n}\n\nforeignObject[data-mjx-xml] {\n  font-family: initial;\n  line-height: normal;\n  overflow: visible;\n}\n\nmjx-container[jax=\"SVG\"] path[data-c], mjx-container[jax=\"SVG\"] use[data-c] {\n  stroke-width: 3;\n}\n",[1092,1096,1097],{},"html pre.shiki code .sD7c4, html code.shiki .sD7c4{--shiki-default:#D73A49}html pre.shiki code .s7eDp, html code.shiki .s7eDp{--shiki-default:#6F42C1}html pre.shiki code .sgsFI, html code.shiki .sgsFI{--shiki-default:#24292E}html pre.shiki code .sYu0t, html code.shiki .sYu0t{--shiki-default:#005CC5}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}",{"title":807,"searchDepth":830,"depth":895,"links":1099},[1100],{"id":399,"depth":830,"text":262,"children":1101},[1102,1103,1112],{"id":429,"depth":852,"text":430},{"id":436,"depth":852,"text":437,"children":1104},[1105,1106,1111],{"id":470,"depth":866,"text":471},{"id":483,"depth":866,"text":484,"children":1107},[1108,1109,1110],{"id":494,"depth":895,"text":495},{"id":505,"depth":895,"text":506},{"id":525,"depth":895,"text":526},{"id":593,"depth":866,"text":594},{"id":610,"depth":852,"text":262,"children":1113},[1114],{"id":796,"depth":866,"text":797},"2025-11-14","Алгоритм сортировки выбором массива или списка","md","images\u002Fblog\u002Fpython\u002Fst26\u002Fimg.png",{},29,true,26,{"title":262,"description":1116},"OEKYDsGQ3XQtw2_Uby2GHxDBU8jvP5yL9PH_mdhusL0",[1126,1128],{"title":258,"path":259,"stem":260,"description":1127,"children":-1},"Примеры задач с использованием бинарного(двоичного) поиска",{"title":266,"path":267,"stem":268,"description":1129,"children":-1},"Алгоритм рекурсии и понятие стек вызовов функции",1780737510298]