jzh4n

Kejuaraan (Multi LinkedList)

May 25th, 2020
1,321
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <string>
  3. #include <stdio.h>
  4.  
  5. template <typename T>
  6. struct LinkedList {
  7.     struct Node {
  8.         T data;
  9.         Node *next;
  10.         Node *prev;
  11.  
  12.         Node() {
  13.             next = nullptr;
  14.             prev = nullptr;
  15.         }
  16.     };
  17.  
  18.     Node *head;
  19.     Node *tail;
  20.  
  21.     LinkedList() {
  22.         head = nullptr;
  23.         tail = nullptr;
  24.     }
  25.  
  26.     void pushBack(T node) {
  27.         if(head == nullptr) {
  28.             head = new Node;
  29.             head->data = node;
  30.             tail = head;
  31.         } else {
  32.             Node *new_node = new Node;
  33.             new_node->data = node;
  34.             tail->next = new_node;
  35.             new_node->prev = tail;
  36.             tail = new_node;
  37.         }
  38.     }
  39.  
  40.     void pushFront(T node) {
  41.         if(head == nullptr) {
  42.             head = new Node;
  43.             head->data = node;
  44.             tail = head;
  45.         } else {
  46.             Node *new_node = new Node;
  47.             new_node->data = node;
  48.             head->prev = new_node;
  49.             new_node->next = head;
  50.             head = new_node;
  51.         }
  52.     }
  53.  
  54.     void popBack() {
  55.         if(head == nullptr) return;
  56.  
  57.         Node *temp = tail;
  58.         tail = tail->prev;
  59.  
  60.         delete temp;
  61.  
  62.         if(tail == nullptr) head = nullptr;
  63.     }
  64.  
  65.     void popFront() {
  66.         if(head == nullptr) return;
  67.  
  68.         Node *temp = head;
  69.         head = head->next;
  70.  
  71.         delete temp;
  72.  
  73.         if(head == nullptr) tail = nullptr;
  74.     }
  75.  
  76.     void remove(T node) {
  77.         Node *temp = head;
  78.         bool flag = false;
  79.  
  80.         while(temp != nullptr) {
  81.             if(temp->data == node) {
  82.                 flag = true;
  83.  
  84.                 break;
  85.             }
  86.            
  87.             temp = temp->next;
  88.         }
  89.  
  90.         if(flag) {
  91.             temp->prev->next = temp->next;
  92.             temp->next->prev = temp->prev;
  93.         }
  94.     }
  95.  
  96.     bool isInList(T node) {
  97.         Node *temp = head;
  98.  
  99.         while(temp != nullptr) {
  100.             if(temp->data == node) {
  101.                 return true;
  102.             }
  103.            
  104.             temp = temp->next;
  105.         }
  106.  
  107.         return false;
  108.     }
  109.  
  110.     Node *getNode(T node) {
  111.         Node *temp = head;
  112.  
  113.         while(temp != nullptr) {
  114.             if(temp->data == node) {
  115.                 return temp;
  116.             }
  117.            
  118.             temp = temp->next;
  119.         }
  120.  
  121.         return nullptr;
  122.     }
  123. };
  124.  
  125. struct Peserta;
  126.  
  127. struct Kejuaraan {
  128.     std::string nama;
  129.     std::string jenis;
  130.  
  131.     void setPeserta(LinkedList<Peserta>::Node *node) {
  132.         if(!peserta.isInList(node))
  133.             peserta.pushBack(node);
  134.     }
  135.  
  136.     LinkedList<LinkedList<Peserta>::Node *> getPeserta() {
  137.         return peserta;
  138.     }
  139.  
  140.     bool operator==(Kejuaraan k) {
  141.         if(k.nama == nama and k.jenis == jenis)
  142.             return true;
  143.        
  144.         return false;
  145.     }
  146.  
  147. //private:
  148.     LinkedList<LinkedList<Peserta>::Node *> peserta;
  149. };
  150.  
  151. struct Peserta {
  152.     std::string nama;
  153.     int umur;
  154.     std::string alamat;
  155.  
  156.     void setKejuaraan(LinkedList<Kejuaraan>::Node *node) {
  157.         if(!kejuaraan.isInList(node))
  158.             kejuaraan.pushBack(node);
  159.     }
  160.  
  161.     LinkedList<LinkedList<Kejuaraan>::Node *> getKejuaraan() {
  162.         return kejuaraan;
  163.     }
  164.  
  165.     bool operator==(Peserta p) {
  166.         if(p.nama == nama and p.alamat == alamat and p.umur == umur)
  167.             return true;
  168.        
  169.         return false;
  170.     }
  171.  
  172. //private:
  173.     LinkedList<LinkedList<Kejuaraan>::Node *> kejuaraan;
  174. };
  175.  
  176. void removeKejuaraanNode(Kejuaraan k, LinkedList<Kejuaraan> &daftar_kejuaraan, LinkedList<Peserta> &daftar_peserta) {
  177.     auto *remove_target = daftar_kejuaraan.getNode(k);
  178.  
  179.     // menghapus data kejuaraan yang ada di setiap peserta
  180.     if(remove_target != nullptr) {
  181.         auto *temp = daftar_peserta.head;
  182.  
  183.         for(; temp != nullptr; temp->next) {
  184.             temp->data.getKejuaraan().remove(remove_target);
  185.         }
  186.     }
  187.  
  188.     daftar_kejuaraan.remove(k);
  189. }
  190.  
  191. void removePesertaNode(Peserta p, LinkedList<Kejuaraan> &daftar_kejuaraan, LinkedList<Peserta> &daftar_peserta) {
  192.     auto *remove_target = daftar_peserta.getNode(p);
  193.  
  194.     // menghapus data peserta yang ada di setiap kejuaraan
  195.     if(remove_target != nullptr) {
  196.         auto *temp = daftar_kejuaraan.head;
  197.  
  198.         for(; temp != nullptr; temp->next) {
  199.             temp->data.getPeserta().remove(remove_target);
  200.         }
  201.     }
  202.  
  203.     daftar_peserta.remove(p);
  204. }
  205.  
  206. int main() {
  207.     LinkedList<Peserta> daftar_peserta;
  208.     LinkedList<Kejuaraan> daftar_kejuaraan;
  209.  
  210.     Peserta peserta[] = {
  211.         {"David", 30, "XYZ"},
  212.         {"Laura", 25, "ABC"},
  213.         {"Jessica", 26, "DEF"},
  214.         {"Agus", 35, "GHI"}
  215.     };
  216.     Kejuaraan kejuaraan[] = {
  217.         {"Lari", "Jarak Pendek"},
  218.         {"Bulu Tangkis", "Ganda Putri"},
  219.         {"Bulu Tangkis", "Ganda Putri"},
  220.         {"Lompat", "Lompat Tinggi"}
  221.     };
  222.  
  223.     for(int i = 0; i < 4; ++i) {
  224.         // Peserta peserta;
  225.         // Kejuaraan kejuaraan;
  226.  
  227.         // std::cout << "Nama: ";
  228.         // std::getline(std::cin, peserta.nama);
  229.  
  230.         // std::cout << "Umur: ";
  231.         // std::cin >> peserta.umur;
  232.  
  233.         // fflush(stdin);
  234.  
  235.         // std::cout << "Alamat: ";
  236.         // std::getline(std::cin, peserta.alamat);
  237.  
  238.         // std::cout << "Nama kejuaraan: ";
  239.         // std::getline(std::cin, kejuaraan.nama);
  240.  
  241.         // std::cout << "Jenis kejuaraan: ";
  242.         // std::getline(std::cin, kejuaraan.jenis);
  243.  
  244.         daftar_peserta.pushBack(peserta[i]);
  245.  
  246.         if(!daftar_kejuaraan.isInList(kejuaraan[i])) {
  247.             daftar_kejuaraan.pushBack(kejuaraan[i]);
  248.         }
  249.  
  250.         auto kejuaraan_node = daftar_kejuaraan.getNode(kejuaraan[i]);
  251.         auto peserta_node = daftar_peserta.getNode(peserta[i]);
  252.  
  253.         peserta_node->data.setKejuaraan(kejuaraan_node);
  254.         kejuaraan_node->data.setPeserta(peserta_node);
  255.     }
  256.  
  257.     auto temp = daftar_kejuaraan.head;
  258.  
  259.     while(temp != nullptr) {
  260.         std::cout << temp->data.nama << '\n';
  261.        
  262.         if(temp->data.nama == "Bulu Tangkis") {
  263.             auto temp2 = temp->data.peserta.head;
  264.  
  265.             while(temp2 != nullptr) {
  266.                 std::cout << temp2->data->data.nama << "\n";
  267.  
  268.                 std::cout << "\t\tnext: " << temp2->data->next->data.nama << "\n";
  269.                 std::cout << "\t\tprev: " << temp2->data->prev->data.nama << "\n";
  270.  
  271.                 temp2 = temp2->next;
  272.             }
  273.  
  274.             std::cout << "\n";
  275.         }
  276.  
  277.         temp = temp->next;
  278.     }
  279.  
  280.     return 0;
  281. }
RAW Paste Data