Advertisement
Shahd_Elmeniawy

Linked list

Jan 31st, 2025
69
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 3.54 KB | None | 0 0
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. class node{
  6.     public:
  7.     int data;
  8.     node* next;
  9.     node(int x = 0){
  10.         data = x;
  11.         next = nullptr;
  12.     }
  13. };
  14.  
  15. class linkedList{
  16.     node* head;
  17.     public:
  18.     linkedList(){
  19.         head = nullptr;
  20.     }
  21.  
  22.     void AddElement(int x){
  23.         node *newnode = new node(x);
  24.         if(head == nullptr){
  25.             head = newnode;
  26.         }else{
  27.             node *curr = head;
  28.             while(curr->next != nullptr){
  29.                 curr = curr->next;
  30.             }
  31.             curr -> next = newnode;
  32.         }
  33.     }
  34.  
  35.     void PopListBack(){
  36.         node *curr = head;
  37.         if(curr -> next == nullptr){
  38.             delete curr;
  39.         }else{
  40.             while(curr->next ->next != nullptr){
  41.                 curr = curr -> next;
  42.             }
  43.             delete curr->next;
  44.             curr ->next = nullptr;
  45.         }
  46.     }
  47.  
  48.     void printList(){
  49.         node *curr = head;
  50.         while(curr != nullptr){
  51.             cout << curr->data << " ";
  52.             curr = curr->next;
  53.         }
  54.         cout << endl;
  55.     }
  56.  
  57.     void removeAt(int index){
  58.         if(index == 0){
  59.             node *deletenode = head;
  60.             head = head -> next;
  61.             delete deletenode;
  62.         }else{
  63.             int cnt = 0;
  64.             node *curr = head;
  65.             while(curr && curr -> next ){
  66.                 cnt++;
  67.                 if(cnt == index){
  68.                     node* deletenode = curr -> next;
  69.                     curr -> next = curr -> next -> next;
  70.                     deletenode -> next = nullptr;
  71.                     delete deletenode;
  72.                    
  73.                 }
  74.                 curr = curr -> next;
  75.             }
  76.         }
  77.     }
  78.  
  79.     void addat(int index, int x){
  80.         node* newnode = new node(x);
  81.         if(index == 0){
  82.             newnode-> next = head;
  83.             head = newnode;
  84.         }else{
  85.             int cnt = 0;
  86.             node* curr = head;
  87.             bool ok = 0;
  88.             while(curr -> next){
  89.                 cnt++;
  90.                 if(cnt == index){
  91.                     node *Next = curr -> next;
  92.                     newnode -> next = Next;
  93.                     curr->next = newnode;
  94.                     ok = 1;
  95.                 }
  96.                 curr = curr -> next;
  97.                
  98.             }
  99.             if(!ok){
  100.                 curr -> next = newnode;
  101.             }
  102.  
  103.         }
  104.     }
  105.  
  106.  
  107.     int size(){
  108.         node *curr = head;
  109.         int cnt = 0;
  110.         while(curr != nullptr){
  111.             cnt++;
  112.             curr = curr->next;
  113.         }
  114.         return cnt;
  115.     }
  116.  
  117.     ~linkedList(){
  118.         node *curr = head;
  119.         while(curr != nullptr){
  120.             node* Next = curr->next;
  121.             delete curr;
  122.             curr = Next;
  123.         }
  124.     }
  125.  
  126. };
  127.  
  128.  
  129. int32_t main(){
  130.    linkedList l;
  131.    cout << "Add element 1 \n";
  132.    l.AddElement(1);
  133.    l.printList();
  134.    cout << "Add element 2 \n";
  135.    l.AddElement(2);
  136.    l.printList();
  137.    cout << "Add element 7 \n";
  138.    l.AddElement(7);
  139.    l.printList();
  140.    cout << "Add element 8 \n";
  141.    l.AddElement(8);
  142.    l.printList();
  143.    cout << "Remove the last element\n";
  144.    l.PopListBack();
  145.    l.printList();
  146.    cout << "Add element 10\n";
  147.    l.AddElement(10);
  148.    l.printList();
  149.    cout << "Add element 3 at position of index 2\n";
  150.    l.addat(2, 3);
  151.    l.printList();
  152.    cout << "Remove element that have index 3\n";
  153.    l.removeAt(3);
  154.    l.printList();
  155.    cout << "Size of linked list\n";
  156.    cout << l.size() << endl;
  157.    
  158. }
  159.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement