Таблица перекрестных ссылок на основе использования динамических списков и деревьев

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <sstream> 
#include <map> 
#include <set> 
 
using namespace std;
 
struct list
{list *next;
int nomstr;};
typedef list*lptr;
 
struct tree
{char slovo[20];
list str;
tree *left,*right;};
typedef tree*tptr;
 
tptr dob(tptr p,char c[20]);
tptr poisk(tptr p,char c[20]);
void print(tptr p,int h);
void check(char b[10]);
 
main()
{char b[10]; tptr e,p;
cout<<"vvedite imia faila:\n";
cin>>b;
//p=dob(e,c);}
check(b);
print(p,5);
//cout<<c;
//scan(c);
//show(e);
getch();}
 
tptr dob(tptr p,char c[20])
{if(p==NULL)
{p=new tree;
strcpy(p->slovo,c);
p->left=p->right=NULL; return p;}
if(strcmp(c,p->slovo)<0)p->left=dob(p->left,c);
else p->right=dob(p->right,c);return p;}
 
tptr poisk(tptr p,char c[20])
//{if(p==NULL||(strcmp(c,p->slovo)==0))
{if(p==NULL)
dob(p,c);
if(strcmp(c,p->slovo)==0)
{p->str.nomstr=1;}
if(strcmp(c,p->slovo)<0)return(poisk(p->left,c));
else return(poisk(p->right,c));}
 
void print(tptr p,int h)
{if(!p)return;
print(p->right,h+5);
cout<<setw(h)<<p<<p->slovo<<endl;
print(p->left,h+5);}
 
void check(char b[10])
{ifstream f(b); ofstream f1("2.txt");
int a,i=0,n=0;
char pchars[] = ".',?!:@#$%^(&*)_+=-;№{}/\[]|",s[5000];
while(f)
{f.get(s[i]);i++;n++;}
for(i=0;i<n;i++)
if(strchr(pchars,s[i])!= NULL)
{s[i]=' ';}
for(i=0;i<n;i++)
{f1.put(s[i]);}
f.close();f1.close();
string u, w; tptr p;
map<string, set<int> > t; 
ifstream ifs("2.txt"); 
for (int n = 1; getline(ifs, u); ++n) { 
for (istringstream iss(u); iss >> w; ) t[w].insert(n);} 
for (map<string, set<int> >::iterator mit = t.begin(); mit != t.end(); ++mit) { 
//dob(p,mit->first);
cout << left << setw(10) << mit->first << right; 
for (set<int>::iterator sit=mit->second.begin(); sit != mit->second.end(); ++sit) { 
cout << setw(3) << *sit;} 
cout << endl;} }//return p;} 
 
 
/*s[i]="\0";
 
void scan(char b[])
{ifstream f("b");string a;
//lptr c=new list; c->next=NULL;
while (f)
{f>>a;cout<<a<<"\t";}f.close();}*/

//Составить таблицу перекрестных ссылок. Программа читает текст
//и собирает все слова этого текста в дерево поиска, запоминая
//номера строк, в которых встречалось данное слово. После того,
//как просмотр будет окончен, формируется таблица, в которой все
//слова расположены в алфавитном порядке и со списками их
//местонахождения. Каждая вершина дерева не только содержит
//в качестве ключа само слово, но и является началом списка
//номеров строк, в которых это слово встречалось в тексте.
//Имя текстового файла запрашивается у пользователя с клавиатуры.
///////////////////////////////////////////////////////////////////////////////
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
struct  T_word_node;
///////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef T_str                   T_word;
typedef T_word_node         *   T_word_node_ptr;
typedef T_word_node_ptr         T_list;
typedef T_word_node_ptr         T_tree;
typedef std::ifstream           T_ifile;
///////////////////////////////////////////////////////////////////////////////
struct  T_word_node
{
    //-------------------------------------------------------------------------
    int     line_ind_;
    T_word  word_;
    T_tree  tree_prev_  =   nullptr;
    T_tree  tree_next_  =   nullptr;
    T_list  list_       =   nullptr;
    //-------------------------------------------------------------------------
    T_word_node
        (
            int                 line_ind,
            T_word  const   &   word    =   {}
        )
        :
        line_ind_   ( line_ind  ),
        word_       ( word      )
    {}
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
void    add_line_ind_to_list
    (
        int         line_ind,
        T_list  &   list
    )
{
    if( !list )
    {
        list    =   new     T_word_node( line_ind );
    }
    else if (
                    line_ind
                !=  list->line_ind_
            )
    {
        add_line_ind_to_list
            (
                line_ind,
                list->list_
            );
    }//else
}
///////////////////////////////////////////////////////////////////////////////
void    add_word_data_to_tree
    (
        int                 line_ind,
        T_word  const   &   word,
        T_tree          &   words_tree
    )
{
    if( !words_tree )
    {
        words_tree  =   new     T_word_node
                                    (
                                        line_ind,
                                        word
                                    );
    }
    else if (
                    word
                ==  words_tree->word_
            )
    {
        add_line_ind_to_list
            (
                line_ind,
                words_tree
            );
    }
    else if (
                    word
                <   words_tree->word_
            )
    {
        add_word_data_to_tree
            (
                line_ind,
                word,
                words_tree->tree_prev_
            );
    }
    else
    {
        add_word_data_to_tree
            (
                line_ind,
                word,
                words_tree->tree_next_
            );
    }//else
}
///////////////////////////////////////////////////////////////////////////////
void    make_word_links
    (
        T_ifile     &   text_file,
        T_tree      &   words_tree
    )
{
    int     line_ind{};
    T_str   line;
 
    while   (
                getline (
                            text_file,
                            line
                        )
            )
    {
        ++line_ind;
 
        std::istringstream  line_istr( line );
 
        T_word  word_cur;
 
        while   (
                    line_istr   >>  word_cur
                )
        {
            add_word_data_to_tree
                (
                    line_ind,
                    word_cur,
                    words_tree
                );
        }
    }//while
}
///////////////////////////////////////////////////////////////////////////////
void    print_word_links( T_tree    words_tree )
{
    if( words_tree )
    {
        print_word_links( words_tree->tree_prev_ );
 
        std::cout   <<  words_tree->word_
                    <<  "\t{"
                    <<  words_tree->line_ind_;
 
        auto    list_cur    =   words_tree->list_;
 
        while( list_cur )
        {
            std::cout   <<  ", "
                        <<  list_cur->line_ind_;
            list_cur    =   list_cur->list_;
        }//while
 
        std::cout   <<  "}"
                    <<  std::endl;
 
        print_word_links( words_tree->tree_next_ );
    }//if
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::cout   <<  "Enter file name: ";
    T_str       filename;
    std::cin    >>  filename;
 
    T_ifile     text_file( filename );
 
    if( !text_file )
    {
        std::cout   <<  "Bad filename!"
                    <<  std::endl;
 
        exit(1);
    }//if
 
    T_tree  words_tree{ nullptr };
 
    make_word_links
        (
            text_file,
            words_tree
        );
 
    print_word_links( words_tree );
}