Huffman coding Algorithm(c++) impementation

#include<bits/stdc++.h>
using namespace std;


struct data
{
    int cou;
};
data store[129];


struct node
{
    string  s;
    int frq;
    node *address;
    node *left,*right;
    bool operator<(const node& target) const
    {
        return frq >target.frq;
    }
};

node arr[100];
priority_queue<node>q;
int n;


int string_match(string ch,string str)
{
    int len = str.length(),p=0;
    for(int i=0; i<len; i++)
    {
        if(ch[0]==str[i])
        {
            p=1;
        }
    }
    return p;
}

node *generate_huffman_tree(string line)
{

    string left_str,right_str;
    int left_fr,right_fr;
    for(int i=0; i<n-1; i++)
    {
        node *z,current,next;
        z = new node();
        current = q.top();
        q.pop();
        left_str = current.s;
        left_fr  = current.frq;
        z->left  =  current.address;
        next = q.top();
        q.pop();
        z->right = next.address;
        right_str=next.s;
        right_fr =next.frq;
        z->s = left_str +right_str;
        z->frq = left_fr+right_fr;
        z->address = z;
        q.push(*z);
        //cout << z->s << ' ' << z->frq <<' '<< z->address <<' ' << endl;

    }

    node * root,x;
    x= q.top();
    root = x.address;


    return root;
}

void generate_code_word(node *root)
{
    cout << "code word" << endl <<endl;
    for(int i=0; i<n; i++)
    {
        node *parent,*leftt,*rightt;
        int m;
        string ch = arr[i].s;
        string bit="" ,str;
        parent = root;
        for (int j=0; j<2*n-1; j++)
        {
            str= parent->s;
            if(str==ch)
            {
                cout << ch <<' ' << bit <<endl;
                break;
            }
            leftt = parent->left;
            str = leftt->s;

            m=string_match(ch,str);
            if(m==0)
            {
                bit+="1";
                parent = parent->right;
            }
            else
            {
                bit+="0";
                parent=leftt;
            }
        }
    }

}
string  generate_encodedstring(node *root,string line)
{
    cout <<endl<< "show encoded string :" << endl;
    int length = line.length();
    string encoded_str="";
    for(int i=0; i<length; i++)
    {
        node *parent,*leftt,*rightt;
        int m;
        string ch ="";
        ch +=line[i];
        string bit="" ,str;
        parent= root;
        for (int j=0; j<2*n-1; j++)
        {
            str= parent->s;
            if(str==ch)
            {
                encoded_str+=bit ;
                break;
            }
            leftt = parent->left;
            str = leftt->s;

            m=string_match(ch,str);
            if(m==0)
            {
                bit+="1";
                parent = parent->right;
            }
            else
            {
                bit+="0";
                parent=leftt;
            }
        }
    }
    return encoded_str;

}
void huffman_decoding(node *root,string str)
{
    cout << endl <<"Decoded String : " << endl;
    int len =  str.length();
    node *parent;
    parent = root;
    for(int i=0; i<len; i++)
    {
        if(str[i]=='0')
        {
             parent = parent->left;
        }
        else if(str[i]=='1')
        {
            parent = parent->right;
        }
        if(parent->left ==NULL)
        {
            cout << parent->s ;
            parent=root;
        }
    }
    cout << endl;
}

int main()
{
    string line;
    getline(cin ,line);
    int length = line.length();
    for(int i=0; i<129; i++)
    {
        store[i].cou=0;
    }
    for(int i=0; i<length; i++)
    {
        int l = line[i];
        store[l].cou++;
    }
    n =0;

    for(int i=0; i<129; i++)
    {
        if(store[i].cou !=0)
        {
            string temp = "";
            char c = i;
            temp+=c;
            arr[n].s = temp;
            arr[n].frq=store[i].cou;
            arr[n].left =NULL;
            arr[n].right=NULL;
            arr[n].address = &arr[n];
            q.push(arr[n]);
            n++;
        }
    }
    node *result;

    result =  generate_huffman_tree(line);

    generate_code_word(result);
    string str = generate_encodedstring(result,line);
    cout << str << endl;
     huffman_decoding(result,str);

}

INPUT:

Hey ! Are you OK ?

OUTPUT:

code word

  11
! 0110
? 0111
A 0000
H 0001
K 0101
O 0100
e 001
o 1010
r 1001
u 1000
y 1011

show encoded string :
000100110111101101100001001001111011101010001101000101110111

Decoded String :
Hey ! Are you OK ?

Binary Search Tree Algorithm Implementation in (C++/CPP)

#include<cstdio>
using namespace std;

struct node
{
    int data;
    node *leftchild;
    node *rightchild;
};
node *root=NULL;


void insert_data(int data)
{
    node *current,*new_node,*parent;
    new_node = new node();
    new_node->data=data;
    new_node->leftchild=NULL;
    new_node->rightchild=NULL;
    if(root==NULL)
    {
        root = new_node;
    }
    else
    {
        current = root;
        parent = NULL;

        while(1)
        {
            parent=current;
            if(current->data<data)
            {
                current=current->rightchild;
                if(current==NULL)
                {
                    parent->rightchild=new_node;
                    return;
                }
            }
            else
            {
                current=current->leftchild;
                if(current==NULL)
                {
                    parent->leftchild=new_node;
                    return;
                }
            }
        }

    }
}
void search_data(int data)
{
    node *current;
    current=root;

    while(current->data!=data)
    {


        if(current->data<data)
        {
            current=current->rightchild;
        }
        else
        {
            current = current->leftchild;
        }
        if(current==NULL)
        {
            printf("Data Not Found\n");
            return;
        }

    }
    printf("%d Yea data is Found\n",current->data);
    return;

}
int main()
{

    int n,data;

    printf("how many node\n");
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        scanf("%d",&data);
        insert_data(data);
    }

    printf("Searching data\n");
    while(1)
    {
        scanf("%d",&data);
        search_data(data);
    }
    printf("Searching completed\n");
}


Reference :https://www.tutorialspoint.com/data_structures_algorithms/tree_data_structure.htm

10062 - Tell me the frequencies!(cpp)

#include<stdio.h>
#include<algorithm>
#include<cstring>
using namespace std;
struct keep
{
    int charecter=0;
    int cont=0;
};
keep arr[200];
bool comp(keep x,keep y)
{
    if(x.cont==y.cont)
       return x.charecter > y.charecter;
    return x.cont < y.cont;
}
int main()
{
    char str[9999];
    int len,i,tag=0;
    while(gets(str))
    {
        len= strlen(str);
        if(tag>0)
        {
            printf("\n");
        }
        tag++;
        for(i=0; i<200; i++)
        {

            arr[i].charecter=0;
            arr[i].cont=0;
        }
        for(i=0; i<len; i++)
        {
            arr[str[i]].charecter=str[i];
            arr[str[i]].cont++;
        }
        sort(arr,arr+200,comp);
        for(i=0; i<200; i++)
        {
            if(arr[i].cont!=0)
            printf("%d %d\n",arr[i].charecter,arr[i].cont);

        }
        memset(str,'\0',sizeof(str));
    }
    return 0;
}