Advertisement
JouJoy

Untitled

Apr 22nd, 2020
590
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 3.40 KB | None | 0 0
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. struct node
  6.  
  7. {
  8.  
  9.     int data;
  10.  
  11.     node* next;
  12.  
  13. };
  14.  
  15. ////////////////////////////////////////////////
  16.  
  17. bool empty_list(node* top)
  18.  
  19. {
  20.  
  21.     return top == NULL;
  22.  
  23. }
  24.  
  25. //////////////////////////////////////////////
  26.  
  27. void create_list(node*& top, int n)
  28.  
  29. {
  30.  
  31.     int i;
  32.  
  33.     node* p;
  34.  
  35.     top = new node;
  36.  
  37.     top = NULL;
  38.  
  39.     for (i = 0; i < n; i++)
  40.  
  41.     {
  42.  
  43.         p = new node;
  44.  
  45.         cout << " enter p->data=";
  46.  
  47.         cin >> p->data;
  48.  
  49.         p->next = top;
  50.  
  51.         top = p;
  52.  
  53.     }
  54.  
  55. }
  56.  
  57. //////////////////////////////////////////////////
  58.  
  59. void pop(node*& top, int& data) // get data from list
  60.  
  61. {
  62.  
  63.     node* p;
  64.  
  65.     if (!empty_list(top))
  66.  
  67.     {
  68.  
  69.         data = top->data;
  70.  
  71.         p = top->next;
  72.  
  73.         delete top;
  74.  
  75.         top = p;
  76.  
  77.     }
  78.  
  79. }
  80.  
  81. //////////////////////////////////////////
  82.  
  83. int pop1(node*& top) // get data from list
  84.  
  85. {
  86.  
  87.     int data;
  88.  
  89.     node* p;
  90.  
  91.     if (top)
  92.  
  93.     {
  94.  
  95.         data = top->data;
  96.  
  97.         p = top->next;
  98.  
  99.         delete top;
  100.  
  101.         top = p;
  102.  
  103.     }
  104.  
  105.     return data;
  106.  
  107. }
  108.  
  109. /////////////////////////////////////////
  110.  
  111. void push(node*& top, int data) // put data to list
  112.  
  113. {
  114.  
  115.     node* p;
  116.  
  117.     p = new node;
  118.  
  119.     p->data = data;
  120.  
  121.     p->next = top;
  122.  
  123.     top = p;
  124.  
  125. }
  126.  
  127. //////////////////////////////////////////
  128.  
  129. void create_list_push(node*& top, int n)
  130.  
  131. {
  132.  
  133.     int i, data;
  134.  
  135.     top = NULL;
  136.  
  137.     for (i = 0; i < n; i++)
  138.  
  139.     {
  140.  
  141.         cout << " enter data=";
  142.  
  143.         cin >> data;
  144.  
  145.         push(top, data);
  146.  
  147.     }
  148.  
  149. }
  150.  
  151. /////////////////////////////////////////
  152.  
  153. void show_list(node* top)
  154.  
  155. {
  156.  
  157.     node* p;
  158.  
  159.     p = top;
  160.  
  161.     while (p)
  162.  
  163.     {
  164.  
  165.         cout << p->data << " ";
  166.  
  167.         p = p->next;
  168.  
  169.     }
  170.  
  171.     cout << endl;
  172.  
  173. }
  174.  
  175. //////////////////////////////////////////////
  176.  
  177. node* previous(node* top, node* p) // pointer p define
  178.  
  179. // task: find previous pointer
  180.  
  181. {
  182.  
  183.     node* pr, * q;
  184.  
  185.     q = top;
  186.  
  187.     pr = NULL;
  188.  
  189.     while (q != p && q)
  190.  
  191.     {
  192.  
  193.         pr = q;
  194.  
  195.         q = q->next;
  196.  
  197.     }
  198.  
  199.     if (q == p) return pr;
  200.  
  201.     return NULL;
  202.  
  203. }
  204.  
  205. node* find_address(node* top, int x)
  206.  
  207. {
  208.  
  209.     node* p;
  210.  
  211.     p = top;
  212.  
  213.     while (p && (p->data) != x)
  214.  
  215.         p = p->next;
  216.  
  217.     return p;
  218.  
  219. }
  220.  
  221. /////////////////////////////////////////////////
  222.  
  223. void delete_element(node*& top, node* p)
  224.  
  225. {
  226.  
  227.     node* r; int x;
  228.  
  229.     if (p == top)
  230.  
  231.         pop(top, x);
  232.  
  233.     else
  234.  
  235.     {
  236.  
  237.         r = previous(top, p);
  238.  
  239.         r->next = p->next;
  240.  
  241.         delete p;
  242.  
  243.     }
  244.  
  245. }
  246.  
  247. bool is_member(node* top, int data)
  248. {
  249.     return find_address(top, data);
  250. }
  251.  
  252. void copy_set(node* top1, node*& top2)
  253. {
  254.     node* p = top1;
  255.     top2 = NULL;
  256.     while (p)
  257.     {
  258.         push(top2, p->data);
  259.         p = p->next;
  260.     }
  261. }
  262. void order_set(node* top)
  263. {
  264.     int r;
  265.     node* p = top;
  266.     node* q;
  267.     while (p->next)
  268.     {
  269.         q = p->next;
  270.         while (q)
  271.         {
  272.             if ((p->data) > (q->data));
  273.             r = p->data;
  274.             p->data = q->data;
  275.             q->data = r;
  276.             q = q->next;
  277.             p = p->next;
  278.         }
  279.     }
  280. }
  281.  
  282. node* obeedinenie(node* top1, node*top2,node*& top3)
  283. {
  284.     top3 = NULL;
  285.     node* p = top2;
  286.     while (p)
  287.     {
  288.         if (is_member(top1, p->data))
  289.             push(top3, p->data);
  290.         p = p->next;
  291.     }
  292.     return top3;
  293. }
  294.  
  295. node* subtrection_sets(node* top1, node* top2)
  296. {
  297.     node* top3 = NULL;
  298.     node* p = top1;
  299.     while (p)
  300.     {
  301.         if (!is_member(top2, p->data))
  302.             push(top3, p->data);
  303.         p = p->next;
  304.     }
  305.     return top3;
  306. }
  307.  
  308. void create_set(node * top1, node * top2, node * &top3)
  309. {
  310.     top3 = NULL;
  311.     copy_set(top1, top3);
  312.     node* p = top2;
  313.     while (p)
  314.     {
  315.         if (!is_member(top3, p->data))
  316.         {
  317.             push(top3, p->data);
  318.             p = p->next;
  319.         }
  320.     }
  321. }
  322. int main()
  323. {
  324.  
  325. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement