#include<iostream>
#include<cstdio>
#include<malloc.h>
#include<string.h>
//构建哈夫曼树来判定是否有重复的二叉树路径
typedef struct BiTCode{                  // 结点结构
    int flag;
    struct BiTCode *Left, *Right; // 左右孩子指针
}BiTCode;

int main()
{
    int n;
    scanf("%d",&n);
   
    BiTCode *Root;
    Root=(BiTCode *)malloc(sizeof(BiTCode));
    Root->flag = 0;
    Root->Left = NULL;
    Root->Right = NULL;
   
    for(int i=0;i<n;i++)            //   iiiii,循环读取n个字符串
    {
        char str[1000]="";
        scanf("%s",&str);
        
        int len;
        len=strlen(str);
        
        BiTCode *p;
        p= Root;
        for(int j=0;j<len;j++)        //    jjjjj，读取当前字符串的每一位
        {
            if(str[j]=='0')
            {
                if( (p->Left)==NULL )
                {
                    p->Left =(BiTCode *)malloc(sizeof(BiTCode));
                    p = p->Left;
                    p->Left  = NULL;
                    p->Right = NULL;
                    if (j == len - 1)
                    {                //读到最后一个字符
                        p->flag = 1;//将在此停止的放置标记为1
                    }
                    else
                    {                //将路上遍历过的节点都设置成为0
                        p->flag = 0;
                    }
                }else
                {
                    if( (j==len-1)||(p->Left->flag) )//当前读取的字符串的最后一位或者有字符串在这里结束
                    {
                        printf("%s\n",str);
                        return 0;
                    }else
                    {
                        p=p->Left;
                    }
                }
            }
            //右边
            if(str[j]=='1')
            {
                if( (p->Right)==NULL )
                {
                    p->Right =(BiTCode *)malloc(sizeof(BiTCode));
                    p = p->Right;
                    p->Left  = NULL;
                    p->Right = NULL;
                    if (j == len - 1)
                    {                //读到最后一个字符
                        p->flag = 1;//将在此停止的放置标记为1
                    }
                    else
                    {                //将路上遍历过的节点都设置成为0
                        p->flag = 0;
                    }
                }else
                {
                    if( (j==len-1)||(p->Right->flag) )//当前读取的字符串的最后一位或者有字符串在这里结束
                    {
                        printf("%s\n",str);
                        return 0;
                    }else
                    {
                        p=p->Right;
                    }
                }
            }
        }
    }
    printf("YES\n");
    return 0;
}

前缀码：任何一个字符的编码都不是同一字符集中另一个字符的编码的前缀。

请编写一个程序，判断输入的n个由1和0组成的编码是否为前缀码。如果这n个编码是前缀码，则输出"YES”；否则输出第一个与前面编码发生矛盾的编码。

输入：
第1行为n（表示下面有n行编码）
第2～n+1行为n个由0或1组成的编码

输出：判断结果

例如，如果输入：

5

00

01

10

110

111

每一个字符均不是其他字符编码的前缀，所以，输出：YES

再如，如果输入：

5

00

01

10

110

11

编码11与前面的编码110的前缀，所以，输出：11

根据你的代码，猜测一下意图，我重写了一个。
但对不对我不知道，我没地方去测试，因此仅供参考

#include <iostream>
#include <string>
using namespace std;

struct BiTCode {
    BiTCode* Left = nullptr;
    BiTCode* Right = nullptr;
};

int main( void )
{
    size_t n;
    cin >> n;

    string found;
    BiTCode head;
    for( size_t i=0; i!=n && found.empty(); ++i )
    {
        string s;
        cin >> s;

        bool bCreated = false;
        BiTCode* p = &head;
        for( char c : s )
        {
            if( i!=0 && !bCreated && p->Left==nullptr && p->Right==nullptr )
            {
                found = s;
                break;
            }

            if( c == '0' )
            {
                if( p->Left==nullptr )
                {
                    p->Left = new BiTCode;
                    bCreated = true;
                }
                p = p->Left;
            }
            else
            {
                if( p->Right==nullptr )
                {
                    p->Right = new BiTCode;
                    bCreated = true;
                }
                p = p->Right;
            }
        }

        if( !bCreated )
            found = s;
    }
    cout << (found.empty()?"YES":found) << endl;
}

十分感谢，我找到之前错误的原因了，是数组设置小了，改成10000就过了。。。