Advertisement
ChiragLulla

Untitled

Jul 21st, 2022
35
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 3.06 KB | None | 0 0
  1. class MyLinkedList {
  2.    
  3.     Node head;
  4.     int size = 0;
  5.    
  6.     static class Node {
  7.         int val;
  8.         Node next;
  9.        
  10.         public Node() {}
  11.         public Node(int val) {
  12.             this.val = val;
  13.         }
  14.         public Node(int val, Node next) {
  15.             this.val = val;
  16.             this.next = next;
  17.         }
  18.     }
  19.  
  20.     public MyLinkedList() {
  21.         this.head = new Node();
  22.         this.size = 0;
  23.     }
  24.    
  25.     public int get(int index) {
  26.         if(size == 0) return -1;
  27.         int idx = 0;
  28.         Node temp = head;
  29.         while(temp != null) {
  30.             if(idx == index) return temp.val;
  31.             idx++;
  32.             temp = temp.next;
  33.         }
  34.         // print();
  35.         return -1;
  36.     }
  37.    
  38.     public void addAtHead(int val) {
  39.         if(size == 0) head.val = val;
  40.         else{
  41.             Node temp = head;
  42.             head = new Node(val);
  43.             head.next = temp;
  44.         }
  45.         size++;
  46.         // print();
  47.     }
  48.    
  49.     public void addAtTail(int val) {
  50.         if(size == 0) {
  51.             addAtHead(val);
  52.             return;
  53.         }
  54.         Node newNode = new Node(val);
  55.         Node temp = head;
  56.         while(temp.next != null) {
  57.             temp = temp.next;
  58.         }
  59.         temp.next = newNode;
  60.         size++;
  61.         // print();
  62.     }
  63.    
  64.     public void addAtIndex(int index, int val) {
  65.         if(index > 0 && size == 0) {
  66.             return;
  67.         }
  68.         if(index == 0 || size == 0) {
  69.             addAtHead(val);
  70.             return;
  71.         }
  72.         if(index > size-1) {
  73.             addAtTail(val);
  74.             return;
  75.         }
  76.         Node newNode = new Node(val);
  77.         Node temp = head;
  78.         int idx = 0;
  79.         while(temp != null && idx != index-1) {
  80.             idx++;
  81.             temp = temp.next;
  82.         }
  83.  
  84.         if(temp == null) {
  85.             addAtTail(val);
  86.             return;
  87.         }
  88.  
  89.         Node old = temp.next;
  90.         temp.next = newNode;
  91.         newNode.next = old;
  92.         size++;
  93.         // print();
  94.     }
  95.    
  96.     public void deleteAtIndex(int index) {
  97.         if(index > size-1) {
  98.             return;
  99.         }
  100.         if(index == 0) {
  101.             head = head.next;
  102.             return;
  103.         }
  104.         int idx = 0;
  105.         Node temp = head;
  106.         while(temp != null && idx != index-1) {
  107.             idx++;
  108.             temp = temp.next;
  109.         }
  110.        
  111.         if(temp != null && temp.next != null) temp.next = temp.next.next;
  112.         size--;
  113.         // print();
  114.     }
  115.    
  116.     // public void print() {
  117.     //     Node temp = head;
  118.     //     while(temp != null) {
  119.     //         System.out.print(temp.val + " ");
  120.     //         temp = temp.next;
  121.     //     }
  122.     //     System.out.println("Size:" +  this.size);
  123.     // }
  124. }
  125.  
  126. /**
  127.  * Your MyLinkedList object will be instantiated and called as such:
  128.  * MyLinkedList obj = new MyLinkedList();
  129.  * int param_1 = obj.get(index);
  130.  * obj.addAtHead(val);
  131.  * obj.addAtTail(val);
  132.  * obj.addAtIndex(index,val);
  133.  * obj.deleteAtIndex(index);
  134.  */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement