add comments

LibraryCPP/binaryHeap.cpp

@@ -2,11 +2,11 @@
 
 struct BinaryHeap
 {
-    void** heapData;
-    size_t heapSize;
-    size_t dataCount;
-    Comparator compare;
-    Destructor destroy;
+    void** heapData;    // Массив указателей для хранения элементов кучи
+    size_t heapSize;    // Максимальное количество элементов, которое может хранить куча
+    size_t dataCount;   // Текущее количество элементов в куче
+    Comparator compare; // Функция-компаратор для сравнения элементов кучи
+    Destructor destroy; // Функция-деструктор для удаления элементов
 };
 
 BinaryHeap* binaryHeap_create(const size_t size, Comparator comp, Destructor dest)
@@ -29,52 +29,82 @@ void binaryHeap_swapData(BinaryHeap* heap, const size_t firstIndex, const size_t
 
 void binaryHeap_heapify(BinaryHeap* heap, int i)
 {
-    int left = 2 * i + 1;
-    int right = 2 * i + 2;
-    int smallest = i;
+    // Вычисляем индексы левого и правого дочерних элементов для данного узла
+    int left = 2 * i + 1;  // Индекс левого дочернего элемента
+    int right = 2 * i + 2; // Индекс правого дочернего элемента
+    int smallest = i;      // Индекс наименьшего элемента, начинаем с текущего узла
 
+    // Проверяем, меньше ли левый дочерний элемент текущего узла
+    // и находится ли он в пределах размера кучи
     if (left < (int)heap->dataCount && heap->compare(heap->heapData[left], heap->heapData[smallest]) < 0)
         smallest = left;
+
+    // Аналогично проверяем правый дочерний элемент
     if (right < (int)heap->dataCount && heap->compare(heap->heapData[right], heap->heapData[smallest]) < 0)
         smallest = right;
+
+    // Если один из дочерних элементов меньше текущего элемента, меняем их местами
     if (smallest != i)
     {
         binaryHeap_swapData(heap, i, smallest);
+        // Рекурсивно применяем heapify к измененному дочернему элементу
         binaryHeap_heapify(heap, smallest);
     }
 }
 
 void binaryHeap_insert(BinaryHeap* heap, void* node)
 {
+    // Проверяем, не достигнут ли максимальный размер кучи.
+    // Если достигнут, то новый элемент добавить нельзя.
     if (heap->dataCount == heap->heapSize)
         return;
 
+    // Увеличиваем количество элементов в куче на единицу.
     heap->dataCount++;
+    // Рассчитываем индекс, где будет размещён новый элемент.
     size_t i = heap->dataCount - 1;
+    // Размещаем новый элемент в конец массива кучи.
     heap->heapData[i] = node;
 
+    // Проходим циклом вверх по куче для восстановления её свойств.
+    // Пока не достигнут корень кучи и пока родительский элемент больше нового элемента...
     while (i != 0 && heap->compare(heap->heapData[(i - 1) / 2], heap->heapData[i]) > 0)
     {
+        // Обмениваем новый элемент с его родителем.
         binaryHeap_swapData(heap, (i - 1) / 2, i);
+        // Перемещаем индекс на позицию родительского элемента.
         i = (i - 1) / 2;
     }
 }
 
 void* binaryHeap_extractMin(BinaryHeap* heap)
 {
+    // Проверяем, есть ли элементы в куче. Если нет, возвращаем NULL.
     if (heap->dataCount <= 0)
         return NULL;
+
+    // Если в куче только один элемент, уменьшаем количество элементов
+    // и возвращаем этот единственный элемент.
     if (heap->dataCount == 1)
     {
         heap->dataCount--;
         return heap->heapData[0];
     }
 
+    // Сохраняем корневой элемент (минимальный элемент кучи) для последующего возвращения.
     void* root = heap->heapData[0];
+
+    // Заменяем корневой элемент последним элементом в куче.
     heap->heapData[0] = heap->heapData[heap->dataCount - 1];
+
+    // Уменьшаем количество элементов в куче на единицу.
     heap->dataCount--;
+
+    // Применяем процедуру "heapify" начиная с корня, чтобы восстановить свойства кучи
+    // и убедиться, что все родительские элементы меньше своих дочерних.
     binaryHeap_heapify(heap, 0);
 
+    // Возвращаем изначальный корневой элемент, который является минимальным элементом кучи.
     return root;
 }
 

LibraryCPP/huffmanTree.cpp

@@ -1,15 +1,17 @@
 #include "huffmanTree.h"
 
+// Ñòðóêòóðà óçëà äåðåâà Õàôôìàíà
 struct HuffmanNode
 {
-    bool isLeaf;
-    unsigned long long int weight;
-    unsigned char symbol;
+    bool isLeaf; // Ôëàã, óêàçûâàþùèé, ÿâëÿåòñÿ ëè óçåë ëèñòîì
+    unsigned long long int weight; // Âåñ óçëà, èñïîëüçóåòñÿ äëÿ ïîñòðîåíèÿ äåðåâà
+    unsigned char symbol; // Ñèìâîë, ñîîòâåòñòâóþùèé óçëó (òîëüêî äëÿ ëèñòüåâ)
 
-    HuffmanNode* leftNode;
-    HuffmanNode* rightNode;
+    HuffmanNode* leftNode; // Óêàçàòåëü íà ëåâûé äî÷åðíèé óçåë
+    HuffmanNode* rightNode; // Óêàçàòåëü íà ïðàâûé äî÷åðíèé óçåë
 };
 
+// Ôóíêöèÿ äëÿ ñîçäàíèÿ ëèñòîâîãî óçëà
 HuffmanNode* huffman_createLeafNode(unsigned char symbol, unsigned long long int weight)
 {
     HuffmanNode* node = new HuffmanNode;
@@ -21,6 +23,7 @@ HuffmanNode* huffman_createLeafNode(unsigned char symbol, unsigned long long int
     return node;
 }
 
+// Ôóíêöèÿ äëÿ ñîçäàíèÿ âíóòðåííåãî óçëà
 HuffmanNode* huffman_createInternalNode(HuffmanNode* leftNode, HuffmanNode* rightNode)
 {
     HuffmanNode* node = new HuffmanNode;
@@ -31,52 +34,61 @@ HuffmanNode* huffman_createInternalNode(HuffmanNode* leftNode, HuffmanNode* righ
     return node;
 }
 
+// Ïîëó÷åíèå ëåâîãî äî÷åðíåãî óçëà
 HuffmanNode* huffman_getLeftNode(HuffmanNode* node)
 {
     return node ? node->leftNode : NULL;
 }
 
+// Ïîëó÷åíèå ïðàâîãî äî÷åðíåãî óçëà
 HuffmanNode* huffman_getRightNode(HuffmanNode* node)
 {
     return node ? node->rightNode : NULL;
 }
 
+// Óñòàíîâêà ëåâîãî äî÷åðíåãî óçëà
 void huffman_setLeftNode(HuffmanNode* node, HuffmanNode* newNode)
 {
     node->leftNode = node->leftNode ? node->leftNode : newNode;
 }
 
+// Óñòàíîâêà ïðàâîãî äî÷åðíåãî óçëà
 void huffman_setRightNode(HuffmanNode* node, HuffmanNode* newNode)
 {
     node->rightNode = node->rightNode ? node->rightNode : newNode;
 }
 
+// Ïðîâåðêà, ÿâëÿåòñÿ ëè óçåë ëèñòîì
 bool huffman_nodeIsLeaf(HuffmanNode* node)
 {
     return node->isLeaf;
 }
 
+// Ïîëó÷åíèå ñèìâîëà èç óçëà
 unsigned char huffman_getNodeChar(HuffmanNode* node)
 {
     return node->symbol;
 }
 
+// Ïîëó÷åíèå âåñà óçëà
 unsigned long long int huffman_getNodeWeight(HuffmanNode* node)
 {
     return node->weight;
 }
 
+// Óäàëåíèå äåðåâà Õàôôìàíà (ðåêóðñèâíàÿ ôóíêöèÿ)
 HuffmanNode* huffman_deleteTree(HuffmanNode* node)
 {
     if (node)
     {
-        huffman_deleteTree(node->leftNode);
-        huffman_deleteTree(node->rightNode);
-        delete node;
+        huffman_deleteTree(node->leftNode); // Óäàëåíèå ëåâîãî ïîääåðåâà
+        huffman_deleteTree(node->rightNode); // Óäàëåíèå ïðàâîãî ïîääåðåâà
+        delete node; // Óäàëåíèå òåêóùåãî óçëà
     }
     return nullptr;
 }
 
+// Êîìïàðàòîð äëÿ óçëîâ (èñïîëüçóåòñÿ â î÷åðåäè ñ ïðèîðèòåòîì)
 int huffmanNodeComparator(const void* nodeA, const void* nodeB)
 {
     HuffmanNode* huffmanNodeA = (HuffmanNode*)nodeA;
@@ -89,24 +101,26 @@ int huffmanNodeComparator(const void* nodeA, const void* nodeB)
     return 0;
 }
 
+// Äåñòðóêòîð äëÿ óçëîâ (èñïîëüçóåòñÿ â î÷åðåäè ñ ïðèîðèòåòîì)
 void huffmanNodeDestructor(void* node)
 {
     HuffmanNode* huffmanNode = (HuffmanNode*)node;
     huffman_deleteTree(huffmanNode);
 }
 
+// Ôóíêöèÿ äëÿ ïå÷àòè äåðåâà Õàôôìàíà (äëÿ îòëàäêè)
 void huffman_printTree(HuffmanNode* node, unsigned int height)
 {
     if (node)
     {
-        huffman_printTree(node->rightNode, height + 1);
-        for (unsigned int i = 0; i < height; i++)
+        huffman_printTree(node->rightNode, height + 1); // Ïå÷àòü ïðàâîãî ïîääåðåâà
+        for (unsigned int i = 0; i < height; i++) // Îòñòóï äëÿ âèçóàëèçàöèè óðîâíÿ
             std::cout << "  ";
         if (node->isLeaf)
-            std::cout << (unsigned char)node->symbol;
+            std::cout << (unsigned char)node->symbol; // Ïå÷àòü ñèìâîëà ëèñòà
         else
-            std::cout << node->weight;
-        huffman_printTree(node->leftNode, height + 1);
+            std::cout << node->weight; // Ïå÷àòü âåñà âíóòðåííåãî óçëà
+        huffman_printTree(node->leftNode, height + 1); // Ïå÷àòü ëåâîãî ïîääåðåâà
     }
     else
         std::cout << std::endl;