SHARE
TWEET

list c++

BeliyCat Nov 12th, 2019 (edited) 73 in 331 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #include <iostream>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. struct listik {
  8.     int value;
  9.     listik* next = NULL;
  10. };
  11.  
  12. long long locate(int s, listik* l) {
  13.     listik* p = l;
  14.     int k = 0;
  15.     while (p != NULL && p->value != s)
  16.     {
  17.         p = p->next;
  18.         k++;
  19.     }
  20.     if (p == NULL)
  21.         return -9223372036854775806;
  22.     return k;
  23. }
  24.  
  25. int insert(int x, int p, listik* l) {
  26.     int p1 = 1;
  27.     listik* nn = l;
  28.     while (nn->next != NULL && p1 != p)
  29.     {
  30.         nn = nn->next;
  31.         p1++;
  32.     }
  33.     listik* ll = new listik;
  34.     ll->next = nn->next;
  35.     ll->value = x;
  36.     nn->next = ll;
  37.     return 1;
  38. }
  39.  
  40. void printlist(listik* l) {
  41.     listik* cat = l;
  42.     while (cat->next != NULL)
  43.     {
  44.         cat = cat->next;
  45.         cout << cat->value << endl;
  46.     }
  47.     cout << endl;
  48. }
  49.  
  50. int listsize(listik* l) {
  51.     listik* p = l;
  52.     int k = 0;
  53.     while (p->next != NULL)
  54.     {
  55.         p = p->next;
  56.         k++;
  57.     }
  58.     return k;
  59. }
  60.  
  61. long long retrieve(int s, listik* l) {
  62.     if (s < 1)
  63.         return -9223372036854775806;
  64.     listik* p = l;
  65.     int k = 0;
  66.     while (p != NULL && k != s)
  67.     {
  68.         p = p->next;
  69.         k++;
  70.     }
  71.     if (p == NULL)
  72.         return 9223372036854775806;
  73.     return p->value;
  74. }
  75.  
  76. long long next(int s, listik* l) {
  77.     if (s < 0)
  78.         return -9223372036854775806;
  79.     listik* p = l;
  80.     int k = -1;
  81.     while (p != NULL && k != s)
  82.     {
  83.         p = p->next;
  84.         k++;
  85.     }
  86.     if (p == NULL)
  87.         return 9223372036854775806;
  88.     return p->value;
  89. }
  90.  
  91.  
  92.  
  93. long long delet(int s, listik* l) {
  94.     if(listsize(l) < 1)
  95.         return -9223372036854775806;
  96.     s = s + 1;
  97.     int p1 = 2;
  98.     listik* nn = l;
  99.     while ((nn->next->next != NULL && nn->next != NULL) && p1 != s)
  100.     {
  101.         nn = nn->next;
  102.         p1++;
  103.     }
  104.     if (nn->next == NULL)
  105.     {
  106.         l->next = NULL;
  107.         return 21;
  108.     }
  109.     if (nn->next->next == NULL)
  110.     {
  111.         listik* del = nn->next;
  112.         delete del;
  113.         nn->next = NULL;
  114.         return 22;
  115.     }
  116.     listik* del = nn->next;
  117.     nn->next = nn->next->next;
  118.     delete del;
  119.     return 11;
  120. }
  121.  
  122.  
  123.  
  124. long long first(listik* l) {
  125.     listik* n = l;
  126.     if (n->next == NULL)
  127.     {
  128.         return -9223372036854775806;
  129.     }
  130.     n = n->next;
  131.     return n->value;
  132. }
  133.  
  134. void makenull(listik* l) {
  135.     listik* p = l;
  136.     while (listsize(l) > 2)
  137.     {
  138.         p = l;
  139.         while (p->next->next != NULL)
  140.         {
  141.             p = p->next;
  142.         }
  143.         listik* del = p;
  144.         del = del->next;
  145.         delete del;
  146.         p->next = NULL;
  147.     }
  148.     p = l;
  149.     p = p->next;
  150.     listik* del = p->next;
  151.     delete del;
  152.     p->next = NULL;
  153.     p = l;
  154.     listik* dele = p->next;
  155.     delete dele;
  156.     p->next = NULL;
  157.     return;
  158. }
  159.  
  160. long long previous(int s, listik* l) {
  161.     if (s <= 1)
  162.         return -9223372036854775806;
  163.     if (s - 1 > listsize(l))
  164.         return 9223372036854775806;
  165.     int k = 0;
  166.     listik* p = l;
  167.     while (p != NULL && k != (s - 1))
  168.     {
  169.         p = p->next;
  170.         k++;
  171.     }
  172.     return p->value;
  173. }
  174.  
  175. void deletelist(listik* l)
  176. {
  177.     listik* n = l;
  178.     makenull(l);
  179.     delete n;
  180. }
  181.  
  182. int main()
  183. {
  184.     listik* test = new listik;
  185.     insert(1, 1, test);
  186.     insert(452, 2, test);
  187.     insert(226, 1, test);
  188.     printlist(test);
  189.     makenull(test);
  190.     insert(21, 1, test);
  191.     printlist(test);
  192.     deletelist(test);
  193.     system("pause");
  194.     return 0;
  195. }
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