SHARE
TWEET

Untitled

a guest Feb 21st, 2019 55 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <string>
  4. using namespace std;
  5.  
  6. class Node
  7. {
  8. public:
  9.         string isim;
  10.         string soyIsim;
  11.         string bolumu;
  12.         int ogrenciNumarasi;
  13.         Node* next;
  14.        
  15. };
  16. class List {
  17. public:
  18.         List(void) { head = NULL; };     // constructor
  19.         ~List(void){};                          // destructor
  20.  
  21.         bool IsEmpty() { return head == NULL; }
  22.         Node* InsertNode(int index, string isim,string soyIsim,string bolumu,int ogrenciNumarasi);  
  23.         int FindNode(int ogrenciNumarasi);    
  24.         int DeleteNode(int ogrenciNumarasi);
  25.         void DisplayList(void);
  26.         Node* getListHead()
  27.         {
  28.             return head;
  29.         }
  30. private:
  31.         Node* head;
  32.         friend class Stack;
  33. };
  34. Node* List::InsertNode(int index, string isim,string soyIsim,string bolumu,int ogrenciNumarasi)
  35. {
  36.         if (index < 0) return NULL;    
  37.        
  38.         int currIndex   =       1;
  39.         Node* currNode  =       head;
  40.         while (currNode && index > currIndex) {
  41.                 currNode        =       currNode->next;
  42.                 currIndex++;
  43.         }
  44.         if (index > 0 && currNode == NULL) return NULL;
  45.        
  46.         Node* newNode   =       new     Node;
  47.         newNode->isim   =       isim;
  48.         newNode->soyIsim        =       soyIsim;
  49.         newNode->bolumu   =       bolumu;
  50.         newNode->ogrenciNumarasi        =       ogrenciNumarasi;
  51.         if (index == 0) {
  52.                 newNode->next   =       head;
  53.                 head            =       newNode;
  54.         }
  55.         else {
  56.                 newNode->next   =       currNode->next;
  57.                 currNode->next  =       newNode;
  58.         }
  59.         return newNode;
  60. }
  61. int List::FindNode(int ogrenciNumarasi) {
  62.         Node* currNode  =   head;
  63.     int currIndex   =   1;
  64.     while (currNode && currNode->ogrenciNumarasi != ogrenciNumarasi) {
  65.         currNode    =   currNode->next;
  66.         currIndex++;
  67.     }
  68.     if (currNode) return currIndex;
  69.     return 0;
  70. }
  71.  
  72.  
  73. int List:: DeleteNode(int ogrenciNumarasi){
  74.         Node* prevNode  =   NULL;
  75.     Node* currNode  =   head;
  76.     int currIndex   =   1;
  77.     while (currNode && currNode->ogrenciNumarasi != ogrenciNumarasi) {
  78.         prevNode    =   currNode;
  79.         currNode    =   currNode->next;
  80.         currIndex++;
  81.     }
  82.     if (currNode) {
  83.         if (prevNode) {
  84.             prevNode->next  =   currNode->next;
  85.             delete currNode;
  86.         }
  87.         else {
  88.             head        =   currNode->next;
  89.             delete currNode;
  90.         }
  91.         return currIndex;
  92.     }
  93.     return 0;
  94. };
  95.  
  96.  
  97. void List::DisplayList()
  98. {
  99.    int num              =       0;
  100.    Node* currNode       =       head;
  101.    while (currNode != NULL){
  102.         cout << currNode->ogrenciNumarasi <<":";
  103.         cout << currNode->isim <<  " ";
  104.         cout << currNode->soyIsim <<" ";
  105.         cout << currNode->bolumu<<endl ;
  106.         currNode        =       currNode->next;
  107.         num++;
  108.    }
  109.    cout << "Number of nodes in the list: " << num << endl;
  110. }
  111. class Stack : public List {
  112. public:
  113.         Stack() {};      // constructor
  114.         ~Stack() {};     // destructor
  115.         double Top() {
  116.                 if (head == NULL) {
  117.                         cout << "Error: the stack is empty." << endl;
  118.                         return -1;
  119.                 }
  120.                 else
  121.                         return head->ogrenciNumarasi;
  122.         }
  123.         void Push(string isim,string soyIsim,string bolumu,int ogrenciNumarasi) { InsertNode(0,isim,soyIsim,bolumu,ogrenciNumarasi); }
  124.         double Pop() {
  125.                 if (head == NULL) {
  126.                         cout << "Error: the stack is empty." << endl;
  127.                         return -1;
  128.                 }
  129.                 else {
  130.                         int val = head->ogrenciNumarasi;
  131.                         DeleteNode(val);
  132.                         return val;
  133.                 }
  134.         }
  135.         void DisplayStack()
  136.         {
  137.                 DisplayList();
  138.         }
  139.         Node* getHead()
  140.         {
  141.             return head;
  142.         }
  143. };
  144. class Queue {
  145. public:
  146.     Queue() {       // constructor
  147.         front = rear = NULL;
  148.         counter = 0;
  149.     };     
  150.     ~Queue() {      // destructor
  151.         int value;
  152.         while (!IsEmpty()) Dequeue(value);
  153.     };
  154.     bool IsEmpty() {
  155.         if (counter)    return false;
  156.         else            return true;
  157.     }
  158.     void Enqueue(string isim,string soyIsim,string bolumu,int ogrenciNumarasi);
  159.     bool Dequeue(int & ogrenciNumarasi);
  160.     int getCounter();
  161.     void DisplayQueue(void);
  162.     Node* getFront()
  163. {
  164.     return front;
  165. }
  166. private:
  167.     Node* front;    // pointer to front node
  168.     Node* rear; // pointer to last node
  169.     int counter;    // number of elements
  170. };
  171. void Queue::Enqueue(string isim,string soyIsim,string bolumu,int ogrenciNumarasi) {
  172.     Node* newNode   =   new Node;
  173.     newNode->isim   =   isim;
  174.     newNode->soyIsim    =   soyIsim;
  175.     newNode->bolumu =   bolumu;
  176.     newNode->ogrenciNumarasi    =   ogrenciNumarasi;
  177.     newNode->next   =   NULL;
  178.     if (IsEmpty()) {
  179.         front       =   newNode;
  180.         rear        =   newNode;
  181.     }
  182.     else {
  183.         rear->next  =   newNode;
  184.         rear        =   newNode;
  185.     }
  186.     counter++;
  187. }
  188. bool Queue::Dequeue(int & ogrenciNumarasi) {   
  189.     if (IsEmpty()) {
  190.         cout << "Error: the queue is empty." << endl;
  191.         return false;
  192.     }
  193.     else {
  194.         ogrenciNumarasi         =   front->ogrenciNumarasi;
  195.         Node* nextNode  =   front->next;
  196.         delete front;
  197.         front           =   nextNode;
  198.         counter--;
  199.     }
  200. }
  201. void Queue::DisplayQueue() {
  202.     cout << "front -->";
  203.     Node* currNode  =   front;
  204.     for (int i = 0; i < counter; i++) {
  205.         if (i == 0) cout << "\t";
  206.         else        cout << "\t\t";
  207.         cout << currNode->ogrenciNumarasi << ":";
  208.         cout << currNode->isim<< " ";
  209.         cout << currNode->soyIsim << " ";
  210.         cout << currNode->bolumu << endl;
  211.         if (i != counter - 1)
  212.             cout << endl;
  213.         else
  214.             cout << "\t<-- rear" << endl;
  215.         currNode    =   currNode->next;    
  216.     }
  217. }
  218. int Queue::getCounter()
  219. {
  220.     return counter;
  221. }
  222. void HerIkidersiAlanlar(Stack,Queue);
  223. void grubaAyir(Stack);
  224. void yalnizMat(Stack,Queue);
  225. void bilgisayarOgr(Stack,Queue);
  226. void veriYapılariOgrAl(Stack*);
  227. void MatematikOgrAl(Queue*);
  228. int main(void)
  229. {
  230.         Stack veriYapılari;
  231.         Queue matematik;
  232.         int secim;
  233.  
  234.         cout<<"\n Menu";
  235.         cout<<"\n========";
  236.         cout<<"\n 1-Veri Yapilari Dersine Ogrenci Kaydet";
  237.         cout<<"\n 2-Matematik Dersine Ogrenci Kaydet";
  238.         cout<<"\n 3-Her Iki Dersi Alan Ogrencileri Goster";
  239.         cout<<"\n 4-Sadece Matematik Dersi Alan Ogrencileri Goster";
  240.         cout<<"\n 5-Veri Yapilari Ogrenci Numarasina Gore 2'ye Ayir ve Goster";
  241.         cout<<"\n 6-Iki Dersten En Az Birini Alan Bilgisayar Muhendisligi Ogrencilerini Goster";
  242.         cout<<"\n 7-Isimleri Ayni Soyisimleri Farkli Olan Ogrencileri Goster";
  243.         cout<<"\n Secimi Girin: ";
  244.         cin>>secim;
  245.  
  246.         switch (secim)
  247.         {
  248.         case 1:{veriYapılariOgrAl(&veriYapılari);}
  249.                 break;
  250.         case 2:{MatematikOgrAl(&matematik);}
  251.                 break;
  252.         case 3:{HerIkidersiAlanlar(veriYapılari,matematik);}
  253.                 break;
  254.         case 4:{yalnizMat(veriYapılari,matematik);}
  255.                 break;
  256.         case 5:{grubaAyir(veriYapılari);}
  257.                 break;
  258.         case 6:{bilgisayarOgr(veriYapılari,matematik);}
  259.                 break;
  260.         case 7:
  261.  
  262.         default: cout<< "Bilinmeyen Secim";
  263.         }
  264.        
  265.         /*veriYapılari.Push("Arda","Turan","Bilgisayar",14);
  266.         veriYapılari.Push("Nuri","Sahin","Makina",20);
  267.         veriYapılari.Push("Emre","Belozoglu","Ebelik",5);
  268.         veriYapılari.Push("Volkan","Demirel","İnşaat",1);*/
  269.        
  270.         //veriYapılari.DisplayStack();
  271.        
  272.         /*matematik.Enqueue("Selcuk","Inan","Bilgisayar",8);
  273.         matematik.Enqueue("Arda","Turan","Bilgisayar",14);
  274.         matematik.Enqueue("Ömer","Toprak","Bilgisayar",3);*/
  275.         //matematik.DisplayQueue();
  276.         //grubaAyir(veriYapılari);
  277.         //yalnizMat(veriYapılari,matematik);
  278.         //cout<<endl;
  279.         //HerIkidersiAlanlar(veriYapılari,matematik);
  280.         bilgisayarOgr(veriYapılari,matematik);
  281.         system("PAUSE");
  282.         return 0;
  283.            
  284. }
  285. void yalnizMat(Stack x,Queue y)
  286. {
  287.     bool isMat = true;
  288.     int counter = y.getCounter();
  289.     Stack yalnizMatematik;
  290.     Node* currNode1 = y.getFront();
  291.     for(int i = 0; i< counter; i++){
  292.         isMat=true;
  293.         Node* currNode = x.getHead();
  294.         while(currNode)
  295.        
  296.     {
  297.             if(currNode->ogrenciNumarasi == currNode1->ogrenciNumarasi  )
  298.         {
  299.                 isMat=false;
  300.            
  301.         }
  302.             currNode = currNode->next;
  303.         }
  304.             if(isMat == true)
  305.             {
  306.                 yalnizMatematik.Push(currNode1->isim,currNode1->soyIsim,currNode1->bolumu,currNode1->ogrenciNumarasi);
  307.                
  308.             }
  309.            
  310.             currNode1 = currNode1->next;
  311.         }
  312.         yalnizMatematik.DisplayList();
  313. }
  314. void grubaAyir(Stack x)
  315. {
  316.     Stack A_grubu;
  317.     Stack B_grubu;
  318.     Node* currNode =x.getHead();
  319.     while (currNode)
  320.     {
  321.         if(currNode->ogrenciNumarasi % 2 == 0)
  322.         {
  323.             B_grubu.Push(currNode->isim,currNode->soyIsim,currNode->bolumu,currNode->ogrenciNumarasi);
  324.         }
  325.         else
  326.         {
  327.             A_grubu.Push(currNode->isim,currNode->soyIsim,currNode->bolumu,currNode->ogrenciNumarasi);
  328.         }
  329.         currNode = currNode->next;
  330.    
  331.     }
  332.     cout <<"A grubu (Tekler)"<<endl;
  333.     A_grubu.DisplayList();
  334.     cout<<endl;
  335.     cout <<"B grubu (Ciftler)"<<endl;
  336.     B_grubu.DisplayList();
  337. }
  338. void HerIkidersiAlanlar(Stack x,Queue y)
  339. {
  340.    
  341.     int counter = y.getCounter();
  342.     Stack IkiDersiAlan;
  343.     Node* currNode1 = y.getFront();
  344.     for(int i = 0; i< counter; i++){
  345.    
  346.         Node* currNode = x.getHead();
  347.         while(currNode)
  348.        
  349.     {
  350.             if(currNode->ogrenciNumarasi == currNode1->ogrenciNumarasi  )
  351.         {
  352.                 IkiDersiAlan.Push(currNode1->isim,currNode1->soyIsim,currNode1->bolumu,currNode1->ogrenciNumarasi);
  353.            
  354.         }
  355.             currNode = currNode->next;
  356.         }
  357.            
  358.            
  359.             currNode1 = currNode1->next;
  360.         }
  361.     IkiDersiAlan.DisplayList();
  362. }
  363. void bilgisayarOgr(Stack x,Queue y)
  364. {
  365.        
  366.         Node* currNode = x.getHead();
  367.         Node* currNode1 = y.getFront();
  368.         int counter = y.getCounter();
  369.         Stack bilgisayarOgrencileri;
  370.        
  371.           while(currNode)
  372.         {
  373.                 if(currNode->bolumu == "Bilgisayar" )
  374.                 {
  375.                     bilgisayarOgrencileri.Push(currNode->isim,currNode->soyIsim,currNode->bolumu,currNode->ogrenciNumarasi);
  376.                 }
  377.                 currNode = currNode->next;
  378.         }
  379.        
  380.         for(int i =0; i < counter; i++)
  381.         {
  382.                 if(currNode1->bolumu == "Bilgisayar")
  383.                 {
  384.                     bilgisayarOgrencileri.Push(currNode1->isim,currNode1->soyIsim,currNode1->bolumu,currNode1->ogrenciNumarasi);
  385.                      
  386.                 }
  387.                
  388.                 currNode1 = currNode1->next;
  389.         }
  390.      
  391.        
  392.         bilgisayarOgrencileri.DisplayList();
  393. }
  394. void veriYapılariOgrAl(Stack* x)
  395. {
  396.     char isim[20];
  397.     char Soyisim[20];
  398.     char bolum[20];
  399.     int ogrenciNumarasi;
  400.     cout << "Ismi girin:";
  401.     gets(isim);
  402.     cout << endl;
  403.     cout << "Soyadini girin:";
  404.     gets(Soyisim);
  405.     cout << endl;
  406.     cout << "Bolumu girin:";
  407.     gets(bolum);
  408.     cout << endl;
  409.     cout << "Ogrenci Numarasini girin:";
  410.     cin >> ogrenciNumarasi;
  411.     x->Push(isim,Soyisim,bolum,ogrenciNumarasi);
  412. }
  413. void MatematikOgrAl(Queue* y)
  414. {
  415.     char isim[10];
  416.     char Soyisim[10];
  417.     char bolum[10];
  418.     int ogrenciNumarasi;
  419.     cout << "Ismi girin:";
  420.     gets(isim);
  421.     cout << endl;
  422.     cout << "Soyadini girin:";
  423.     gets(Soyisim);
  424.     cout << endl;
  425.     cout << "Bolumu girin:";
  426.     gets(bolum);
  427.     cout << endl;
  428.     cout << "Ogrenci Numarasini girin:";
  429.     cin >> ogrenciNumarasi;
  430.     y->Enqueue(isim,Soyisim,bolum,ogrenciNumarasi);
  431. }
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
 
Top