Здравствуйте, Антон!

я сделал 2 класса, CNode - для одного узла с одним сиволом и указателем на следующий узел
CSentence - для содержания листа узлов и работы с ними

Основная функция main()
Логически законченные части алгоритма оформлены отдельными методами в классе CSentence и идут по очереди в main

Чтобы сильно не усложнять, я всё сделал в одной строке. Но при выводе учитываются символы превода строк и знаки пунктуации.
Учёт того, что нужно пропустить при разборе есть в условии:

т.е. тут не считаются частями слова: символ новой строки, двоеточие, запятая, точка, восклицательный и вопросительный знаки.

В функции main закомментирована зачитка из файла, вставлена зачитка из строки. Нужно закомментировать зачитку из строки, раскомментировать зачитку из файла и написать там своё имя файла

Проект сделан в MS Visual studio 6.0, как консольное приложение

Приложение:
//#include "stdafx.h"
#include <stdio.h>
#include <string.h>

#define NULL 0

//---------------------------------
// class CNode
//
// used to keep one character in
// our string in list

class CNode
{
char m_ch;
CNode *m_pNext;
public:
CNode(char c);
~CNode();
char Char(){return m_ch;}
CNode *Next() {return m_pNext;}
CNode *NextCreate(char c);
void NextSet(CNode *pNext) {m_pNext = pNext;}
void Convert(char cFrom, char cTo);
bool IsSpace() {return (strchr(" ", m_ch)!= NULL); }
};

CNode::CNode(char c)
{
m_ch = c;
m_pNext = NULL;
}
CNode::~CNode()
{
}

// create next Node for this Node and init it by c
CNode *CNode::NextCreate(char c)
{
return (m_pNext = new CNode(c));
}

// char checker and converter
void CNode::Convert(char cFrom, char cTo)
{
if(m_ch == cFrom)
m_ch = cTo;
}

//---------------------------------
// class CSentence
//
// used for sentence
// keep head of list of CNode
//
class CSentence
{
CNode *m_pHead;
public:
CSentence();
~CSentence();
void Clear();
bool IsEmpty() {return (m_pHead == NULL);}

void Create(char*pString);
void CreateFromFile(char* pFileName);

void StringAdd(char *pString);
void CharDel(CNode &pNodeDel, CNode *pStart = NULL);

void Process();

void Print();
};

CSentence::CSentence()
{
m_pHead = NULL;
}

CSentence::~CSentence()
{
Clear();
}

// make if empty
void CSentence::Clear()
{
CNode *pNode, *pNodeCur = m_pHead;
while(pNodeCur)
{
pNode = pNodeCur;
pNodeCur = pNode->Next();
delete pNode;
}
m_pHead = NULL;
}

// create Sentence from string
void CSentence::Create(char*pString)
{
if(!pString)
return;

Clear();

CNode *pNode = m_pHead = new CNode(*pString);
while(*(++pString))
pNode = pNode->NextCreate(*pString);
}

// create Sentence from file
void CSentence::CreateFromFile(char* pFileName)
{
char szLine[1024] = {0}; // one line in file
FILE *fptr = fopen(pFileName, "r");
if(fptr)
{
while(!feof(fptr)) // while not end of file
{
fgets(szLine, 1024, fptr); // get a line
StringAdd(szLine); // add that line
}
fclose(fptr);
}
}

// add string to current content of the Sentence
void CSentence::StringAdd(char* pString)
{
if(IsEmpty()) // if we have no context - create it
{
Create(pString);
}
else // else find a tail and concatenate
{
CNode *pNode = m_pHead; // begin from head

while(pNode->Next()) // find a tail
pNode = pNode->Next();

while(*pString) // add char by char
pNode = pNode->NextCreate(*pString++);
}
}

void CSentence::CharDel(CNode &pNodeDel, CNode *pStart)// = NULL
{
if(&pNodeDel == m_pHead) // if we delete a head Node:
{
CNode *pNode = m_pHead->Next();
delete m_pHead;
m_pHead = pNode;
return;
}

// else we find previous node and remove it
//
//1. ?-> pNode -> pNext
//2. pPrev-> pNode -> pNext
//3. pPrev X pNext
//4. pPrev -> pNext

CNode *pNode = pStart;
if(!pNode)
pNode = m_pHead;

// 1 & 2
while(pNode && (pNode->Next() != &pNodeDel))
pNode = pNode->Next();


if(pNode)
{
// 4.
pNode->NextSet(pNodeDel.Next());
// 3.
delete &pNodeDel;
}
}

void CSentence::Process()
{
if(IsEmpty())
return;

CNode *pNode = m_pHead;
pNode->Convert('\t', ' '); // check it's tab

CNode *pNodePrev = NULL;
CNode *pNodeNext = pNode->Next();
if(pNodeNext == NULL)
return; // nothing to process

while(pNodeNext)
{
if(strchr("\n:,.!?", pNodeNext->Char())) // if it's newline character or comma or smth like it...
{
pNode = pNode->Next(); // jump
if(!pNode)
break;
pNode = pNode->Next(); // jump
if(!pNode)
break;
pNodeNext = pNode->Next();
continue;
}

pNodeNext->Convert('\t', ' '); // check it's tab

// both are Spaces
if(pNode->IsSpace() && pNodeNext->IsSpace())
{
CharDel(*pNodeNext, pNode); // remove next
pNodeNext = pNode->Next(); // go to next Node
continue;
}

// both are not Spaces
if(!pNode->IsSpace() && !pNodeNext->IsSpace())
{
pNodeNext = pNode->Next(); // look for own Next
CharDel(*pNode, pNodePrev); // remove current
pNode = pNodeNext; // now current is his own Next
pNodeNext = pNode->Next(); // go to next Node
continue;
}
// edge
pNodePrev = pNode; // remember start pos for searching (see CharDel)
pNode = pNode->Next(); // jump to next position
pNodeNext = pNode->Next(); // jump to next position
}
}

// pring string char by char
void CSentence::Print()
{
CNode *pNode = m_pHead;
while(pNode)
{
printf("%c", pNode->Char());
pNode = pNode->Next();
}
}

//---------------------------------
int main(int argc, char* argv[])
{
CSentence Sntc;

// Load a string
Sntc.Create("Hello, world \t and you: all!");
//Sntc.CreateFromFile("c:\\info.txt");

// show, what we got
Sntc.Print();
printf("\n---\n"); // text divider

// process the string
Sntc.Process();

// show what we have now
Sntc.Print();

return 0;
}