Переполнение стека

Переполнение стека :(

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <stdlib.h>
using namespace std;

struct Tree {
    Tree *left, *right, *parent;
    string symbol;
    int how_many;
    string code;
};

Tree* Element(string my_symbols, int all_how_many, string code) {
    Tree* element = new Tree;
    if (element != NULL) {
        element = new Tree;
        element->symbol += my_symbols;
        element->how_many = all_how_many;
        element->code = "";
        element->left = NULL;
        element->right = NULL;
    }
    return element;
}

void Node_add(Tree* the_element, string symbol, int how_many, string code, int &g) {
    Tree* node, * parent;
    if (g == 0) {
        g++;
        return;
    }
    for (parent = the_element; the_element != NULL; ) {
        parent = the_element;
        if (how_many < the_element->how_many) {
            the_element = the_element->left;
        }
        else if (how_many > the_element->how_many) {
            the_element = the_element->right;

        }
        else {
            return;
        }
        node = Element(symbol, how_many, code);
        if (how_many < parent->how_many) {
            parent->left = node;
        }
        else {
            parent->right = node;
        }
    }
}

void Coding(Tree *the_element, Tree *symbols, int Nmax, int all_how_many, string my_symbols, string old_code = "", int k = 0, string new_code = "", int g = 0) {
    Node_add(the_element, my_symbols, all_how_many, new_code, g);
    int global = 0;
    string code = old_code + new_code;
    string half1_symbols = "", half2_symbols = "";
    if (k == 1) {
        symbols[global].code = code;
        global++;
        return;
    }
    int num = 0;
    int Nnew = Nmax;
    int k1 = 0, k2 = 0;
    int half_how_many = all_how_many / 2, half1 = 0, half2 = 0;
    for (Nnew; Nnew > 0; Nnew--) {
        if (half1 + symbols[Nnew].how_many < half_how_many) {
            half1 += symbols[Nnew].how_many;
            half1_symbols += symbols[Nnew].symbol;
            k1++;
        }
    }
    half2 = all_how_many - half1;
    for (num; num < Nmax - k1; num++) {
        half2_symbols += symbols[num].symbol;
        k2++;
    }
    Coding(the_element, symbols, Nmax, half1, half1_symbols, code, k1, "0", g);
    Coding(the_element, symbols, Nmax, half2, half2_symbols, code, k2, "1", g);
}

int main()
{
    setlocale(LC_ALL, "Russian");
    ifstream file4("E:\\text4.txt");
    if (!file4)
    {
        cout << "Error!" << endl;
        exit(1);
    }
    char s;
    int size = 0, num_2;
    while (!file4.eof()) //Выяснили размер текста
    {
        file4.get(s);
        size++;
    }
    file4.close();
    file4.open("E:\\text4.txt");
    int i = 1, Nmax = 1, j, k_new;
    string text;
    text.clear();
    while (!file4.eof())
    {
        file4.get(s);
        text = text + s;
    }
    file4.close();
    Tree* symbols = new Tree[size];
    string my_symbols;
    my_symbols.clear();
    my_symbols += text[0];
    for (i; i < size; i++) {
        j = Nmax - 1;
        k_new = Nmax;
            for (k_new; k_new > 0; k_new--) {
                if (text[i] != my_symbols[0]) {
                    if (j != 0) {
                        j--;
                    }
                    else {
                        my_symbols += text[i];
                        Nmax++;
                        break;
                    }
                }
                else {
                    break;
                }
            }
    }

    for (int num = 0; num < Nmax; num++) {
        num_2 = 0;
        for (int num_1 = 0; num_1 < size; num_1++) {
            if (text[num_1] == my_symbols[num])
                num_2++;
        }
        symbols[num].how_many = num_2;
    }

    for (int num = 0; num < Nmax; num++) {
        symbols[num].symbol = my_symbols[num];
    }

    bool truth = false;
    while (!truth) {
        truth = true;
        for (int num = 0; num < Nmax; num++) {
            if (symbols[num].how_many < symbols[num + 1].how_many) {
                swap(symbols[num], symbols[num + 1]);
                truth = false;
            }
        }
    }
    int all_how_many = 0;
    for (int num = 0; num < Nmax; num++) {
        all_how_many += symbols[num].how_many;
    }

    Tree* the_element = Element(my_symbols, all_how_many, "");
    Coding(the_element, symbols, Nmax, all_how_many, my_symbols);
    delete[] symbols;
    system("pause");
}