Add files via upload

This involves the basic data structures used in java😁

Author: Mmabiaa

DSA/DynamicArray.java

@@ -0,0 +1,70 @@
+public class DynamicArray {
+    int size, capacity = 10;
+    Object[] array;
+
+    public DynamicArray() {
+        this.capacity = capacity;
+        this.array = new Object[capacity];
+    }
+
+    public  void add(Object data){
+        if (size >= capacity){
+            grow();
+        }
+        array[size] = data;
+        size++;
+    }
+    public void insert(int index, Object data){
+        if(size >= capacity){
+            grow();
+        }
+        for(int i = size; i > index; i--){
+            array[i] = array[i - 1];
+        }
+        array[index] = data;
+        size++;
+    }
+    public void delete(Object data){
+        for(int i = 0; i < size; i++){
+            if(array[i] == data){
+                for(int j = 0; j < (size - i - 1); j++){
+                    array[i + j] = array[i + j + 1];
+                }
+                array[size - 1] = null;
+                size--;
+                if(size <= (int)(capacity/3)){
+                    shrink();
+                }
+                break;
+            }
+    }
+}
+    public int search(Object data){
+        return -1;
+    }
+
+    private void grow(){
+
+    }
+    private void shrink(){
+
+    }
+    public boolean isEmpty(){
+        return size == 0;
+    }
+
+    public String toString(){
+        String string = "";
+
+        for (int i =0; i < capacity; i++){
+            string += array[i] + ", ";
+        }
+        if(string != ""){
+            string = "["+string.substring(0, string.length() - 2) + "]";
+        }
+        else{
+            string = "[]";
+        }
+        return string;
+    }
+}

DSA/Main.java

@@ -0,0 +1,17 @@
+public class Main {
+    public static void main(String[] args) {
+        DynamicArray dynamicArray = new DynamicArray();
+
+        dynamicArray.add("A");
+        dynamicArray.add("B");
+        dynamicArray.add("C");
+
+        dynamicArray.insert(9, "D");
+        dynamicArray.delete("A");
+
+        System.out.println(dynamicArray);
+        System.out.println("size: "+dynamicArray.size);
+        System.out.println("capacity: "+dynamicArray.capacity);
+        System.out.println("Empty: "+dynamicArray.isEmpty());
+    }
+}

DSA/Main_ArrayList.java

@@ -0,0 +1,29 @@
+import java.util.*;
+
+public class Main_ArrayList{
+
+//Class method for the ArrayList.
+
+
+
+    public static void main(String[] args) {
+       //ArrayList variable.
+       ArrayList <Integer> array = new ArrayList<>(List.of(10, 20, 30, 40, 50));
+
+       //Listing elements at index
+       System.out.println("Elements at index 0:" + array.get(0));
+       System.out.println("Elements at index 2:" + array.get(20));
+       System.out.println("Elements at index 4:" + array.get(4));
+
+        int Sum = array.stream().mapToInt(Integer::intValue).sum();
+        System.out.println("Sum of the ArrayList elements:" + Sum);
+
+        array.set(2, 35);
+        System.out.println("Updated elements at index 2:" + array.get(2));
+
+        System.out.println("Elements in the ArrayList: ");
+        for(int element: array){
+            System.out.println(element);
+        }
+    }
+}

DSA/Main_Queue.java

@@ -0,0 +1,90 @@
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+/*
+            * Queue - FIFO Data Structure. First-In First-Out.
+                        A collection design for holding elements prior to processing
+                        Linear data structures.
+
+            *Dequeue - Removing queued elements, .poll();
+            *Enqueue - Adding queued elements, .offer();
+       */
+    
+
+public class Main_Queue {
+
+    //Queue_ method.
+    public void Queue_(){
+    Queue <String> queue = new LinkedList<String>(); // Queue is an interface not a class.
+
+        // Adding queue elements
+        queue.offer("Karen");
+        queue.offer("Chad");
+        queue.offer("Steve");
+        queue.offer("Harold");
+
+        //Removing queue elements
+        queue.poll();
+
+        //To see the number of people present in the queue
+        System.out.println(queue.size());
+
+        //To see if an element is present in the queue
+        System.out.println(queue.contains("Chad"));
+}
+
+    //Linked_LIst method
+    public void Linked_List(){
+        LinkedList<String> linkedList = new LinkedList<String>();
+        /*
+         As Stack
+         linkedList.push("A");
+        linkedList.push("C");
+        linkedList.push("S");
+        linkedList.push("X");
+         */
+
+         //As Queue
+         linkedList.offer("A");
+        linkedList.offer("C");
+        linkedList.offer("S");
+        linkedList.offer("X");
+
+        //Adding and removing items
+        linkedList.add(3,"E");
+        linkedList.remove(4);
+
+        linkedList.addFirst("0");//Adding an item to the first
+        linkedList.addLast("G");//Adding an item to the last
+        String first = linkedList.removeFirst(); //Removing the first item
+        String last = linkedList.removeLast();    //Removing the last item.
+
+        //Peek
+        System.out.println(linkedList.peekFirst()); // To see first item
+        System.out.println(linkedList.peekLast()); //  To see last item
+
+        //Output of new stack.
+        System.err.println(linkedList);
+    }
+
+    //Priority_Queue method.
+    public void Priority_Queue(){//Higher priority are served first before lower ones.
+        Queue<String> queue = new PriorityQueue<>();
+        queue.offer("B");
+        queue.offer("C");
+        queue.offer("A");
+        queue.offer("D");
+        queue.offer("F");
+
+        //output
+
+        while(!(queue.isEmpty())){
+            System.out.println(queue.poll());
+        }
+    }
+    public static void main(String[] args) {
+       Main_Queue q = new Main_Queue();
+       q.Linked_List();
+        //q.Priority_Queue();
+    }
+}