Kod Huffmana - wysyłanie pustego wskaźnika

Question

Mam pytanie, implementuje uproszczoną wersję algorytmu Huffmana, wczytujemy ciąg złożony z małych liter, według tego pseudokodu: 

 

Ale mam problem, bo jak chcę podejrzeć, czy drzewo buduje mi się dobrze, dostaję, że wysyłam puste wskaźniki, nie mam pojęcia jak to naprawić. 

 

#include<iostream>
#include<cstdlib>
#include<vector>
#include<string.h>
#include<queue>
using namespace std;

struct characters
{
    char a;
    int likehood;
    characters *left, *right;
};

struct characters_comparsion
{
    bool operator() (const characters &first, const characters &second)
    {
        if(first.likehood > second.likehood) return true;

        if(first.likehood < second.likehood) return false;

        return false;
    }
};

void print (characters* root)
{

    if(root->left!=NULL)
    {
        print(root->left);
    }

    cout<<root->likehood<<" ";

    if(root->right!=NULL)
    {
        print(root->right);
    }
}

struct characters Huffman(priority_queue<characters, vector<characters>, characters_comparsion> Q)
{

    characters X,Y,*Z,m;
    unsigned long n;

    n = Q.size();

    for(int i=1; i<n; i++)
    {
        Z = new characters();

        X = Q.top();
        Q.pop();

        Y = Q.top();
        Q.pop();

        Z->left = &X;
        Z->right = &Y;
        Z->likehood = X.likehood + Y.likehood;

        Q.push(*Z);

    }

    print(Z);

    return *Z;
}

int main()
{

    vector<characters> how_many_times;
    how_many_times.reserve(26);
    string C="abcdefghijklmnoprqestuvwxyz", rows="abbceeeddfff";
    struct characters *w;
    priority_queue<characters, vector<characters>, characters_comparsion> Q;

    for(int i=0; i<26; i++)
    {
        how_many_times[i].a = C[i];
        how_many_times[i].likehood=0;
        how_many_times[i].left = NULL;
        how_many_times[i].right = NULL;
    }

   /* getline(cin, rows);*/

    unsigned long length = rows.length();

    for(int i=0; i<length; i++)
    {
        for(int j=0; j<26; j++)
        {
            if(how_many_times[j].a==rows[i])
            {
                how_many_times[j].likehood++;
                break;
            }
        }
    }

    for(int i=0; i<26; i++)
    {
        if(how_many_times[i].likehood!=0)
        {
            Q.push(how_many_times[i]);
        }
    }

    Huffman(Q);
        return 0;
}