Создать собственный контейнер список

#include <iostream>
#include <ctype.h>
#include <algorithm>
#include <string.h>
 
 
using namespace std;
 
const unsigned int MAX_STR_LEN = 250000;
const unsigned short MONOGRAM = 1;
const unsigned short DIGRAM = 2;
const unsigned short TRIGRAM = 3;
 
char monograms[MAX_STR_LEN][MONOGRAM+1] = { 0 };
char digrams[MAX_STR_LEN][DIGRAM+1] = { 0 };
char trigrams[MAX_STR_LEN][TRIGRAM+1] = { 0 };
 
bool notTerminated(const char *ptr, const unsigned short GRAMS) {
    for (int i=0; i<GRAMS; i++) {
        if (ptr[i] == '\0') {
            return false;
        }
    }
    return true;
}
 
int strCmp( const void* a, const void* b)
{
    char const *char_a = *(char const **)a;
    char const *char_b = *(char const **)b;
    return strcmp(char_a, char_b);
}
 
struct FreqNode {
    const char* str;
    unsigned int freq;
    FreqNode *prev;
    FreqNode *next;
};
 
 
void unlink(FreqNode *node) {
    FreqNode *prev = node->prev;
    FreqNode *next = node->next;
    if (prev && prev->next) {
        prev->next = next;
    }
 
    if (next && next->prev) {
        next->prev = prev;
    }
 
    node->next = 0;
    node->prev= 0;
}
 
void insertAfter(FreqNode *insert, FreqNode *after) {
    FreqNode *origNext = after->next;
    after->next = insert;
    insert->prev = after;
    origNext->prev = insert;
    insert->next = origNext;
}
 
void insertFreqNode(FreqNode *orig, const char* ptr) {
    int freq = 0;
    FreqNode *head = orig;
    FreqNode *origHead = head;
    bool needInsert= true;
    while (head->next) {
        freq = origHead->next->freq;
        if (strcmp(head->next->str, ptr) == 0) {
            head->next->freq += 1;
            if (head->next->freq >= freq
                && origHead->next != head->next) {
                FreqNode *link = head->next;
                unlink(link);
                insertAfter(link, origHead);
            }
            needInsert = false;
            break;
        }
       head = head->next;
    }
    if (needInsert) {
        head->next = new FreqNode();
        head->next->prev = head;
        head->next->next = 0;
        head->next->str = ptr;
        head->next->freq = 1;
   }
}
 
void bubble_sort_list(FreqNode * list) {
    FreqNode * p = NULL;
    
    if (list != NULL) {
        while (list->next != NULL) {
            p = list->next;
            
            do {
                if (p->freq < list->freq) {
                    int tmp = p->freq;
                    p->freq = list->freq;
                    list->freq = tmp;
                }
                
                p = p->next;
            } while (p != NULL);
            
            list = list->next;
        }
    }
}
 
int showMonogram(char *str)
{
    const char *ptr = str;
    int idx = 0;
    while (notTerminated(ptr,MONOGRAM)) {
             for (int i=0; i<MONOGRAM; i++) {
                monograms[idx][i] = ptr[i];
            }
            monograms[idx][MONOGRAM] = '\0';
            idx++;
        
        ptr++;
    }
 
    FreqNode head = { "HEAD", 0, 0, 0 };
    for (int i=0; i<MAX_STR_LEN; i++) {
        if (monograms[i][0] == '\0') break;
        insertFreqNode(&head, monograms[i]);
    }
 
    FreqNode *headPtr = &head;
    int iter = 0;
    bubble_sort_list(headPtr);
    while (headPtr->next) {
        cout << headPtr->next->str << " \t" << headPtr->next->freq << endl;
        headPtr = headPtr->next;
    }
 
   return 0;
}
 
int showDigram(char *str)
{
    const char *ptr = str;
    int idx = 0;
    while (notTerminated(ptr, DIGRAM)) {
             for (int i=0; i<DIGRAM; i++) {
                digrams[idx][i] = ptr[i];
            }
            digrams[idx][DIGRAM] = '\0';
            idx++;
        
        ptr++;
    }
 
    FreqNode head = { "HEAD", 0, 0, 0 };
    for (int i=0; i<MAX_STR_LEN; i++) {
        if (digrams[i][0] == '\0') break;
        insertFreqNode(&head, digrams[i]);
    }
 
    FreqNode *headPtr = &head;
    int iter = 0;
    while (headPtr->next) {
        cout << headPtr->next->str << " \t" << headPtr->next->freq << endl;
        headPtr = headPtr->next;
    }
 
   return 0;
}
 
int showTrigram(char *str)
{ 
    const char *ptr = str;
    int idx = 0;
    while (notTerminated(ptr,TRIGRAM)) {
             for (int i=0; i<TRIGRAM; i++) {
                trigrams[idx][i] = ptr[i];
            }
            trigrams[idx][TRIGRAM] = '\0';
            idx++;
        
        ptr++;
    }
 
    FreqNode head = { "HEAD", 0, 0, 0 };
    for (int i=0; i<MAX_STR_LEN; i++) {
        if (trigrams[i][0] == '\0') break;
        insertFreqNode(&head, trigrams[i]);
    }
 
    FreqNode *headPtr = &head;
    int iter = 0;
    while (headPtr->next) {
        cout << headPtr->next->str << " \t" << headPtr->next->freq << endl;
        headPtr = headPtr->next;
    }
 
   return 0;
}
 
int main()
{
    FILE *fp;
    char str[MAX_STR_LEN];
    char *file = "C_C_VT00";
    fp = fopen( file, "r" );
    fgets( str, MAX_STR_LEN, fp );
   // getline(fp, str, '\0');
 
    showMonogram(str);
    showDigram(str);
    showTrigram(str);
    return 0;
}

#include <cstdlib>
#include <cstring>
struct node{
    int freq;
    char* str;
    node* next;
};
node* getNewList(){
    const int names_sz=5;
    const char* names[]={"igla", "kub", "buk", "strela", "shilka"};
    node* head=NULL;
    for (int i=0; i<names_sz; ++i)
    {
        node* new_it=new node;
        new_it->freq=rand()%91+9;
        new_it->str=new char[strlen(names[i])+1];
        strcpy(new_it->str, names[i]);
        new_it->next=head;
        head=new_it;
    }
    return head;
}
void removeList(node* head)
{
    while(head)
    {
        node* new_it=head;
        head=head->next;
        delete[] new_it->str;
        delete[] new_it;
    }
}
node* BubbleSort(node* head){
    bool unsorted=true;
    node fake;
    while(unsorted)
    {
        unsorted=false;
        node *pre=head, *cur=head->next, *prepre=&fake;
        prepre->next=head;
        while(cur)
        {
            if (pre->freq>cur->freq)
            {
                prepre->next=cur;
                pre->next=cur->next;
                cur->next=pre;
                unsorted=true;
                cur=pre->next;
                prepre=prepre->next;
 
            }
            else
            {
                cur=cur->next;
                prepre=prepre->next;
                pre=pre->next;
            }
        }
        head=fake.next;
    }
    return head;
}
int main()
{
    node* items=getNewList();
    items=BubbleSort(items);
    removeList(items);
    return 0;
}