Advertisement
JouJoy

Untitled

Apr 15th, 2020
269
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.68 KB | None | 0 0
  1. //arb2016_basic_functions_list
  2.  
  3. // in this progam define functions
  4.  
  5. // node* previous(node* top,node* p)
  6.  
  7. //void insert_list_before(node* &top,node* q,int x)
  8.  
  9. //void insert_list_after(node* top, node* &q, int x)
  10.  
  11. //node* find_address(node* top, int x)
  12.  
  13. //void delete_element(node* &top, node* p)
  14.  
  15.  
  16.  
  17. #include <iostream>
  18.  
  19. using namespace std;
  20.  
  21. struct node
  22.  
  23. {
  24.  
  25.     int data;
  26.  
  27.     node* next;
  28.  
  29. };
  30.  
  31. ////////////////////////////////////////////////
  32.  
  33. bool empty_list(node* top)
  34.  
  35. {
  36.  
  37.     return top == NULL;
  38.  
  39. }
  40.  
  41. //////////////////////////////////////////////
  42.  
  43. void create_list(node*& top, int n)
  44.  
  45. {
  46.  
  47.     int i;
  48.  
  49.     node* p;
  50.  
  51.     top = new node;
  52.  
  53.     top = NULL;
  54.  
  55.     for (i = 0; i < n; i++)
  56.  
  57.     {
  58.  
  59.         p = new node;
  60.  
  61.         cout << " enter p->data=";
  62.  
  63.         cin >> p->data;
  64.  
  65.         p->next = top;
  66.  
  67.         top = p;
  68.  
  69.     }
  70.  
  71. }
  72.  
  73. //////////////////////////////////////////////////
  74.  
  75. void pop(node*& top, int& data) // get data from list
  76.  
  77. {
  78.  
  79.     node* p;
  80.  
  81.     if (!empty_list(top))
  82.  
  83.     {
  84.  
  85.         data = top->data;
  86.  
  87.         p = top->next;
  88.  
  89.         delete top;
  90.  
  91.         top = p;
  92.  
  93.     }
  94.  
  95. }
  96.  
  97. //////////////////////////////////////////
  98.  
  99. int pop1(node*& top) // get data from list
  100.  
  101. {
  102.  
  103.     int data;
  104.  
  105.     node* p;
  106.  
  107.     if (top)
  108.  
  109.     {
  110.  
  111.         data = top->data;
  112.  
  113.         p = top->next;
  114.  
  115.         delete top;
  116.  
  117.         top = p;
  118.  
  119.     }
  120.  
  121.     return data;
  122.  
  123. }
  124.  
  125. /////////////////////////////////////////
  126.  
  127. void push(node*& top, int data) // put data to list
  128.  
  129. {
  130.  
  131.     node* p;
  132.  
  133.     p = new node;
  134.  
  135.     p->data = data;
  136.  
  137.     p->next = top;
  138.  
  139.     top = p;
  140.  
  141. }
  142.  
  143. //////////////////////////////////////////
  144.  
  145. void create_list_push(node*& top, int n)
  146.  
  147. {
  148.  
  149.     int i, data;
  150.  
  151.     top = NULL;
  152.  
  153.     for (i = 0; i < n; i++)
  154.  
  155.     {
  156.  
  157.         cout << " enter data=";
  158.  
  159.         cin >> data;
  160.  
  161.         push(top, data);
  162.  
  163.     }
  164.  
  165. }
  166.  
  167. /////////////////////////////////////////
  168.  
  169. void show_list(node* top)
  170.  
  171. {
  172.  
  173.     node* p;
  174.  
  175.     p = top;
  176.  
  177.     while (p)
  178.  
  179.     {
  180.  
  181.         cout << p->data << " ";
  182.  
  183.         p = p->next;
  184.  
  185.     }
  186.  
  187.     cout << endl;
  188.  
  189. }
  190.  
  191. //////////////////////////////////////////////
  192.  
  193. node* previous(node* top, node* p) // pointer p define
  194.  
  195. // task: find previous pointer
  196.  
  197. {
  198.  
  199.     node* pr, * q;
  200.  
  201.     q = top;
  202.  
  203.     pr = NULL;
  204.  
  205.     while (q != p && q)
  206.  
  207.     {
  208.  
  209.         pr = q;
  210.  
  211.         q = q->next;
  212.  
  213.     }
  214.  
  215.     if (q == p) return pr;
  216.  
  217.     return NULL;
  218.  
  219. }
  220.  
  221. //////////////////////////////////////////
  222.  
  223. void insert_list_before(node*& top, node* q, int x)
  224.  
  225. // insert x before position q
  226.  
  227. {
  228.  
  229.     node* p, * r;
  230.  
  231.     p = new node;
  232.  
  233.     r = previous(top, q);
  234.  
  235.     if (q == top) push(top, x);
  236.  
  237.     else
  238.  
  239.         if (r == NULL)
  240.  
  241.         {
  242.  
  243.             cout << " sorry, impossible insert element " << endl;
  244.  
  245.             system("pause");
  246.  
  247.             exit(-1);
  248.  
  249.         }
  250.  
  251.         else
  252.  
  253.         {
  254.  
  255.             p->data = x;
  256.  
  257.             p->next = r->next;
  258.  
  259.             r->next = p;
  260.  
  261.         }
  262.  
  263. }
  264.  
  265. ///////////////////////////////////////////
  266.  
  267. void insert_list_after(node* top, node*& q, int x)
  268.  
  269. // insert x after position q
  270.  
  271. {
  272.  
  273.     node* p;
  274.  
  275.     p = new node;
  276.  
  277.     p->data = x;
  278.  
  279.     p->next = q->next;
  280.  
  281.     q->next = p;
  282.  
  283. }
  284.  
  285. ///////////////////////////////////////////////////
  286.  
  287. node* find_address(node* top, int x)
  288.  
  289. {
  290.  
  291.     node* p;
  292.  
  293.     p = top;
  294.  
  295.     while (p && (p->data) != x)
  296.  
  297.         p = p->next;
  298.  
  299.     return p;
  300.  
  301. }
  302.  
  303. /////////////////////////////////////////////////
  304.  
  305. void delete_element(node*& top, node* p)
  306.  
  307. {
  308.  
  309.     node* r; int x;
  310.  
  311.     if (p == top)
  312.  
  313.         pop(top, x);
  314.  
  315.     else
  316.  
  317.     {
  318.  
  319.         r = previous(top, p);
  320.  
  321.         r->next = p->next;
  322.  
  323.         delete p;
  324.  
  325.     }
  326.  
  327. }
  328.  
  329. void list_two_lists(node* top, node*& top1, node*& top2)
  330. {
  331.    
  332.     top1 = NULL;
  333.     top2 = NULL;
  334.     node* p = top;
  335.     while (p)
  336.     {
  337.         if ((p->data) % 2 == 1)
  338.             push(top1, p->data);
  339.         else push(top2, p->data);
  340.         p = p->next;
  341.     }
  342. }
  343. int min(node* top)
  344. {
  345.     node* p;
  346.     p = top;
  347.     int min1=top->data;
  348.     while (p)
  349.     {
  350.         if (min1 > p->data)
  351.         {
  352.             min1 = p->data;
  353.         }
  354.         p = p->next;
  355.     }
  356.     return min1;
  357.  
  358. }
  359. int max(node* top)
  360. {
  361.     node* p;
  362.     p = top;
  363.     int max1 = top->data;
  364.     while (p)
  365.     {
  366.         if (max1 < p->data)
  367.         {
  368.             max1 = p->data;
  369.         }
  370.         p = p->next;
  371.     }
  372.     return max1;
  373.  
  374. }
  375.     void change(node * top)
  376.     {
  377.         node* pmin = NULL;
  378.         node* pmax = NULL;
  379.         int min1 = min(top);
  380.         int max1 = max(top);
  381.         pmin = find_address(top, min1);
  382.         pmax = find_address(top, max1);
  383.         int c;
  384.         c = pmax->data;
  385.         pmax->data = pmin->data;
  386.         pmin->data = c;
  387.  
  388.     }
  389.  
  390.  
  391. ////////////////////////////////////////////////
  392.  
  393. int main()
  394. {
  395.  
  396.     int n, data1, data2, data3, data4, data5;
  397.  
  398.     node* top_my_list;
  399.  
  400.     node* p;
  401.     node* top11;
  402.     node* top22;
  403.     cout << "enter n= ";
  404.  
  405.     cin >> n;
  406.  
  407.     create_list(top_my_list, n);
  408.  
  409.     cout << " list = ";
  410.  
  411.     show_list(top_my_list);
  412.  
  413.     cout << "enter data1=";
  414.  
  415.     cin >> data1;
  416.  
  417.     p = find_address(top_my_list, data1);
  418.  
  419.     if (p) cout << "data1 = " << p->data << endl;
  420.  
  421.     else
  422.  
  423.     {
  424.  
  425.         cout << "sorry! data1 not exist in list " << endl;
  426.  
  427.         exit(1);
  428.  
  429.     }
  430.  
  431.     cout << "insert data2 before data1" << endl;
  432.  
  433.     cout << "enter data2= ";
  434.  
  435.     cin >> data2;
  436.  
  437.     insert_list_before(top_my_list, p, data2);
  438.  
  439.     cout << " list = ";
  440.  
  441.     show_list(top_my_list);
  442.  
  443.     cout << "insert data3 ater data1" << endl;
  444.  
  445.     cout << "enter data3= ";
  446.  
  447.     cin >> data3;
  448.  
  449.     insert_list_after(top_my_list, p, data3);
  450.  
  451.     cout << " list = ";
  452.  
  453.     show_list(top_my_list);
  454.  
  455.     cout << "delete data4" << endl;
  456.  
  457.     cout << "enter data4=";
  458.  
  459.     cin >> data4;
  460.  
  461.     p = find_address(top_my_list, data4);
  462.  
  463.     if (p)
  464.  
  465.         delete_element(top_my_list, p);
  466.  
  467.     cout << " list = ";
  468.  
  469.     show_list(top_my_list);
  470.  
  471.     cout << "delete data5" << endl;
  472.  
  473.     cout << "enter data5=";
  474.  
  475.     cin >> data5;
  476.  
  477.     p = find_address(top_my_list, data5);
  478.  
  479.     if (p)
  480.  
  481.         delete_element(top_my_list, p);
  482.  
  483.     cout << " list = ";
  484.  
  485.     show_list(top_my_list);
  486.     list_two_lists(top_my_list, top11, top22);
  487.     show_list(top11);
  488.     show_list(top22);
  489.     change(top_my_list);
  490.     show_list(top_my_list);
  491.     system("pause");
  492.  
  493.     return 0;
  494. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement