193030

Kursova SAA new pochti raboti, da se fixne stack-a mai? pri nqkoi inputi se chupi

Oct 23rd, 2020 (edited)
510
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.80 KB | None
  1. // Raboti do nqkyde. next ne raboti
  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.  
  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.              traverseListEmployed(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.     while(1)
  178.     {
  179.         if(p)
  180.         {
  181.             int stackElements = stackNumberOfElements();
  182.  
  183.             cout << " " << p->data; //<< "stack number of elements" << stackElements << endl;
  184.            // printStack();
  185.  
  186.         }
  187.         if(p->child && p->next)
  188.         {
  189.           //  cout << "insert stack p->next " << p->next->data << endl;
  190.             insertStack(p->next);
  191.             traverseList(p->child);
  192.             break;
  193.         }
  194.         if(p->child)
  195.         {
  196.             traverseList(p->child);
  197.             break;
  198.  
  199.         }
  200.         if(p->next)
  201.         {
  202.             traverseList(p->next);
  203.             break;
  204.         }
  205.         if(top == NULL)
  206.         {
  207.             //cout << "top == NULL p->data " << p->data << endl;
  208.  
  209.         }
  210.  
  211.         if(p->next == NULL && p->child == NULL && top!=NULL)
  212.         {
  213.             p = popStack();
  214.            // cout << "p popped --------------------------------------------" << p->data << endl;
  215.             traverseList(p);
  216.             break;
  217.         }
  218.         else
  219.         {
  220.             break;
  221.         }
  222.     }
  223.  
  224. }
  225.  
  226. void traverseListEmployed(struct Node *p)
  227. {
  228.  
  229.     int whileLoop = 1;
  230.     if(p!=NULL)
  231.     {
  232.     static int flagPrint = 0;
  233.     counterEmployed++;
  234.     if(counterEmployed > 7) // 7 elements in the list
  235.     {
  236.         counterEmployed = 1;
  237.     }
  238.     cout << "counterEmployed i p->data " << counterEmployed<<" " << p->data <<endl;
  239.  
  240.     if(counterEmployed == 1)
  241.     {
  242.         struct Node *address2 = p->child->next;
  243.         struct Node *address3 = p->child->next->next;
  244.         cout << "address2 i address3 " <<
  245.         address2->data  << " " << address3->data << endl;
  246.         if(address2->data.empty()== 1  && address3->data.empty() == 1 )
  247.         {
  248.  
  249.             cout << "vliza v empty" << endl;
  250.  
  251.             flagPrint = 0;
  252.             if(p->next==NULL)
  253.             {
  254.                 whileLoop = 0;
  255.                 cout << "if p->next==NULL" << endl;
  256.                 //traverseListEmployed(p->next);
  257.  
  258.             }
  259.             else
  260.             {
  261.             //    cout << "end list" << endl;
  262.             }
  263.         }
  264.         else
  265.         {
  266.             flagPrint = 1;
  267.         }
  268.     }
  269.  
  270.     while(whileLoop)
  271.     {
  272.         if(p)
  273.         {
  274.             int stackElements = stackNumberOfElements();
  275.             if(flagPrint)
  276.                 cout << " " << p->data << endl;//<< "stack number of elements" << stackElements << endl;
  277.             if(!flagPrint)
  278.                 cout << "!" << p->data << endl;//<< "stack number of elements" << stackElements << endl;
  279.  
  280.            // printStack();
  281.  
  282.         }
  283.         if(p->child && p->next)
  284.         {
  285.           //  cout << "insert stack p->next " << p->next->data << endl;
  286.             insertStack(p->next);
  287.             traverseListEmployed(p->child);
  288.             break;
  289.         }
  290.         if(p->child)
  291.         {
  292.             traverseListEmployed(p->child);
  293.             break;
  294.  
  295.         }
  296.         if(p->next)
  297.         {
  298.             traverseListEmployed(p->next);
  299.             break;
  300.         }
  301.         if(top == NULL)
  302.         {
  303.             //cout << "top == NULL p->data " << p->data << endl;
  304.  
  305.         }
  306.  
  307.         if(p->next == NULL && p->child == NULL && top!=NULL)
  308.         {
  309.            cout << "print stack before pop: ";
  310.             printStack();
  311.             cout << endl;
  312.             p = popStack();
  313.             cout << "p popped --------------------------------------------" << p->data << endl;
  314.             cout << "print stack after pop: ";
  315.             printStack();
  316.             cout << endl;
  317.             traverseListEmployed(p);
  318.             break;
  319.         }
  320.         if(p->next == NULL && p->child == NULL)
  321.         {
  322.             cout <<" p->next == NULL && p->child == NULL " << endl;
  323.             break;
  324.         }
  325.         else
  326.         {
  327.             break;
  328.         }
  329.     }
  330.     }
  331. }
  332.  
  333.  
  334. void insertStack(struct Node *p)
  335. {
  336.     if(top == NULL)
  337.     {
  338.         top = new StackNode;
  339.         top->data = p;
  340.         top->next = NULL;
  341.     }
  342.     else
  343.     {
  344.         StackNode *t = new StackNode;
  345.         t->data = p;
  346.         t->next = top;
  347.         top = t;
  348.     }
  349. }
  350.  
  351. int stackNumberOfElements()
  352. {
  353.     int countStack = 0;
  354.     StackNode *p = top;
  355.     while(p)
  356.     {
  357.         p = p->next;
  358.         countStack++;
  359.     }
  360.     return countStack;
  361. }
  362.  
  363. struct Node* popStack()
  364. {
  365.     struct StackNode *p;
  366.     struct Node* t;
  367.     p = top;
  368.     t = top->data;
  369.     top = top->next;
  370.     delete p;
  371.     return t;
  372.  
  373.  
  374. }
  375.  
  376. void printStack()
  377. {
  378.     struct StackNode *p = top;
  379.  //   cout << "Printing the stack with elements : " << stackNumberOfElements() << " | ";
  380.     while(p!=NULL)
  381.     {
  382.         cout << p->data->data << " ";
  383.         p = p->next;
  384.     }
  385.     cout << endl;
  386. }
  387.  
RAW Paste Data Copied