fork download
copy 
  1. #include <iostream>
  2.  
  3. struct Snode
  4. {
  5.     char data;
  6.     int count;
  7.     Snode *previous = nullptr;
  8.     Snode *next = nullptr;
  9.     Snode(char a, int c) : data(a), count(c) {}
  10. };
  11.  
  12. class set
  13. {
  14. private:
  15.     Snode *head = nullptr;
  16.     Snode *tail = nullptr;
  17.  
  18.     void append(char value, int count)
  19.     {
  20.         Snode *temp = new Snode(value, count);
  21.  
  22.         if (!head)
  23.             head = temp;
  24.  
  25.         if (tail)
  26.         {
  27.             temp->previous = tail;
  28.             tail->next = temp;
  29.         }
  30.         tail = temp;
  31.     }
  32.  
  33.     void remove(Snode *node)
  34.     {
  35.         if (node->previous)
  36.             node->previous->next = node->next;
  37.  
  38.         if (node->next)
  39.             node->next->previous = node->previous;
  40.  
  41.         if (head == node)
  42.             head = node->next;
  43.  
  44.         if (tail == node)
  45.             tail = node->previous;
  46.  
  47.         delete node;
  48.     }
  49.  
  50.     void swap(set &other)
  51.     {
  52.         Snode *ptr = head;
  53.         head = other.head;
  54.         other.head = ptr;
  55.  
  56.         ptr = tail;
  57.         tail = other.tail;
  58.         other.tail = ptr;
  59.     }
  60.  
  61. public:
  62.     set() = default;
  63.  
  64.     set(const set &src)
  65.     {
  66.         Snode *temp = src.head;
  67.         while (temp)
  68.         {
  69.             append(temp->data, temp->count);
  70.             temp = temp->next;
  71.         }
  72.     }
  73.  
  74.     set(set &&src)
  75.     {
  76.         src.swap(*this);
  77.     }
  78.  
  79.     ~set()
  80.     {
  81.         Snode *temp = head;
  82.         while (temp)
  83.         {
  84.             Snode *next = temp->next;
  85.             delete temp;
  86.             temp = next;
  87.         }
  88.     }
  89.  
  90.     set& operator=(const set &rhs)
  91.     {
  92.         if (&rhs != this)
  93.         {
  94.             set temp(rhs);
  95.             temp.swap(*this);
  96.         }
  97.         return *this;
  98.     }
  99.  
  100.     set& operator=(set &&rhs)
  101.     {
  102.         rhs.swap(*this);
  103.         return *this;
  104.     }
  105.  
  106.     bool isAvailable(char value)
  107.     {
  108.         return (find(value) != nullptr);
  109.     }
  110.  
  111.     Snode* find(char value)
  112.     {
  113.         Snode *temp = head;    
  114.         while (temp)
  115.         {
  116.             if (temp->data == value)
  117.                 return temp;    
  118.             temp = temp->next;
  119.         }    
  120.         return nullptr;
  121.     }
  122.  
  123.     bool isFirst(char value)
  124.     {
  125.         return ((head) && (head->data == value));
  126.     }
  127.  
  128.     bool isLast(char value)
  129.     {
  130.         return ((tail) && (tail->data == value));
  131.     }
  132.  
  133.     void display()
  134.     {
  135.         Snode *temp = head;
  136.         while (temp)
  137.         {
  138.             std::cout << temp->data << " " << temp->count << std::endl;
  139.             temp = temp->next;
  140.         }
  141.     }
  142.  
  143.     void insert(char value)
  144.     {
  145.         Snode *temp = find(value);
  146.         if (temp)
  147.             temp->count += 1;
  148.         else
  149.             append(value, 1);
  150.     }
  151.  
  152.     int count(char value)
  153.     {
  154.         Snode *temp = find(value);
  155.         return (temp) ? temp->count : 0;
  156.     }
  157.  
  158.     void deleteFirst()
  159.     {
  160.         if (head)
  161.             remove(head);
  162.     }
  163.  
  164.     void deleteLast()
  165.     {
  166.         if (tail)
  167.             remove(tail);
  168.     }
  169.  
  170.     void remove(char value)
  171.     {
  172.         Snode *temp = find(value);
  173.         if (temp)
  174.         {
  175.             if (temp->count > 1)
  176.                 temp->count -= 1;
  177.             else
  178.                 remove(temp);
  179.         }
  180.     }   
  181. };
  182.  
  183. int main()
  184. {
  185.     //defining a mySet as a "set" type
  186.     set mySet;
  187.  
  188.     //adding values to create nodes
  189.     mySet.insert('c');
  190.     mySet.insert('a');
  191.     mySet.insert('a');
  192.     mySet.insert('c');
  193.     mySet.insert('c');
  194.  
  195.     set myCopiedSet = mySet; // make a copy of the list
  196.  
  197.     //adding more values to create nodes
  198.     myCopiedSet.insert('a');
  199.     myCopiedSet.insert('b');
  200.     myCopiedSet.insert('b');
  201.     myCopiedSet.insert('c');
  202.  
  203.     // another test
  204.     set myTestSet;
  205.     myTestSet.insert('c');
  206.     myTestSet.insert('c');
  207.     myTestSet.insert('j');
  208.     myTestSet.insert('j');
  209.     myTestSet.insert('j');
  210.     myTestSet.insert('r');
  211.  
  212.     //displaying nodes through "value count" format
  213.     std::cout << "original:" << std::endl;
  214.     mySet.display();    
  215.     std::cout << "copy:" << std::endl;
  216.     myCopiedSet.display();
  217.     std::cout << "test:" << std::endl;
  218.     myTestSet.display();
  219.  
  220.     return 0;
  221. }
Success #stdin #stdout 0s 4536KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
original:
c 3
a 2
copy:
c 4
a 3
b 2
test:
c 2
j 3
r 1
https://ideone.com/ebU9V3
language:
C++ (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!