SHARE
TWEET

Untitled

a guest Jun 19th, 2017 48 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. using namespace std;
  3.  
  4.  
  5. struct node
  6. {
  7.     node * next;
  8.     int val;
  9. };
  10. bool isEmpty(node*head)
  11. {
  12.     return !head;
  13. }
  14.  
  15. void addFrontList(node *&head, int v)
  16. {
  17.     node * s = new node;
  18.     s->next = head;
  19.     s->val = v;
  20.     head = s;
  21. }
  22.  
  23. void removeFrontList(node *&head)
  24. {
  25.     if (isEmpty(head))
  26.     {
  27.         cout << "List is Empty!!" << endl;
  28.         return;
  29.     }
  30.     else
  31.     {
  32.         node * s = head;
  33.         head = head->next;
  34.         delete s;
  35.     }
  36. }
  37.  
  38. void showList(node *&head)
  39. {
  40.     node * s = head;
  41.     while (s)
  42.     {
  43.         cout << s->val << " ";
  44.         s = s->next;
  45.     }
  46.     cout << endl << endl;
  47. }
  48.  
  49. void mergeLists(node *&head1,node*&head2)
  50. {
  51.     node * s = head1;
  52.     while (s->next)
  53.     {
  54.         s = s->next;
  55.     }
  56.     s->next = head2;
  57. }
  58.  
  59. void switchFirstLast(node *&head)
  60. {
  61.     node * s = head;
  62.     if (isEmpty(head))
  63.     {
  64.         cout << "stack is empty!" << endl;
  65.         return;
  66.     }
  67.     if (s->next == nullptr)
  68.     {
  69.         cout << "can't switch only 1 element!" << endl;
  70.         return;
  71.     }
  72.     if (s->next->next == nullptr)
  73.     {
  74.        
  75.         node * x = s->next;
  76.         x->next = s;
  77.         s->next = nullptr;
  78.         head = x;
  79.     }
  80.     else
  81.     {
  82.         while (s->next->next)
  83.         {
  84.             s = s->next;
  85.         }
  86.         node * x = s->next;
  87.         x->next = head->next;
  88.         s->next = head;
  89.         head->next = nullptr;
  90.         head = x;
  91.  
  92.     }
  93. }
  94.  
  95. void switchXToNext(node *&head,int v)
  96. {
  97.    
  98.     node * s = head;
  99.     if (isEmpty(head))
  100.     {
  101.         cout << "list is empty!" << endl;
  102.         return;
  103.     }
  104.     if(s->next == nullptr)
  105.     {
  106.         cout << "only one element!" << endl;
  107.         return;
  108.     }
  109.     if (s->next->next == nullptr && s->val == v)
  110.     {
  111.         node * x = s->next;
  112.         s->next = nullptr;
  113.         x->next = s;
  114.         head = x;
  115.         return;
  116.     }
  117.    
  118.     while (s->next->next)
  119.     {
  120.         if (s->val == v && s == head)
  121.         {
  122.             node * x = s->next;
  123.             s->next = x->next;
  124.             x->next = s;
  125.             head = x;
  126.            
  127.  
  128.         }
  129.  
  130.     if (s->next->val == v)
  131.         {
  132.            
  133.             node * x = s->next;
  134.             s->next = s->next->next;
  135.             if (s->next->next == nullptr)
  136.             {
  137.                 s->next->next = x;
  138.                 x->next = nullptr;
  139.                 return;
  140.             }
  141.             else
  142.             {
  143.                 x->next = s->next->next;
  144.             }
  145.             s->next->next = x;
  146.             s = s->next;
  147.         }
  148.      s = s->next;
  149.     }
  150. }
  151.  
  152. void switchXToPrev(node*&head, int v)
  153. {
  154.     node * s = head;
  155.     if (isEmpty(head))
  156.     {
  157.         cout << "list is Empty!" << endl;
  158.         return;
  159.     }
  160.     if (s->next == nullptr)
  161.     {
  162.         cout << "only one element!" << endl;
  163.         return;
  164.     }
  165.     if (s->next->val == v & s==head)
  166.     {
  167.         node * x = s->next;
  168.         if (s->next->next == nullptr)
  169.         {
  170.             s->next = nullptr;
  171.             x->next = s;
  172.             head = x;
  173.             return;
  174.         }
  175.         else
  176.         {
  177.             s->next = s->next->next;
  178.             x->next = s;
  179.             head = x;
  180.         }
  181.        
  182.     }
  183.    
  184.     while (s->next->next)
  185.     {
  186.        
  187.        
  188.         if (s->next->next->val == v)
  189.         {
  190.             node * x = s->next;
  191.             s->next = s->next->next;
  192.             if (s->next->next == nullptr)
  193.             {
  194.                 x->next = nullptr;
  195.                 s->next->next = x;
  196.                 return;
  197.             }
  198.             else
  199.             {
  200.                 x->next = s->next->next;
  201.                 s->next->next = x;
  202.             }
  203.            
  204.         }
  205.         s = s->next;
  206.     }
  207.  
  208. }
  209.  
  210. void deleteEverySecond(node*head)
  211. {
  212.     if (isEmpty(head))
  213.     {
  214.         cout << "list is Empty!" << endl;
  215.     }
  216.     node * s = head;
  217.     while (s->next)
  218.     {
  219.         node * x = s->next;
  220.         if (s->next->next == nullptr)
  221.         {
  222.             s->next = nullptr;
  223.             delete x;
  224.             return;
  225.         }
  226.         else
  227.         {
  228.             s->next = x->next;
  229.             delete x;
  230.             s = s->next;
  231.         }
  232.     }
  233. }
  234.  
  235. void deleteEveryThird(node *head)
  236. {
  237.    
  238.  
  239.     node * s = head;
  240.     if (isEmpty(head))
  241.     {
  242.         cout << "list is empty!" << endl;
  243.     }
  244.     else
  245.     {
  246.         while (s->next->next)
  247.         {
  248.             node * x = s->next->next;
  249.             if (s->next->next->next == nullptr)
  250.             {
  251.                 s->next->next = nullptr;
  252.                 delete x;
  253.                 return;
  254.             }
  255.             else
  256.             {
  257.                 s->next->next = x->next;
  258.                 s = s->next->next;
  259.                 delete x;
  260.             }
  261.         }
  262.     }
  263. }
  264.  
  265. void deleteNAfterX(node *head, int N, int X)
  266. {
  267.     if (isEmpty(head))
  268.     {
  269.         cout << "list is empty!" << endl;
  270.         return;
  271.     }
  272.     else
  273.     {
  274.         node * s = head;
  275.         int tmp = N;
  276.         if (s->next == nullptr)
  277.         {
  278.             cout << "only one element!" << endl;
  279.             return;
  280.         }
  281.         while (s->next)
  282.        
  283.         {
  284.             if (s->val == X)
  285.         {  
  286.                 while (tmp)
  287.                 {
  288.                     if (s->next == nullptr)
  289.                     {
  290.                         return;
  291.                     }
  292.                     else
  293.                     {
  294.                         node * x = s->next;
  295.                         if (s->next->next == nullptr)
  296.                         {
  297.                             s->next = nullptr;
  298.                             delete x;
  299.                             return;
  300.                         }
  301.                         else
  302.                         {
  303.                             s->next = s->next->next;
  304.                             delete x;
  305.                         }
  306.  
  307.                     }
  308.                    
  309.                     tmp--;
  310.                 }
  311.                
  312.                
  313.            
  314.         }
  315.             s = s->next;
  316.         }
  317.     }
  318. }
  319.  
  320. void reverseList(node *&head)
  321. {
  322.     if (isEmpty(head))
  323.     {
  324.         cout << "list is Empty!" << endl;
  325.         return;
  326.     }
  327.     else
  328.     {
  329.         node * p = head;
  330.        
  331.         while (p->next)
  332.         {
  333.             node * x = p->next;
  334.             p->next = x->next;
  335.             x->next = head;
  336.             head = x;
  337.  
  338.         }
  339.     }
  340. }
  341.  
  342. void copyListAfter(node *head)
  343. {
  344.     if (isEmpty(head))
  345.     {
  346.         cout << "stack is Empty!" << endl;
  347.     }
  348.     else
  349.     {
  350.         node * s = head;
  351.         node * pointer = head;
  352.         while (s->next)
  353.         {
  354.             s = s->next;
  355.         }
  356.         node * stop = s;
  357.         if (pointer == stop)
  358.         {
  359.             node * element = new node;
  360.             element->next = nullptr;
  361.             element->val = pointer->val;
  362.             s->next = element;
  363.             s = s->next;
  364.         }
  365.         while (pointer)
  366.         {
  367.             node * element = new node;
  368.             element->next = nullptr;
  369.             element->val = pointer->val;
  370.             s->next = element;
  371.             s = s->next;
  372.             if (pointer == stop) return;
  373.             else pointer = pointer->next;
  374.         }
  375.    
  376.        
  377.            
  378.     }
  379. }
  380.  
  381. void copyAfterXtimesX(node *head)
  382. {
  383.     node * s = head;
  384.    
  385.     while (s)
  386.     {
  387.         int tmp = (s->val)-1;
  388.        
  389.            
  390.             {
  391.                 if (s->next == nullptr)
  392.                 {
  393.                     while (tmp)
  394.                     {
  395.                         node * elem = new node;
  396.                         elem->next = nullptr;
  397.                         elem->val = s->val;
  398.                         s->next = elem;
  399.                         s = s->next;
  400.                         tmp--;
  401.                        
  402.                     }
  403.                     return;
  404.                 }
  405.                 else
  406.                 {
  407.                     while (tmp)
  408.                     {
  409.                        
  410.                         node * elem = new node;
  411.                         elem->next = s->next;
  412.                         elem->val = s->val;
  413.                         s->next = elem;
  414.                         s = s->next;
  415.                         tmp--;
  416.                     }
  417.                    
  418.                 }
  419.             s = s->next;
  420.             }
  421.  
  422.        
  423.  
  424.     }
  425.  
  426. }
  427.  
  428. void insertSort(node *&head,int v)
  429. {
  430.  
  431.         node * s = head;
  432.         node * elem = nullptr;
  433.         if (s == nullptr)
  434.         {
  435.             elem = new node;
  436.             elem->val = v;
  437.             elem->next = nullptr;
  438.             s = elem;
  439.             head = s;
  440.             return;
  441.         }
  442.  
  443.         else if (s->next == nullptr)
  444.         {
  445.             elem = new node;
  446.             elem->val = v;
  447.             if (v > s->val)
  448.             {
  449.                 s->next = elem;
  450.                 elem->next = nullptr;
  451.                 return;
  452.             }
  453.             if (v < s->val)
  454.             {
  455.                 elem->next = s;
  456.                 head = elem;
  457.                 return;
  458.             }
  459.  
  460.         }
  461.  
  462.         if (s == head && v < s->val)
  463.         {
  464.             elem = new node;
  465.             elem->next = s;
  466.             elem->val = v;
  467.             head = elem;
  468.             return;
  469.         }
  470.             while (s->next)
  471.             {
  472.                 if (s->val<v && s->next->val>v)
  473.                 {
  474.                     elem = new node;
  475.                     elem->val = v;
  476.                     node * x = s->next;
  477.                     s->next = elem;
  478.                     elem->next = x;
  479.                     return;
  480.                    
  481.  
  482.                 }
  483.             s=s->next;
  484.             }
  485.             elem = new node;
  486.             elem->val = v;
  487.             s->next = elem;
  488.             elem->next = nullptr;
  489.             return;
  490.  
  491.         }
  492.    
  493. void bubbleSort(node *&head)
  494. {
  495.  
  496. }
  497.  
  498.  
  499.  
  500.  
  501. int main()
  502. {
  503. node * head1 = nullptr;
  504.  
  505. addFrontList(head1, 6); // bubblesort
  506. addFrontList(head1, 7);
  507. addFrontList(head1, 1);
  508. addFrontList(head1, 8);
  509. addFrontList(head1, 5);
  510. showList(head1);
  511.  
  512.  
  513.  
  514.  
  515. /*insertSort(head1, 4); //insertsort
  516. insertSort(head1, 5);
  517. insertSort(head1, 6);
  518. insertSort(head1, 3);
  519. insertSort(head1, 2);
  520. showList(head1);*/
  521.  
  522.  
  523. /*addFrontList(head1, 5); // dla pracy na listach
  524. addFrontList(head1, 4);
  525. addFrontList(head1, 3);
  526. addFrontList(head1, 2);
  527. addFrontList(head1, 2);
  528. showList(head1);*/
  529.  
  530. /*copyAfterXtimesX(head1);
  531. showList(head1);*/
  532.  
  533. /*copyListAfter(head1);
  534. showList(head1);*/
  535.  
  536. /*reverseList(head1);
  537. showList(head1);*/
  538.  
  539. /*deleteNAfterX(head1, 2, 5);
  540. showList(head1);*/
  541.  
  542. /*deleteEveryThird(head1);
  543. showList(head1);*/
  544.  
  545.  
  546. /*deleteEverySecond(head1);
  547. showList(head1);*/
  548.  
  549. /*switchXToPrev(head1,5);
  550. showList(head1);*/
  551.  
  552. /*switchXToNext(head1, 2);
  553. showList(head1);*/
  554.  
  555. /*switchFirstLast(head1);
  556. showList(head1);*/
  557.  
  558. /*node* head2 = NULL;
  559. addFrontList(head2, 10);
  560. addFrontList(head2, 9);
  561. addFrontList(head2, 8);
  562. addFrontList(head2, 7);
  563. addFrontList(head2, 6);
  564. showList(head2);
  565.  
  566. mergeStacks(head1, head2);
  567. showList(head1);*/
  568. system("pause");
  569. return 0;
  570. }
RAW Paste Data
Want to get better at C++?
Learn to code C++ in 2017
Pastebin PRO Summer Special!
Get 40% OFF on Pastebin PRO accounts!
Top