SHARE
TWEET

Untitled

a guest Jan 11th, 2019 67 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include<cassert>
  2.  
  3. template <class T> class LinkIterator;
  4. template <class T> class LinkList;
  5.  
  6. template <class T>
  7. class LinkNode
  8. {
  9.     friend class LinkIterator<T>;
  10.     friend class LinkList<T>;
  11.  
  12.  
  13.  
  14. public://
  15.     //class member initilization list
  16.     LinkNode() : m_next(0), m_previous(0)
  17.     {
  18.  
  19.     }
  20.  
  21.     T m_data;
  22.     LinkNode *m_next;
  23.     LinkNode *m_previous;
  24. };
  25.  
  26. template <class T>
  27. class LinkIterator
  28. {
  29. public://
  30.     LinkNode<T> *m_node;
  31.  
  32. public:
  33.     LinkIterator()
  34.     {
  35.         m_node = NULL;
  36.     }
  37.  
  38.     ~LinkIterator()
  39.     {
  40.  
  41.     }
  42.  
  43.     void operator= (LinkNode<T> *node)
  44.     {
  45.         m_node = node;
  46.     }
  47.  
  48.     T &operator*()
  49.     {
  50.         assert(m_node != NULL);
  51.         return m_node->m_data;
  52.     }
  53.  
  54.     void operator++()
  55.     {
  56.         assert (m_node !=NULL);
  57.         m_node = m_node->m_next;
  58.     }
  59.     void operator++(int)
  60.     {
  61.         assert(m_node !=NULL);
  62.         m_node = m_node->m_next;
  63.     }
  64.  
  65.     void operator--()
  66.     {
  67.         assert(m_node != NULL);
  68.         m_node = m_node->m_previous;
  69.     }
  70.  
  71.     void operator--(int)
  72.     {
  73.         assert(m_node != NULL);
  74.         m_node = m_node->m_previous;
  75.     }
  76.  
  77.     bool operator != (LinkNode<T> *node)
  78.     {
  79.         return(m_node != node);
  80.     }
  81.     bool operator == (LinkNode<T> *node)
  82.     {
  83.         return (m_node == node);
  84.     }
  85. };
  86.  
  87. template<class T>
  88. class LinkList
  89. {
  90. private:
  91.     int m_size;
  92.  
  93.     LinkNode<T> *m_root;
  94.     LinkNode<T> *m_lastNode;
  95.  
  96. public:
  97.     int counter;
  98.     LinkList()
  99.         :m_size(0), m_root(NULL), m_lastNode(NULL)
  100.     {
  101.     }
  102.     ~LinkList()
  103.     {
  104.         while (m_root)
  105.         {
  106.             Pop();
  107.         }
  108.     }
  109.  
  110.     LinkNode<T> *Begin()
  111.     {
  112.         assert (m_root !=NULL);
  113.         return m_root;
  114.     }
  115.     LinkNode<T> *End()
  116.     {
  117.         return NULL;
  118.     }
  119.     LinkNode<T> *Last()
  120.     {
  121.         return m_lastNode;
  122.     }
  123.     int GetSize()
  124.     {
  125.         return m_size;
  126.     }
  127.  
  128.     void Push(T newData, LinkIterator<T> position)
  129.     {
  130.         LinkNode<T> *node = new LinkNode<T>;
  131.  
  132.         //LinkList<int> lList;
  133.  
  134.         assert (node != NULL);
  135.  
  136.         node -> m_data = newData;
  137.         node ->m_next = NULL;
  138.         node->m_previous = NULL;
  139.  
  140.         //position = lList.Begin();
  141.  
  142.         if(position.m_node->m_previous == NULL)                 // First and last nodes checked
  143.         {
  144.             Push_Front(newData);
  145.         }else if(position.m_node == m_lastNode)
  146.         {
  147.             Push(newData);
  148.         }else
  149.         {
  150.             node->m_next = position.m_node;
  151.             node ->m_previous = position.m_node->m_previous;
  152.             position.m_node ->m_previous = node;
  153.  
  154.             position--;
  155.             position--;
  156.             position.m_node->m_next = node;
  157.         }
  158.        
  159.        
  160.  
  161.         //m_lastNode = node;
  162.  
  163.         m_size++;
  164.     }
  165.  
  166.     void Push(T newData)        //old
  167.     {
  168.         LinkNode<T> *node = new LinkNode<T>;
  169.  
  170.  
  171.         assert (node != NULL);
  172.  
  173.         node -> m_data = newData;
  174.         node ->m_next = NULL;
  175.         node->m_previous = NULL;
  176.  
  177.         if ( m_lastNode != NULL)
  178.         {
  179.             m_lastNode ->m_next = node;
  180.             node->m_previous = m_lastNode;
  181.         }
  182.         else
  183.         {
  184.             m_root = node;
  185.         }
  186.        
  187.         m_lastNode = node;
  188.  
  189.         m_size++;
  190.     }
  191.  
  192.  
  193.     void Push_Front( T newData)
  194.     {
  195.         LinkNode<T> *node = new LinkNode<T>;
  196.  
  197.         assert (node != NULL);
  198.  
  199.         node ->m_data = newData;
  200.         node ->m_next = NULL;
  201.         node ->m_previous = node;
  202.  
  203.         if (m_root !=NULL)
  204.         {
  205.             node ->m_next = m_root;
  206.             m_root->m_previous = node;
  207.             m_root = node;
  208.         }
  209.         else
  210.         {
  211.             m_root = node;
  212.             m_lastNode = node;
  213.         }
  214.         m_size++;
  215.     }
  216.  
  217.     void Pop()
  218.     {
  219.         assert (m_root != NULL);
  220.  
  221.         if (m_root ->m_next ==NULL)
  222.         {
  223.             delete m_root;
  224.             m_root = NULL;
  225.         }
  226.         else
  227.         {
  228.             LinkNode<T> *prevNode = m_lastNode->m_previous;
  229.  
  230.             prevNode->m_next = NULL;
  231.             delete m_lastNode;
  232.             prevNode ->m_next=NULL;
  233.             m_lastNode=prevNode;
  234.         }
  235.         m_size = (m_size = 0 ? m_size:m_size-1);
  236.     }
  237.  
  238.         void Pop( LinkIterator<T> position)                                         //NEW
  239.     {
  240.         assert (m_root != NULL);
  241.  
  242.         if (position.m_node->m_previous == NULL)
  243.         {
  244.             delete m_root;
  245.             m_root = NULL;
  246.         }
  247.         else
  248.         {
  249.             LinkNode<T> *prevNode = m_lastNode->m_previous;
  250.  
  251.             prevNode->m_next = NULL;
  252.             delete m_lastNode;
  253.             prevNode ->m_next=NULL;
  254.             m_lastNode=prevNode;
  255.         }
  256.         m_size = (m_size = 0 ? m_size:m_size-1);
  257.     }
  258.  
  259.     void Pop_Front()
  260.     {
  261.         assert (m_root !=NULL);
  262.  
  263.         LinkNode <T> *temp = m_root;
  264.  
  265.         m_root = m_root -> m_next;
  266.  
  267.         if(m_root != NULL)
  268.         {
  269.             m_root->m_previous = NULL;
  270.         }
  271.  
  272.         delete temp;
  273.         m_size = (m_size = 0 ? m_size : m_size-1);
  274.     }
  275. };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top