Adding in a sorted bag C++ - c++

Question

I want to implement the sorted bag(collection) data structure(with a singly-linked list) in C++ and I have a problem when I want to test the add function. This is the test:
SortedBag sb(relation1); (relation1 is e1<=e2)
sb.add(5);
std::cout << sb.size()<<" ";
sb.add(6);
std::cout << sb.size() << " ";
sb.add(0);
std::cout << sb.size() << " ";
sb.add(5);
std::cout << sb.size() << " ";
sb.add(10);
std::cout << sb.size() << " ";
sb.add(8);
std::cout << sb.size() << " ";
And it will print 1 2 3 3 4 5 instead of 1 2 3 4 5 6.
This is the add function:
void SortedBag::add(TComp e) {
Node* auxiliarElement = new Node;
Node* CheckSLL = new Node;
int flagStop = 1;
if (this->head == nullptr)
{
auxiliarElement->value = e;
auxiliarElement->freq = 1;
auxiliarElement->next = nullptr;
this->head = auxiliarElement;
}
else {
CheckSLL = this->head;
while (CheckSLL->next != nullptr && rel(CheckSLL->value, e))
{
if (CheckSLL->value == e) {
CheckSLL->freq += 1;
flagStop = 0;
break;
}
CheckSLL = CheckSLL->next;
}
if (CheckSLL == this->head && flagStop)
{
auxiliarElement->value = e;
auxiliarElement->freq = 1;
auxiliarElement->next = this->head;
this->head = auxiliarElement;
flagStop = 0;
}
if (CheckSLL->value == e && flagStop)
{
CheckSLL->freq += 1;
flagStop = 0;
}
if (flagStop) {
auxiliarElement->value = e;
auxiliarElement->freq = 1;
auxiliarElement->next = nullptr;
CheckSLL->next = auxiliarElement;
}
}
}
The size() functions works fine, I will post that too:
int SortedBag::size() const {
int Size = 0;
Node* goThrough = new Node;
goThrough = this->head;
while (goThrough != nullptr) {
Size += goThrough->freq;
goThrough = goThrough->next;
}
return Size;
}
And I can't find out why it doesn't add the frequency from the second 5. Can somebody help me, please? (the struct Node has value,freq and a pointer to the next Node)

Answer 1

For starters these statements
Node* CheckSLL = new Node;
and
Node* goThrough = new Node;
result in memory leaks.
Also this output
And it will print 1 2 3 3 4 5.
does not correspond to the sequence of entered data because the function size counts the total value of frequencies
Size += goThrough->freq;
So as 6 elements were inserted in the list then the output should be
1 2 3 4 5 6
The relation should be specified like e1 < e2 not like e1 <= e2
The function add can be defined very simply. I assume that the relation corresponds to the operator <.
void SortedBag::add( TComp e )
{
Node **current = &this->head;
while ( *current != nullptr && rel( ( *current )->value, e ) )
{
current = &( *current )->next;
}
if ( *current == nullptr || rel( e, ( *current )->value ) )
{
Node *new_node = new Node;
new_node->value = e;
new_node->freq = 1;
new_node->next = *current;
*current = new_node;
}
else
{
++( *current )->freq;
}
}
And you should decide whether the function size returns frequencies or the number of nodes in the list.
Here is a demonstrative program.
#include <iostream>
#include <functional>
template <typename T, typename Comparison = std::less<T>>
class List
{
private:
struct Node
{
T value;
size_t freq;
Node *next;
} *head = nullptr;
Comparison cmp;
public:
explicit List() : cmp( Comparison() )
{
}
explicit List( Comparison cmp ) : cmp( cmp )
{
}
~List()
{
while ( this->head != nullptr )
{
Node *current = this->head;
this->head = this->head->next;
delete current;
}
}
List( const List & ) = delete;
List & operator =( const List & ) = delete;
void add( const T &value );
friend std::ostream & operator <<( std::ostream &os, const List &list )
{
for ( Node *current = list.head; current != nullptr; current = current->next )
{
os << current->value << ':' << current->freq << " -> ";
}
return os << "null";
}
};
template <typename T, typename Comparison>
void List<T, Comparison>::add( const T &value )
{
Node **current = &this->head;
while ( *current != nullptr && cmp( ( *current )->value, value ) )
{
current = &( *current )->next;
}
if ( *current == nullptr || cmp( value, ( *current )->value ) )
{
Node *new_node = new Node { value, 1, *current };
*current = new_node;
}
else
{
++( *current )->freq;
}
}
int main()
{
List<int> list;
list.add( 5 );
list.add( 6 );
list.add( 0 );
list.add( 5 );
list.add( 10 );
list.add( 8 );
std::cout << list << '\n';
return 0;
}
The program output is
0:1 -> 5:2 -> 6:1 -> 8:1 -> 10:1 -> null