✅Quick Sort in-place in Python

📚In-place Quick Sort — это модификация быстрой сортировки(Quick Sort был пост выше),
которая сортирует элементы массива на месте, без использования
дополнительной памяти для создания новых массивов.

📑Вот этот алгоритм уже можно использовать на практике, но с подмечу,
если есть какие то встроенные варианты(функции, методы) на вашем языке, то
лучше использовать их, так как они могут быть написаны на более производительных
языках, например C or Rust.

📉Сложность: O(log n)

⚙️Принцип работы:
➖ Выбирается опорный элемент (pivot), обычно последний, первый или случайный элемент.

➖ Все элементы, меньшие pivot, перемещаются влево, а большие — вправо.

➖ После этого массив рекурсивно делится на две части, которые сортируются по тому же принципу.


#algorithms #python

✅Вычисление ОПРЕДЕЛИТЕЛЯ(Determinant) 2x2, 3x3, 4x4. На python.

#algorithms #python

✅Вычисление Минора в ОПРЕДЕЛИТЕЛИ(Determinant) 2x2, 3x3, 4x4

#algorithms #python

✅DFS algorithm С++ - Поиск в глубину

📚Алгоритм поиска в глубину (DFS, Depth First Search) обходит граф так,
что он идет "вглубь" от начальной вершины по каждому пути до конца,
прежде чем вернуться назад и исследовать следующий путь. Давайте разберем
его пошагово.

⚙️Как работает алгоритм:

💡1.Начинаем с начальной вершины (например, 0).
💡2.Помечаем её как посещённую.
💡3.Идем по всем её смежным вершинам.
💡4.Если соседняя вершина ещё не посещена, то:
- Переходим к ней и повторяем процесс (углубляемся).
💡5.Если все соседи посещены или их нет, возвращаемся назад и ищем другие пути.
💡6.Продолжаем, пока не обойдем все достижимые вершины.

📑Читать: тут

#algorithms #cpp

✅Sort Merge in Python

📚Сортировка слиянием — это алгоритм "разделяй и властвуй", который
разбивает массив на две части, рекурсивно сортирует их, а затем
объединяет в один отсортированный массив.

⚙️Принцип работы:
➖Разделение: массив разбивается на две равные части.
➖Сортировка: каждая часть сортируется рекурсивно.
➖Слияние: два отсортированных подмассива объединяются в один.

📉Сложность: O(n log n)

#algorithms #python

Реализация простого HashMap на C++

📚Создание простой версии HashMap на с++,
key типа string, value типа int. Для решение проблемы с коллизии я
использовал алгоритм "Прямой адресации".

------------------------------
⚙️Кратко о коде:

➖#define FILL_FACTOR 75 - это параметр который говорит когда стоит расширять HashMap.
Если количество элементов if this->count * 100 >= this->capacity * FILL_FACTOR то мы расширяем наш HashMap, этим занимается realloc().

➖int get() - Просто выдаёт значение по ключу

➖long hashed() - это функция преобразует key в хэш

➖void init() - инициализируем и выделяем память на наш HashMap.

➖typedef struct {} Item - Описывает элемент внутри HashMap.

➖elements - элементы в HashMap.

➖capacity - выделенный размер для элементов в HashMap.

➖count - количество заполненных элементов в HashMap.

------------------------------

📑Почитать о работе HashMap: тут

#algorithms #cpp

✅Структура данных Stack написанная на Java

⚙️Коротко о коде:
———————————
💡Поле limitSize - это поле(переменная) отвечает за переполнения stack.
Если длина stack.length > limitSize то это не допустимо.
———————————
💡Метод isLimitSize - отвечает за проверку не переполнен ли stack.
———————————
💡Метод push - добавляет в вершину stack. При этом я использовал примитивный тип
данных(array) и по этой причине там пересоздаётся массив.
———————————
💡Метод pop - удаляет вершину stack и возвращает
этот элемент (По прицепу stack).
———————————
💡Метод peek - Возвращает без удаления вершину stack.
———————————
💡Метод size - Возвращает размер stack.
———————————
💡Метод isEmpty - Проверяет пуст ли stack.
———————————
💡Метод toString - Возвращает stack в виде Type String.
———————————

👁‍🗨Что такое stack: читать

#algorithms #java

✅Реализация структуры данных Queue(Очереди) на Java

⚙️Коротко о коде:
💡void enqueue(int el) - добавление элемента в очередь
💡int dequeue() - удаление из queue и возврат элемента
💡int peek() - получение первого элемента в очереди
💡boolean isEmpty() - пуст ли queue true/false
💡int size() - размер queue

👁‍🗨Что такое очередь: читать

#algorithms #java

Таблица простых интегралов на Python

#algorithms #python

🟢Реализация Графа (Graph) на Java (Pt 2)

❓Какие свойства есть у Графа(Graph) ?

📚Как мы выяснили ранее, граф состоит из Рёбер(Edge) и Узлами(Node),
их можно представить в виде двух мерного массива int[][] но это не эффективно,
По этой причине в основе понимания Графа(Graph), стоит понимать такие структуры данных
как Деревья(Tree), Хэш таблицы(HashMap), Связанный списки и ещё не из структур данных Рекурсии. Если эти
структуры данных вам понятны, значит и эта структура будет понятно.

💡Окей. Давайте разберём Graph на составные, а именно Edge и Node.
Node - это обЪект имеющий свойства
* value(может быть любым типом данных)
* edges(все узлы которые есть у node)
* parents(все вершины которые ведут к текущей node, то есть родители node )

Edge - это обЪект имеющий свойства
* adjacentNode - соседний узел
* weight - вес ребра(Каждое ребро имеет вес, в нашем примере для простоты все веса всех ребер равны 1)

#algorithms #java

🟢Алгоритм сортировки слиянием (Merge Sort) на Golang

📚Описание:
Сортировка слиянием — это один из эффективных алгоритмов
сортировки, основанный на принципе разделяй и властвуй.
Алгоритм состоит из двух этапов:

1. Разделение массива на подмассивы mergeSort().
2. Слияние подмассивов в отсортированном порядке mergeTwoSlice().

Предположим, у нас есть массив: [5, 3, 8, 6, 2, 7, 4, 1].
- Разделяем массив на 2 части left = [5, 3, 8, 6]; right = [2, 7, 4, 1]
- И так рекурсивно делим массив до одного элемента в нём
- Дальше Соединяем обратно [5] и [3] -> [3, 5], [8] и [6] -> [6, 8] и т.д

📉Сложность:
⌚️Время: O(n log n)
💾Память: O(n)

#algorithms #go

✅Алгоритм QuickSort(Быстрая сортировка) на Golang

💡Объяснение:

📚QuickSort - это алгоритм быстрой сортировки элементов в массиве.
Принцип работы основан на методологии "Разделяй и властвуй".

🔵Алгоритм имеет 3️⃣ этапа:
1. На вход поступает не отсортированный массив.
2. Мы должны выбрать pivot element (опорный элемент), есть много вариантов как мы
будем выбирать этот элемент, но мы воспользуемся самым простым, а именно будем брать
последний элемент массива.
3. Берём pivot и все элементы которые меньше pivot, располагаем слева от pivot,
все элементы которые больше pivot располагаем справа.

🔄И повторяем действия 2 и 3 пункт рекурсивно,
до тех пор пока массив не будет отсортирован.

⚙️Уточнение:
параметры maxIndex и minIndex это диапазон сортировки массива.
slice - можно воспринимать как array, просто в golang
slice это динамический массив.


👁‍🗨Пример:
« [9, 12, 9, 2, 17, 1, 6]
» [1, 2, 6, 9, 9, 12, 17]

📉Сложность:
⌚️Время: O(n log n)

#algorithms #go

🟢Алгоритм Insertion Sort(Сортировка вставки) на Golang

⚙️Суть алгоритма:

💡Начинаем с того что в function insertionSort мы
принимаем не отсортированный массив. Потом
идёт проверка если массив пустой или имеет только
1 элемент, мы считаем его отсортированным и завершаем
работу функции (или возвращаем передаваемый массив, если
реализация не через указатель). Дальше пробегаемся по
всему массиву и на каждой итерации первого цикла, мы
вызываем 2 цикл, который уже от текущего элемента (*(nums[i]))
до нулевого элемента(то есть начало массива). И при
этом сравниваем текущий элемент с предыдущим, и
если текущей элемент окажется меньше предыдущего, то меняем местами
их в массиве, в противном случаи выходим из 2 цикла, и так до конца всего
массива. На выходи получаем отсортированный массив.


📉Сложность:
⌚️Время: O(n**2)
💾Память: O(1)

#algorithms #go

✅Задача «Add Digits»

📚Дано целое число num, многократно складывайте все его цифры,
пока в результате не останется только одна цифра, и верните ее.

👁‍🗨Пример 1:
« num = 38
» 2

👁‍🗨Пример 2:
« num = 1701
» 9

💡Решение:
В решении используется чистая математика,
и скажу честно я не смог решить это задачу
за O(1) самостоятельно. Меня довольно сильно удивило
такое короткое и лаконичное решение задачи,
хотя казалось бы что надо использовать цикл/рекурсию
для решения(что я по началу и сделал ) но понял что сложность
алгоритма в таком случаи было бы O(n) или что ещё хуже O(n**2).
В задачи было сказано что её можно решить за O(1), что меня естественно удивило.
И про гуглив решение нашёл как решить эту задачу за время O(1).

📉Сложность:
⌚️Время: O(1)
💾Память: O(1)

#algorithms #java

✅Первый и второй замечательный
придел с графиком на Python

⚙️Коротко о коде:

- class Limit - просто объект для абстракции задачи.

- method first_wonderful_limit - вычисление первого
замечательного предела.

- method second_wonderful_limit - вычисление второго
замечательного предела.

- private method _render - служит для отрисовки графиков
для функции первого и второго предела.

- для вычисления используем lib numpy,
numpy - мощная математическая библиотека.

- для отрисовки графиков используем lib matplotlib.

pip install numpy 
pip install matplotlib

#algorithms #python

✅Реализация универсальной функции reverse с нуля на Rust

#algorithms #rust

✅Двусвязный список (Doubly Linked List)

Двусвязный список — структура данных, где каждый узел хранит:

✔️значение
✔️ссылку на следующий узел (next)
✔️ссылку на предыдущий узел (prev)

1️⃣Узел списка:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

2️⃣Двусвязный список:

class DoublyLinkedList:
    def __init__(self):
        self.head = None

3️⃣Вставка в начало — O(1)

    def add_front(self, data):
        new_node = Node(data)
        if self.head:
            self.head.prev = new_node
            new_node.next = self.head
        self.head = new_node

4️⃣Обход списка — O(n)

    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=" <-> ")
            current = current.next
        print("None")

#ComputerScience #algorithms