Реализуйте методы удаления/поиска в ХТ с открытым хешированием

#pragma once
 
#include <string>
 
#define NAMELENGTH 10                   // Зафикируем длину имени
typedef char FruitName[NAMELENGTH];     // тип имя фрукта
 
class HashTable                         // Хеш-таблица
{ 
 
public:
    HashTable();
    ~HashTable();
    void add(FruitName fr_name, int fr_count);
    void resize();
 
    void del(FruitName fr_name);
    int find(FruitName fr_name);
 
private:
    struct ChainNode                    // узел в цепочке 
    {
        FruitName fruit_name;           // ключ
        int fruit_count;                // значение
 
        ChainNode* next;                // указатель на следующий узел в цепочке
 
        ChainNode(FruitName _fn, int _fc) :
            fruit_count(_fc) 
        {
            strcpy(fruit_name, _fn);
            next = nullptr;
        }
        ~ChainNode() 
        {
            if (next != nullptr)        // удаляем друг за дружкой
                delete next;
        }
    };
    
    int hash_func(FruitName fr_name);   // хеш-функция для поиска индекса цепочки
 
    ChainNode** chain_tops;             // массив указателей на цепочки
    int mem_size;                       // количество выделенной памяти
    int count;                          // колиество добавленных пар ключ-значение
};

//#include "../headers/hash_table.h"
#include "hash_table.h"
 
HashTable::HashTable() 
{
    mem_size = 8;                       // выделение памяти, инициализация
    chain_tops = new ChainNode * [mem_size];
    for (int i = 0; i < mem_size; i++) 
    {
        chain_tops[i] = nullptr;
    }
    count = 0;
}
 
HashTable::~HashTable() 
{
    for (int i = 0; i < mem_size; i++)  // прибираем за собой
        if (chain_tops[i] != nullptr)
            delete chain_tops[i];
    delete[] chain_tops;
}
 
int HashTable::hash_func(FruitName fr_name) 
{
    int sum = 0, i = 0;                 // вычисляем индекс
    for (; i < strlen(fr_name); i++) 
    {
        sum += fr_name[i];
    }
    // метод деления
    return sum % mem_size;              // значение точно будет между 0 и memsize
}
void HashTable::add(FruitName fr_name, int fr_count) 
{
     //пересчет таблицы, если много элементов внутри
     //боремся с коллизиями
    if (count / mem_size > 3)
        resize();
    int index = hash_func(fr_name);     // вычислили индекс в массиве
    if (chain_tops[index] != nullptr) 
    {
        /* если цепока с таким индексом уже есть, то
        создаем новый узел и делаем его верхним */
        ChainNode* newNode = new ChainNode(fr_name, fr_count);
        newNode->next = chain_tops[index];
        chain_tops[index] = newNode;
    }
    else {
        // если нет цепочки с таким хешем
        chain_tops[index] = new ChainNode(fr_name, fr_count);
    }
    count++;
}
 
void HashTable::resize() 
{
    ChainNode** save_ct = chain_tops;           // запоминаем старый массив
    int oldSize = mem_size;
 
    mem_size *= 2;                              // увеличиваем размер в два раза  
    count = 0;                                  // обнуляем количество элементов
    chain_tops = new ChainNode * [mem_size];    // выделяем новую память
    for (int i = 0; i < mem_size; i++) 
    {
        chain_tops[i] = nullptr;
    }
 
    for (int i = 0; i < oldSize; i++) 
    {
        ChainNode* current = save_ct[i];
        while (current != nullptr) 
        {
            // пересчитываем хеши и добавляем в новый массив
            add(current->fruit_name, current->fruit_count);
            current = current->next;
        }
        // чистим за собой
        delete current;
    }
    // чистим за собой
    delete[] save_ct;
}

//#include "../headers/hash_table.h"
#include "hash_table.h"
 
void HashTable::del(FruitName fr_name) 
{
    int indexList = hash_func(fr_name);
    while (true)
    {
        if(chain_tops[indexList]->fruit_name == fr_name)
        {
            chain_tops[indexList]=nullptr;
        }
            break;
    }
}
 
int HashTable::find(FruitName fr_name) 
// вернуть нужно значение, соответствующее ключу fr_name
// если такого ключа нету в таблице, то верните -1
// Ваш код
{
    int indexList = hash_func(fr_name);
    
    while (true)
    {
        if (chain_tops[indexList]->fruit_name == fr_name)
            return chain_tops[indexList]->fruit_count;
        else
        {
            return -1;
        }
        break;
    }
}

//#include "../headers/hash_table.h"
#include "hash_table.h"
 
void HashTable::del(FruitName fr_name) 
{
    {
        // Ваш код
        int index = hash_func(fr_name);
        if (index != -1) 
        {
            ChainNode* p_current = chain_tops[index];
            ChainNode* p_next = nullptr;
            if (!strcmp(fr_name, p_current->fruit_name)) 
            {       //если нашли в корне
                if (chain_tops[index]->next) 
                {   //сохраняем потомка если есть
                    p_next = new ChainNode(p_current->next->fruit_name, p_current->next->fruit_count);
                    p_next->next = p_current->next->next;
                }
                delete chain_tops[index];   //удаляем найденный 
                chain_tops[index] = p_next; //потомка ставим на его место
                count--;
            }
            else {
                p_next = chain_tops[index]->next;//ищем вглубь
                while (p_next) {
                    if (!strcmp(fr_name, p_next->fruit_name)) 
                    {//если нашли 
                        if (p_next->next) 
                        {
                            //запомнили потомка если есть
                            p_current->next = new ChainNode(p_next->next->fruit_name, p_next->next->fruit_count);
                            p_current->next->next = p_next->next->next;
                            delete p_next;
                            count--;
                        }
                        else 
                        {
                            p_current->next = nullptr;
                            delete p_next;
                            count--;
                        }
                        break;
                    }
                    p_next = p_next->next;
                }
            }
        }
 
 
    }
}
 
int HashTable::find(FruitName fr_name) 
// вернуть нужно значение, соответствующее ключу fr_name
// если такого ключа нету в таблице, то верните -1
// Ваш код
{
    int index = hash_func(fr_name);
    if (chain_tops[index] != nullptr)
        return chain_tops[index]->fruit_count;
    else
        return -1;
}