193030

Kursova SAA raboti fixed

Oct 26th, 2020 (edited)
167
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // Raboti fixnata e.
  2. #include <iostream>
  3. #include <string>
  4. using namespace std;
  5.  
  6. string names;
  7. string addresses[3];
  8. string phoneNumbers[3];
  9.  
  10. struct Node
  11. {
  12.     string data;
  13.     Node* next;
  14.     Node* child;
  15. } *prevPerson = NULL;
  16.  
  17.  
  18. struct StackNode
  19. {
  20.     struct Node* data;
  21.     struct StackNode* next;
  22. } *top = NULL;
  23.  
  24.  
  25. void enterPerson(); // Read input from the console
  26. // third name, address1, address2, address3, Phone number 1,2,3.
  27. struct Node* addNode(); // Create a new node from the values entered in enterPerson()
  28. void insertStack(struct Node* n); // Inserting an element in the stack
  29. struct Node* popStack(); // Poping element from stack
  30. void traverseList(struct Node* FIRST); // Traversing the list
  31. void traverseListEmployed(struct Node* p); // Traversing the list, printing the employed people
  32. void traverseListEmployedNew(struct Node* p); // Traversing the list, printing the employed people new version
  33. void printStack();
  34. int stackNumberOfElements();
  35.  
  36.  
  37.  
  38. struct Node* lastPersonAdded;
  39. struct Node* firstPersonAdded = NULL;
  40.  
  41. int numberOfPeople = 0;
  42. static int counterEmployed = 0;
  43.  
  44. int main()
  45. {
  46.     int loop = 1;
  47.     while (loop)
  48.     {
  49.         cout << "\nMenu: " << endl;
  50.         cout << "1. Press 1 to add person" << endl;
  51.         cout << "2. Press 2 to show the whole list" << endl;
  52.         cout << "3. Press 3 to show the list of employed people" << endl;
  53.         cout << "5. Press 0 to exit" << endl;
  54.         int inputCommand;
  55.         cin >> inputCommand;
  56.         switch (inputCommand)
  57.         {
  58.         case 1:
  59.         {
  60.             enterPerson();
  61.             struct Node* FIRST = addNode();
  62.             break;
  63.         }
  64.         case 2:
  65.         {
  66.             traverseList(firstPersonAdded);
  67.             break;
  68.         }
  69.         case 3:
  70.         {
  71.             traverseListEmployedNew(firstPersonAdded);
  72.             counterEmployed = 0;
  73.  
  74.         }
  75.         break;
  76.         case 4:
  77.         {
  78.             cout << firstPersonAdded->data << endl;
  79.             cout << firstPersonAdded->next->data << endl;
  80.         }
  81.         break;
  82.  
  83.  
  84.         case 0:
  85.             loop = 0;
  86.             break;
  87.         default:
  88.  
  89.             break;
  90.  
  91.         }
  92.     }
  93. }
  94.  
  95.  
  96. void enterPerson()
  97. {
  98.     cin.ignore();
  99.     cout << "Enter first name: " << endl;
  100.     cin >> names;
  101.     cout << "Enter first address: " << endl;
  102.     cin >> addresses[0];
  103.     cout << "Enter second address: " << endl;
  104.     cin.ignore();
  105.     getline(cin, addresses[1]);
  106.     cout << "Enter third address: " << endl;
  107.     getline(cin, addresses[2]);
  108.     cout << "Enter first phone number: " << endl;
  109.     cin >> phoneNumbers[0];
  110.     cout << "Enter second phone number: " << endl;
  111.     cin >> phoneNumbers[1];
  112.     cout << "Enter third phone number: " << endl;
  113.     cin >> phoneNumbers[2];
  114.  
  115. }
  116.  
  117.  
  118. struct Node* addNode()
  119. {
  120.     struct Node* first;
  121.     first = new Node;
  122.     first->data = names;
  123.     prevPerson = first;
  124.  
  125.     Node* adress1Node = new Node;
  126.     adress1Node->data = addresses[0];
  127.     adress1Node->child = NULL;
  128.  
  129.     Node* adress2Node = new Node;
  130.     adress2Node->data = addresses[1];
  131.     adress1Node->next = adress2Node;
  132.     adress2Node->child = NULL;
  133.  
  134.  
  135.     Node* adress3Node = new Node;
  136.     adress3Node->data = addresses[2];
  137.     adress2Node->next = adress3Node;
  138.     adress3Node->child = NULL;
  139.  
  140.     first->child = adress1Node;
  141.  
  142.     Node* firstNumberNode = new Node;
  143.     firstNumberNode->data = phoneNumbers[0];
  144.     firstNumberNode->next = NULL;
  145.     firstNumberNode->child = NULL;
  146.  
  147.     Node* secondNumberNode = new Node;
  148.     secondNumberNode->data = phoneNumbers[1];
  149.     secondNumberNode->next = NULL;
  150.     secondNumberNode->child = NULL;
  151.     firstNumberNode->next = secondNumberNode;
  152.  
  153.     Node* thirdNumberNode = new Node;
  154.     thirdNumberNode->data = phoneNumbers[2];
  155.     thirdNumberNode->next = NULL;
  156.     thirdNumberNode->child = NULL;
  157.  
  158.     adress1Node->child = firstNumberNode;
  159.     adress3Node->child = thirdNumberNode;
  160.  
  161.     if (numberOfPeople > 0)
  162.     {
  163.         lastPersonAdded->next = first;
  164.         lastPersonAdded = first;
  165.     }
  166.     else
  167.     {
  168.         firstPersonAdded = first;
  169.         lastPersonAdded = first;
  170.     }
  171.     numberOfPeople++;
  172.     return first;
  173. }
  174.  
  175. void traverseList(struct Node* p)
  176. {
  177.     int static counterTraverse = 0;
  178.     int whileFlag = 1;
  179.     counterTraverse++;
  180.     if (counterTraverse == numberOfPeople * 8)
  181.     {
  182.         counterTraverse = 0;
  183.         whileFlag = 0;
  184.     }
  185.     while (whileFlag)
  186.     {
  187.         if (p)
  188.         {
  189.            // int stackElements = stackNumberOfElements();
  190.  
  191.             cout << " " << p->data; //<< "stack number of elements" << stackElements << endl;
  192.            // printStack();
  193.  
  194.         }
  195.         if (p->child && p->next)
  196.         {
  197.             //  cout << "insert stack p->next " << p->next->data << endl;
  198.             insertStack(p->next);
  199.             traverseList(p->child);
  200.             break;
  201.         }
  202.         if (p->child)
  203.         {
  204.             traverseList(p->child);
  205.             break;
  206.  
  207.         }
  208.         if (p->next)
  209.         {
  210.             traverseList(p->next);
  211.             break;
  212.         }
  213.         if (top == NULL && p->child ==  NULL && p->next == NULL)
  214.         {
  215.             //cout << "top == NULL p->data " << p->data << endl;
  216.             break;
  217.         }
  218.  
  219.         if (p->next == NULL && p->child == NULL && top != NULL)
  220.         {
  221.             p = popStack();
  222.             // cout << "p popped --------------------------------------------" << p->data << endl;
  223.             traverseList(p);
  224.             break;
  225.         }
  226.         else
  227.         {
  228.             break;
  229.         }
  230.     }
  231.  
  232. }
  233.  
  234. void traverseListEmployedNew(struct Node* p)
  235. {
  236.     struct Node* address2 = NULL;
  237.     struct Node* address3 = NULL;
  238.     static int counterTraverse = 0;
  239.     int whileFlag = 1;
  240.     int flagPrint = 1;
  241.     counterTraverse++;
  242.     if (counterTraverse == (numberOfPeople * 8)-1)
  243.     {
  244.         counterTraverse = 0;
  245.         cout <<" "<< p->data << endl;
  246.         whileFlag = 0;
  247.         return;
  248.     }
  249.     if (counterTraverse == 1 || counterTraverse % 8 == 0)
  250.     {
  251.         if (p->child!=nullptr)
  252.         {
  253.             if (p->child->next)
  254.                 address2 = p->child->next;
  255.             if (p->child->next->next)
  256.                 address3 = p->child->next->next;
  257.         }
  258.        if (address2->data.empty() == 1 && address3->data.empty() == 1)
  259.        {
  260.            flagPrint = 0;
  261.        }
  262.     }
  263.     while (whileFlag)
  264.     {
  265.         if (p)
  266.         {
  267.             // int stackElements = stackNumberOfElements();
  268.             if(flagPrint)
  269.                 cout << " " << p->data; //<< "stack number of elements" << stackElements << endl;
  270.            // printStack();
  271.  
  272.         }
  273.         if (p->child && p->next)
  274.         {
  275.             //  cout << "insert stack p->next " << p->next->data << endl;
  276.             insertStack(p->next);
  277.             traverseListEmployedNew(p->child);
  278.             break;
  279.         }
  280.         if (p->child)
  281.         {
  282.             traverseListEmployedNew(p->child);
  283.             break;
  284.  
  285.         }
  286.         if (p->next)
  287.         {
  288.             traverseListEmployedNew(p->next);
  289.             break;
  290.         }
  291.         if (top == NULL && p->child == NULL && p->next == NULL)
  292.         {
  293.             //cout << "top == NULL p->data " << p->data << endl;
  294.             break;
  295.         }
  296.  
  297.         if (p->next == NULL && p->child == NULL && top != NULL)
  298.         {
  299.             p = popStack();
  300.             // cout << "p popped --------------------------------------------" << p->data << endl;
  301.             traverseListEmployedNew(p);
  302.             break;
  303.         }
  304.         else
  305.         {
  306.             break;
  307.         }
  308.     }
  309.  
  310. }
  311.  
  312.  
  313.  
  314. void traverseListEmployed(struct Node* p)
  315. {
  316.  
  317.     int whileLoop = 1;
  318.     if (p != NULL)
  319.     {
  320.         static int flagPrint = 0;
  321.         counterEmployed++;
  322.         if (counterEmployed > 7) // 7 elements in the list
  323.         {
  324.             counterEmployed = 1;
  325.         }
  326.         cout << "counterEmployed i p->data " << counterEmployed << " " << p->data << endl;
  327.  
  328.         if (counterEmployed == 1)
  329.         {
  330.             struct Node* address2 = p->child->next;
  331.             struct Node* address3 = p->child->next->next;
  332.             cout << "address2 i address3 " <<
  333.                 address2->data << " " << address3->data << endl;
  334.             if (address2->data.empty() == 1 && address3->data.empty() == 1)
  335.             {
  336.  
  337.                 cout << "vliza v empty" << endl;
  338.  
  339.                 flagPrint = 0;
  340.                 if (p->next == NULL)
  341.                 {
  342.                     whileLoop = 0;
  343.                     cout << "if p->next==NULL" << endl;
  344.                     //traverseListEmployed(p->next);
  345.  
  346.                 }
  347.                 else
  348.                 {
  349.                     //    cout << "end list" << endl;
  350.                 }
  351.             }
  352.             else
  353.             {
  354.                 flagPrint = 1;
  355.             }
  356.         }
  357.  
  358.         int static counterTraverse = 0;
  359.         counterTraverse++;
  360.         if (counterTraverse == numberOfPeople * 8)
  361.         {
  362.             counterTraverse = 0;
  363.             whileLoop = 0;
  364.         }
  365.         while (whileLoop)
  366.         {
  367.             if (p)
  368.             {
  369.                 int stackElements = stackNumberOfElements();
  370.                 if (flagPrint)
  371.                     cout << " " << p->data << endl;//<< "stack number of elements" << stackElements << endl;
  372.                 if (!flagPrint)
  373.                     cout << "!" << p->data << endl;//<< "stack number of elements" << stackElements << endl;
  374.  
  375.                // printStack();
  376.  
  377.             }
  378.             if (p->child && p->next)
  379.             {
  380.                 //  cout << "insert stack p->next " << p->next->data << endl;
  381.                 insertStack(p->next);
  382.                 traverseListEmployed(p->child);
  383.                 break;
  384.             }
  385.             if (p->child)
  386.             {
  387.                 traverseListEmployed(p->child);
  388.                 break;
  389.  
  390.             }
  391.             if (p->next)
  392.             {
  393.                 traverseListEmployed(p->next);
  394.                 break;
  395.             }
  396.             if (top == NULL)
  397.             {
  398.                 //cout << "top == NULL p->data " << p->data << endl;
  399.  
  400.             }
  401.  
  402.             if (p->next == NULL && p->child == NULL && top != NULL)
  403.             {
  404.                 cout << "print stack before pop: ";
  405.                 printStack();
  406.                 cout << endl;
  407.                 p = popStack();
  408.                // cout << "p popped --------------------------------------------" << p->data << endl;
  409.               //  cout << "print stack after pop: ";
  410.              //   printStack();
  411.                 cout << endl;
  412.                 traverseListEmployed(p);
  413.                 break;
  414.             }
  415.             if (p->next == NULL && p->child == NULL)
  416.             {
  417.                 cout << " p->next == NULL && p->child == NULL " << endl;
  418.                 break;
  419.             }
  420.             else
  421.             {
  422.                 break;
  423.             }
  424.         }
  425.     }
  426. }
  427.  
  428. void insertStack(struct Node* p)
  429. {
  430.     if (top == NULL)
  431.     {
  432.         top = new StackNode;
  433.         top->data = p;
  434.         top->next = NULL;
  435.     }
  436.     else
  437.     {
  438.         StackNode* t = new StackNode;
  439.         t->data = p;
  440.         t->next = top;
  441.         top = t;
  442.     }
  443. }
  444.  
  445. int stackNumberOfElements()
  446. {
  447.     int countStack = 0;
  448.     StackNode* p = top;
  449.     while (p)
  450.     {
  451.         p = p->next;
  452.         countStack++;
  453.     }
  454.     return countStack;
  455. }
  456.  
  457. struct Node* popStack()
  458. {
  459.     struct StackNode* p;
  460.     struct Node* t;
  461.     p = top;
  462.     t = top->data;
  463.     top = top->next;
  464.     delete p;
  465.     return t;
  466.  
  467.  
  468. }
  469.  
  470. void printStack()
  471. {
  472.     struct StackNode* p = top;
  473.     //   cout << "Printing the stack with elements : " << stackNumberOfElements() << " | ";
  474.     while (p != NULL)
  475.     {
  476.         cout << p->data->data << " ";
  477.         p = p->next;
  478.     }
  479.     cout << endl;
  480. }
RAW Paste Data Copied