fork download
copy 
  1. #include <bits/stdc++.h>
  2. using  namespace std;
  3.  
  4. template <typename T>
  5. struct Node{
  6.     T info;
  7.     Node *link;
  8. };
  9.  
  10. template<typename T>
  11. class single_LinkedList{
  12. private:
  13.     Node<T>* head;
  14.     int list_size ;
  15. public:
  16.     single_LinkedList(){
  17.         assert(head);
  18.         head = nullptr;
  19.         list_size = 0;
  20.     }
  21.     void insertAtHead(int value){
  22.         Node<T>* newNode;
  23.         assert(newNode);
  24.         newNode = new Node<T>;
  25.         newNode->info = value;
  26.         ///
  27.         newNode->link = head;
  28.         head = newNode;
  29.         list_size++;
  30.     }
  31.     void insertAtTail(int value){
  32.         Node<T>* newNode = new Node<T>;
  33.         assert(newNode);
  34.         newNode = new Node<T>;
  35.         newNode->info = value;
  36.         newNode->link = nullptr;
  37.         /// Make head point to the newNode element
  38.         if(head == nullptr){
  39.             head= newNode;
  40.         } else{
  41.             Node<T> *current ;
  42.             current = new Node<T>;
  43.             assert(current);
  44.             current = head;
  45.             while (current->link != nullptr){
  46.                 current = current->link;
  47.             }
  48.             current->link = newNode;
  49.         }
  50.         list_size++;
  51.     }
  52.     void insertAt(T value , int index){
  53.         try {
  54.             if (index >= list_size || index < 0) {
  55.                 throw std::runtime_error("Index out of bounds\n");
  56.             }
  57.         } catch (const std::runtime_error& e) {
  58.             std::cerr << "Exception caught: " << e.what() << std::endl;
  59.         }
  60.         if(index==0){
  61.             insertAtHead(value);
  62.         } else if(index == list_size - 1){
  63.             insertAtTail(value);
  64.         } else {
  65.             Node<T> *CurrentNode = new Node<T>;
  66.             assert(CurrentNode);
  67.             Node<T>*NewNode = new Node<T>;
  68.             assert(NewNode);
  69.             Node<T> *PrevNode = new Node<T>;
  70.             assert(PrevNode);
  71.             PrevNode->link = nullptr;
  72.             NewNode->info = value;
  73.             int current_index = 0;
  74.             CurrentNode = head;
  75.             while (current_index != index){
  76.                 PrevNode = CurrentNode;
  77.                 CurrentNode = CurrentNode->link;
  78.                 current_index++;
  79.             }
  80.             PrevNode->link = NewNode;
  81.             NewNode->link = CurrentNode;
  82.         }
  83.         list_size++;
  84.     }
  85.     void removeAtTail(){
  86.         try {
  87.             if (isEmpty()) {
  88.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  89.             }
  90.         } catch (const std::runtime_error& e) {
  91.             std::cerr << "Exception caught: " << e.what() << std::endl;
  92.         }
  93.         Node<T> *to_delete ;
  94.         to_delete = new Node<T>;
  95.         assert(to_delete);
  96.         to_delete = head;
  97.         while (to_delete->link != nullptr){
  98.             to_delete = to_delete->link;
  99.         }
  100.         Node<T>* before_delete;
  101.         before_delete = new Node<T>;
  102.         assert(before_delete);
  103.         before_delete = head;
  104.         while (before_delete->link != to_delete){
  105.             before_delete = before_delete->link;
  106.         }
  107.         delete to_delete;
  108.         before_delete->link = nullptr;
  109.         list_size--;
  110.     }
  111.     void removeAtHead(){
  112.         try {
  113.             if (isEmpty()) {
  114.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  115.             }
  116.         } catch (const std::runtime_error& e) {
  117.             std::cerr << "Exception caught: " << e.what() << std::endl;
  118.         }
  119.         Node<T>*PointToHeadLink = new Node<T>;
  120.         assert(PointToHeadLink);
  121.         PointToHeadLink = head;
  122.         head = head->link;
  123.         delete PointToHeadLink;
  124.         list_size--;
  125.     }
  126.     void removeAt(int index){
  127.         try {
  128.             if (isEmpty()) {
  129.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  130.             }
  131.         } catch (const std::runtime_error& e) {
  132.             std::cerr << "Exception caught: " << e.what() << std::endl;
  133.         }
  134.         try{
  135.             if(index < 0 || index >= list_size ){
  136.                 throw std::runtime_error("Index out of bound :(.");
  137.             }
  138.         }catch (const std::runtime_error &e) {
  139.             cerr << "Exception caught " << e.what() << '\n';
  140.         }
  141.         Node<int>* current_node = head;
  142.         assert(current_node);
  143.         Node<int>* previous_current = new Node<int>;
  144.         assert(current_node);
  145.         previous_current->link = nullptr;
  146.         int current_index = -1;
  147.         while (current_index < index-1){
  148.             previous_current = current_node;
  149.             current_node = current_node->link;
  150.             current_index++;
  151.         }
  152.         if(previous_current->link == nullptr){
  153.             head = head->link;
  154.             delete current_node;
  155.         } else if(current_node->link == nullptr){
  156.             previous_current->link = nullptr;
  157.             delete current_node;
  158.  
  159.         }
  160.         else {
  161.             previous_current->link = current_node->link;
  162.             delete current_node ;
  163.         }
  164.         list_size--;
  165.     }
  166.     T retrieveAt(int index)const{
  167.         try{
  168.             if(index < 0 || index >= list_size){
  169.                 throw std::runtime_error("Index out of bound :(.");
  170.             }
  171.         }catch (const std::runtime_error &e) {
  172.             cerr << "Exception caught " << e.what() << '\n';
  173.         }
  174.         Node<int>* current_node = head;
  175.         assert(current_node);
  176.         Node<int>* previous_current = new Node<int>;
  177.         assert(previous_current);
  178.         previous_current->link = nullptr;
  179.         int current_index = -1;
  180.         while (current_index < index-1){
  181.             previous_current = current_node;
  182.             current_node = current_node->link;
  183.             current_index++;
  184.         }
  185.         if(previous_current->link == nullptr){
  186.             return head->info;
  187.         } else {
  188.             return current_node->info;
  189.         }
  190.     }
  191.     void replaceAt( T value ,  int index ){
  192.         try{
  193.             if(index < 0 || index >= list_size){
  194.                 throw std::runtime_error("Index out of bound :(.");
  195.             }
  196.         }catch (const std::runtime_error &e) {
  197.             cerr << "Exception caught " << e.what() << '\n';
  198.         }
  199.         Node<int>* current_node = head;
  200.         assert(current_node);
  201.         Node<int>* previous_current = new Node<int>;
  202.         assert(previous_current);
  203.         previous_current->link = nullptr;
  204.         int current_index = -1;
  205.         while (current_index < index-1){
  206.             previous_current = current_node;
  207.             current_node = current_node->link;
  208.             current_index++;
  209.         }
  210.         if(previous_current->link == nullptr){
  211.             head->info = value;
  212.         } else {
  213.             current_node->info = value;
  214.         }
  215.     }
  216.     bool is_itemAt_equal( T value ,  int index )const{
  217.         try{
  218.             if(index < 0 || index >= list_size){
  219.                 throw std::runtime_error("Index out of bound :(.");
  220.             }
  221.         }catch (const std::runtime_error &e) {
  222.             cerr << "Exception caught " << e.what() << '\n';
  223.         }
  224.         Node<int>* current_node = head;
  225.         assert(current_node);
  226.         Node<int>* previous_current = new Node<int>;
  227.         assert(previous_current);
  228.         previous_current->link = nullptr;
  229.         int current_index = -1;
  230.         while (current_index < index-1){
  231.             previous_current = current_node;
  232.             current_node = current_node->link;
  233.             current_index++;
  234.         }
  235.         if(previous_current->link == nullptr){
  236.             return head->info == value;
  237.         } else {
  238.             return current_node->info == value;
  239.         }
  240.     }
  241.     void swap(int first_index , int second_index){
  242.         try{
  243.             if(first_index < 0 || first_index >= list_size || second_index < 0 || second_index >= list_size){
  244.                 throw std::runtime_error("Index out of bound :(.");
  245.             }
  246.         }catch (const std::runtime_error &e) {
  247.             cerr << "Exception caught " << e.what() << '\n';
  248.         }
  249.         if(first_index == second_index)
  250.             return;
  251.         int mx = max(first_index , second_index);
  252.         int mn = min(first_index , second_index);
  253.         first_index = mn;
  254.         second_index = mx;
  255.         Node<T>*first_node = new Node<T>;
  256.         Node<T>*before_first_node = new Node<T>;
  257.         before_first_node->link = nullptr;
  258.  
  259.         Node<T>*second_node = new Node<T>;
  260.         Node<T>*before_second_node = new Node<T>;
  261.         before_second_node->link = nullptr;
  262.  
  263.         first_node = head;
  264.         int cnt = 0;
  265.         while (cnt < first_index){
  266.             before_first_node = first_node;
  267.             first_node = first_node->link;
  268.             cnt++;
  269.         }
  270.  
  271.         second_node = head;
  272.         cnt = 0;
  273.         while (cnt < second_index){
  274.             before_second_node = second_node;
  275.             second_node = second_node->link;
  276.             cnt++;
  277.         }
  278.         Node<T>*temp2 = new Node<T>;
  279.         Node<T>*temp1 = new Node<T>;
  280.         if(second_index-first_index == 1){
  281.             if (first_node == head) {
  282.                 Node<T> *cur = head;
  283.                 while (cur->link != head) {
  284.                     cur = cur->link;
  285.                 }
  286.                 temp2 = second_node->link;
  287.                 temp1 = first_node;
  288.                 head = second_node;
  289.                 head->link = temp1;
  290.                 temp1->link = temp2;
  291.                 cur->link = head;
  292.             } else if (second_node == head) {
  293.                 temp2 = before_first_node;
  294.                 temp1 = second_node;
  295.                 second_node = first_node;
  296.                 first_node = temp1;
  297.                 temp2->link = first_node;
  298.                 first_node->link = second_node;
  299.             } else {
  300.                 temp2 = second_node->link;
  301.                 first_node->link = temp2;
  302.                 before_first_node->link = second_node;
  303.                 second_node->link = first_node;
  304.             }
  305.         } else{
  306.             if (first_node == head) {
  307.                 // 7 6 5 1 2 3
  308.                 Node<T>*after_first = first_node->link;
  309.                 Node<T>*after_second = second_node->link;
  310.  
  311.                 temp2 = first_node;
  312.                 head = second_node;
  313.                 head->link = after_first;
  314.                 before_second_node->link = temp2;
  315.                 temp2->link = after_second;
  316.  
  317.             } else if (second_node == head) {
  318.                 temp2 = before_first_node;
  319.                 temp1 = second_node;
  320.                 second_node = first_node;
  321.                 first_node = temp1;
  322.                 temp2->link = first_node;
  323.                 first_node->link = second_node;
  324.             } else {
  325.                 temp2 = second_node->link;
  326.                 first_node->link = temp2;
  327.                 before_first_node->link = second_node;
  328.                 second_node->link = first_node;
  329.             }
  330.         }
  331.     }
  332.     T size()const{
  333.         return list_size;
  334.     }
  335.     void print()const{
  336.         try {
  337.             if (isEmpty()) {
  338.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  339.             }
  340.         } catch (const std::runtime_error& e) {
  341.             std::cerr << "Exception caught: " << e.what() << std::endl;
  342.         }
  343.         Node<T>* current = head;
  344.         assert(current);
  345.         for(int i = 0 ; i < list_size ; i++){
  346.             cout << current->info << ' ';
  347.             current = current->link;
  348.         }
  349.         cout << '\n';
  350.     }
  351.     bool isEmpty()const{
  352.         return (head == nullptr);
  353.     }
  354.     void clear() {
  355.         if (head != nullptr) {
  356.             Node<T> *current = new Node<T>;
  357.             assert(current);
  358.             current = head;
  359.  
  360.             int t = 0;
  361.             while (t < list_size) {
  362.                 Node<T> *temp = new Node<T>;
  363.                 temp = current;
  364.                 current = current->link;
  365.                 delete temp;
  366.                 t++;
  367.             }
  368.             head = nullptr;
  369.             list_size = 0;
  370.         }
  371.     }
  372.     ~single_LinkedList(){
  373.         if(head != nullptr) {
  374.             Node<T> *current = new Node<T>;
  375.             assert(current);
  376.             current = head;
  377.             while (current->link != nullptr) {
  378.                 Node<T> *temp = new Node<T>;
  379.                 assert(temp);
  380.                 temp = current;
  381.                 current = current->link;
  382.                 delete temp;
  383.             }
  384.             head = nullptr;
  385.         }
  386.     }
  387. };
  388.  
  389. template<typename T>
  390. class  circular_LinkedList{
  391. private:
  392.     Node<T>*head;
  393.     int list_size = 0;
  394. public:
  395.     circular_LinkedList(){
  396.         head = new Node<T>;
  397.         assert(head);
  398.         head = nullptr;
  399.         list_size = 0;
  400.     }
  401.     void insertAtHead(int value){
  402.         Node<T>* newNode = new Node<T>;
  403.         assert(newNode);
  404.         newNode->info = value;
  405.         newNode->link = nullptr;
  406.         if(head == nullptr){
  407.             head = newNode;
  408.             head->link = head;
  409.         } else{
  410.             Node<T>*temp = new Node<T>;
  411.             temp = head;
  412.             newNode->link = head;
  413.             head = newNode;
  414.             Node<T>*current = head;
  415.             do{
  416.                 current = current->link;
  417.             } while (temp != current->link);
  418.             current->link = head;
  419.         }
  420.         list_size++;
  421.     }
  422.     void insertAtTail(int value){
  423.         Node<T>* newNode = new Node<T>;
  424.         assert(newNode);
  425.         newNode = new Node<T>;
  426.         newNode->info = value;
  427.         newNode->link = nullptr;
  428.         /// Make head point to the newNode element
  429.         if(head == nullptr){
  430.             head = newNode;
  431.         } else{
  432.             Node<T> *current ;
  433.             current = new Node<T>;
  434.             assert(current);
  435.             current = head;
  436.             while (current->link != head){
  437.                 current = current->link;
  438.             }
  439.             current->link = newNode;
  440.             newNode->link = head;
  441.         }
  442.         list_size++;
  443.     }
  444.     void insertAt(T value , int index){
  445.         try {
  446.             if (index >= list_size || index < 0) {
  447.                 throw std::runtime_error("Index out of bounds\n");
  448.             }
  449.         } catch (const std::runtime_error& e) {
  450.             std::cerr << "Exception caught: " << e.what() << std::endl;
  451.         }
  452.         if(index==0){
  453.             insertAtHead(value);
  454.         } else if(index == list_size - 1){
  455.             insertAtTail(value);
  456.         } else {
  457.             Node<T> *CurrentNode = new Node<T>;
  458.             assert(CurrentNode);
  459.             Node<T>*NewNode = new Node<T>;
  460.             assert(NewNode);
  461.             Node<T> *PrevNode = new Node<T>;
  462.             assert(PrevNode);
  463.             PrevNode->link = head;
  464.             NewNode->info = value;
  465.             int current_index = 0;
  466.             CurrentNode = head;
  467.             while (current_index != index){
  468.                 PrevNode = CurrentNode;
  469.                 CurrentNode = CurrentNode->link;
  470.                 current_index++;
  471.             }
  472.             NewNode->link = CurrentNode;
  473.             PrevNode->link = NewNode;
  474.             list_size++;
  475.         }
  476.     }
  477.     void removeAtTail(){
  478.         try {
  479.             if (isEmpty()) {
  480.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  481.             }
  482.         } catch (const std::runtime_error& e) {
  483.             std::cerr << "Exception caught: " << e.what() << std::endl;
  484.         }
  485.         Node<T> *to_delete , *previous_delete = new Node<T>;
  486.         to_delete = new Node<T>;
  487.         assert(to_delete);
  488.         previous_delete->link = head;
  489.         to_delete = head;
  490.         while (to_delete->link != head){
  491.             previous_delete = to_delete;
  492.             to_delete = to_delete->link;
  493.         }
  494.         if(to_delete == head){
  495.             head = nullptr;
  496.             delete to_delete;
  497.         } else{
  498.             previous_delete->link = head;
  499.             delete to_delete;
  500.         }
  501.         list_size--;
  502.     }
  503.     void removeAtHead(){
  504.         try {
  505.             if (isEmpty()) {
  506.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  507.             }
  508.         } catch (const std::runtime_error& e) {
  509.             std::cerr << "Exception caught: " << e.what() << std::endl;
  510.         }
  511.         Node<T>*temp = head;
  512.         if(temp->link == nullptr){
  513.             delete temp;
  514.             head = nullptr;
  515.         } else{
  516.             head = head->link;
  517.             Node<T>*current = head;
  518.             while (current->link != temp){
  519.                 current = current->link;
  520.             }
  521.             current->link = head;
  522.             delete temp;
  523.         }
  524.         list_size--;
  525.     }
  526.     void removeAt(int index){
  527.         try {
  528.             if (isEmpty()) {
  529.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  530.             }
  531.         } catch (const std::runtime_error& e) {
  532.             std::cerr << "Exception caught: " << e.what() << std::endl;
  533.         }
  534.         try{
  535.             if(index < 0 || index >= list_size ){
  536.                 throw std::runtime_error("Index out of bound :(.");
  537.             }
  538.         }catch (const std::runtime_error &e) {
  539.             cerr << "Exception caught " << e.what() << '\n';
  540.         }
  541.         Node<int>* current_node = head;
  542.         assert(current_node);
  543.         Node<int>* previous_current = new Node<int>;
  544.         assert(current_node);
  545.         previous_current->link = nullptr;
  546.         int current_index = -1;
  547.         while (current_index < index-1){
  548.             previous_current = current_node;
  549.             current_node = current_node->link;
  550.             current_index++;
  551.         }
  552.         if(previous_current->link == nullptr){
  553.             head = head->link;
  554.             delete current_node;
  555.         } else if(current_node->link == head){
  556.             previous_current->link = nullptr;
  557.             delete current_node;
  558.         }
  559.         else {
  560.             previous_current->link = current_node->link;
  561.             delete current_node ;
  562.         }
  563.         list_size--;
  564.     }
  565.     T retrieveAt(int index)const{
  566.         try{
  567.             if(index < 0 || index >= list_size){
  568.                 throw std::runtime_error("Index out of bound :(.");
  569.             }
  570.         }catch (const std::runtime_error &e) {
  571.             cerr << "Exception caught " << e.what() << '\n';
  572.         }
  573.         Node<int>* current_node = head;
  574.         assert(current_node);
  575.         Node<int>* previous_current = new Node<int>;
  576.         assert(previous_current);
  577.         previous_current->link = nullptr;
  578.         int current_index = 0;
  579.         while (current_index != index){
  580.             previous_current = current_node;
  581.             current_node = current_node->link;
  582.             current_index++;
  583.         }
  584.         if(previous_current->link == nullptr){
  585.             return head->info;
  586.         } else {
  587.             return current_node->info;
  588.         }
  589.     }
  590.     void replaceAt( T value ,  int index ){
  591.         try{
  592.             if(index < 0 || index >= list_size){
  593.                 throw std::runtime_error("Index out of bound :(.");
  594.             }
  595.         }catch (const std::runtime_error &e) {
  596.             cerr << "Exception caught " << e.what() << '\n';
  597.         }
  598.         Node<int>* current_node = head;
  599.         assert(current_node);
  600.         Node<int>* previous_current = new Node<int>;
  601.         assert(previous_current);
  602.         previous_current->link = nullptr;
  603.         int current_index = -1;
  604.         while (current_index < index-1){
  605.             previous_current = current_node;
  606.             current_node = current_node->link;
  607.             current_index++;
  608.         }
  609.         if(previous_current->link == nullptr){
  610.             head->info = value;
  611.         } else {
  612.             current_node->info = value;
  613.         }
  614.     }
  615.     bool is_itemAt_equal( T value ,  int index )const{
  616.         try{
  617.             if(index < 0 || index >= list_size){
  618.                 throw std::runtime_error("Index out of bound :(.");
  619.             }
  620.         }catch (const std::runtime_error &e) {
  621.             cerr << "Exception caught " << e.what() << '\n';
  622.         }
  623.         Node<int>* current_node = head;
  624.         assert(current_node);
  625.         Node<int>* previous_current = new Node<int>;
  626.         assert(previous_current);
  627.         previous_current->link = nullptr;
  628.         int current_index = -1;
  629.         while (current_index < index-1){
  630.             previous_current = current_node;
  631.             current_node = current_node->link;
  632.             current_index++;
  633.         }
  634.         if(previous_current->link == nullptr){
  635.             return head->info == value;
  636.         } else {
  637.             return current_node->info == value;
  638.         }
  639.     }
  640.     void swap(int first_index , int second_index){
  641.         try{
  642.             if(first_index < 0 || first_index >= list_size || second_index < 0 || second_index >= list_size){
  643.                 throw std::runtime_error("Index out of bound :(.");
  644.             }
  645.         }catch (const std::runtime_error &e) {
  646.             cerr << "Exception caught " << e.what() << '\n';
  647.         }
  648.         if(first_index == second_index)
  649.             return;
  650.         int mx = max(first_index , second_index);
  651.         int mn = min(first_index , second_index);
  652.         first_index = mn;
  653.         second_index = mx;
  654.         Node<T>*first_node = new Node<T>;
  655.         Node<T>*before_first_node = new Node<T>;
  656.         before_first_node->link = nullptr;
  657.  
  658.         Node<T>*second_node = new Node<T>;
  659.         Node<T>*before_second_node = new Node<T>;
  660.         before_second_node->link = nullptr;
  661.  
  662.         first_node = head;
  663.         int cnt = 0;
  664.         while (cnt < first_index){
  665.             before_first_node = first_node;
  666.             first_node = first_node->link;
  667.             cnt++;
  668.         }
  669.  
  670.         second_node = head;
  671.         cnt = 0;
  672.         while (cnt < second_index){
  673.             before_second_node = second_node;
  674.             second_node = second_node->link;
  675.             cnt++;
  676.         }
  677.         Node<T>*temp2 = new Node<T>;
  678.         Node<T>*temp1 = new Node<T>;
  679.  
  680.         if(second_index-first_index == 1){
  681.             if (first_node == head) {
  682.                 // 7 6 5 1 2 3
  683.                 Node<T>*cur = head;
  684.                 while (cur->link != head){
  685.                     cur = cur->link;
  686.                 }
  687.                 Node<T>*after_first = first_node->link;
  688.                 Node<T>*after_second = second_node->link;
  689.  
  690.                 temp2 = first_node;
  691.                 head->link = after_second;
  692.                 second_node->link = head;
  693.  
  694.                 head= second_node;
  695.                 first_node = second_node;
  696.  
  697.                 cur->link = head;
  698.  
  699.             } else if (second_node->link == head) {
  700.                 temp2 = before_first_node;
  701.                 temp1 = second_node;
  702.                 second_node = first_node;
  703.                 second_node->link = head;
  704.                 first_node = temp1;
  705.                 temp2->link = first_node;
  706.                 first_node->link = second_node;
  707.             } else {
  708.                 temp2 = second_node->link;
  709.                 first_node->link = temp2;
  710.                 before_first_node->link = second_node;
  711.                 second_node->link = first_node;
  712.             }
  713.         } else{
  714.             if (first_node == head) {
  715.                 Node<T> *cur = head;
  716.                 while (cur->link != head) {
  717.                     cur = cur->link;
  718.                 }
  719.                 // 7 6 5 1 2 3
  720.                 Node<T>*after_first = first_node->link;
  721.                 Node<T>*after_second = second_node->link;
  722.  
  723.                 temp2 = first_node;
  724.                 head = second_node;
  725.                 head->link = after_first;
  726.                 before_second_node->link = temp2;
  727.                 temp2->link = after_second;
  728.  
  729.                 cur->link = head;
  730.  
  731.             } else if (second_node->link == head) {
  732.                 // 7 6 5 1 2 3
  733.                 Node<T>*after_first = first_node->link;
  734.                 // 7 3 6
  735.                 temp2 = first_node;
  736.                 first_node = second_node ;
  737.                 before_first_node->link = first_node;
  738.                 first_node->link = after_first;
  739.  
  740.                 second_node = temp2;
  741.                 before_second_node->link = second_node;
  742.                 second_node->link = head;
  743.             } else {
  744.                 temp2 = second_node->link;
  745.                 first_node->link = temp2;
  746.                 before_first_node->link = second_node;
  747.                 second_node->link = first_node;
  748.             }
  749.         }
  750.     }
  751.     T size()const{
  752.         return list_size;
  753.     }
  754.     void print()const{
  755.         try {
  756.             if (isEmpty()) {
  757.                 throw std::runtime_error("Empty list: Can't delete an element.\n");
  758.             }
  759.         } catch (const std::runtime_error& e) {
  760.             std::cerr << "Exception caught: " << e.what() << std::endl;
  761.         }
  762.         Node<T>* current = head;
  763.         assert(current);
  764.         for(int i = 0 ; i < list_size ; i++){
  765.             cout << current->info << ' ';
  766.             current = current->link;
  767.         }
  768.         cout << '\n';
  769.  
  770.     }
  771.     bool isEmpty()const{
  772.         return (head == nullptr);
  773.     }
  774.     void clear() {
  775.         if (head != nullptr) {
  776.             Node<T> *current = new Node<T>;
  777.             assert(current);
  778.             current = head;
  779.  
  780.             int t = 0;
  781.             while (t < list_size) {
  782.                 Node<T> *temp = new Node<T>;
  783.                 temp = current;
  784.                 current = current->link;
  785.                 delete temp;
  786.                 t++;
  787.             }
  788.             head = nullptr;
  789.             list_size = 0;
  790.         }
  791.     }
  792.     ~circular_LinkedList() {
  793.         if (head != nullptr) {
  794.             Node<T>* current = head;
  795.             Node<T>* next;
  796.  
  797.             do {
  798.                 next = current->link;
  799.                 delete current;
  800.                 current = next;
  801.             } while (current != head);
  802.  
  803.             head = nullptr;
  804.             list_size = 0;
  805.         }
  806.     }
  807. };
  808.  
  809. int main(){
  810.     circular_LinkedList<int>list1;
  811.     list1.insertAtHead(5);
  812.     list1.insertAtHead(6);
  813.     list1.insertAtHead(7);
  814.     list1.insertAtTail(1);
  815.     list1.insertAtTail(2);
  816.     list1.insertAtTail(3);
  817.  
  818.     // 7 6 5 1 2 3
  819.     list1.swap(0 , 1);
  820.     // 7 3 5 1 2 6
  821.  
  822.     list1.print();
  823.  
  824. }
Success #stdin #stdout 0s 5260KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
6 7 5 1 2 3
https://ideone.com/wuisf0
language:
C++ (gcc 8.3)
created:
9 days 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!