⚡ array queque

EyuCoder · EyuCoder · commit 5e3f8651e915 · 2021-12-30T22:15:01.000+03:00
diff --git a/Data_Structures/Arrays/Array.java b/Data_Structures/Arrays/Array.java
@@ -1,3 +1,5 @@
+package data_structures.arrays;
+
 import java.util.Arrays;
 
 public class Array {
diff --git a/Data_Structures/Arrays/ArrayTest.java b/Data_Structures/Arrays/ArrayTest.java
@@ -1,3 +1,5 @@
+package data_structures.arrays;
+
 public class ArrayTest {
 
     
diff --git a/Data_Structures/Arrays/DynamicArray.java b/Data_Structures/Arrays/DynamicArray.java
@@ -1,4 +1,5 @@
-import java.io.*;
+package data_structures.arrays;
+
 import java.util.*;
 
 public class DynamicArray {
diff --git a/Data_Structures/Arrays/MergeSortedArrays.java b/Data_Structures/Arrays/MergeSortedArrays.java
@@ -1,4 +1,4 @@
-//merge sorted Array
+package data_structures.arrays;//merge sorted Array
 
 class MergeSortedArrays {
 
diff --git a/Data_Structures/Arrays/ReverseLinkedList.java b/Data_Structures/Arrays/ReverseLinkedList.java
@@ -1,4 +1,5 @@
-import java.util.LinkedList;
+package data_structures.arrays;
+
 public class ReverseLinkedList{
 	static Node head;
 
diff --git a/Data_Structures/Arrays/StringPermutation.java b/Data_Structures/Arrays/StringPermutation.java
@@ -1,3 +1,5 @@
+package data_structures.arrays;
+
 /**
  * Time Complexity: O(2n) Linear time
  * Space Complexity: O(1) constant time
diff --git a/Data_Structures/Arrays/TwoSum.java b/Data_Structures/Arrays/TwoSum.java
@@ -1,3 +1,5 @@
+package data_structures.arrays;
+
 import java.util.HashMap;
 import java.util.Map;
 
diff --git a/Data_Structures/hashtables/UniqueCharacter.java b/Data_Structures/hashtables/UniqueCharacter.java
diff --git a/Data_Structures/queues/array_queue/ArrayQueue.java b/Data_Structures/queues/array_queue/ArrayQueue.java
@@ -0,0 +1,59 @@
+package data_structures.queues.array_queue;
+
+import java.util.NoSuchElementException;
+
+public class ArrayQueue {
+
+    private Employee[] queue;
+    private int front;
+    private int back;
+
+    public ArrayQueue(int capacity) {
+        queue = new Employee[capacity];
+    }
+
+    public void add(Employee employee) {
+        if (back == queue.length) {
+            Employee[] newArray = new Employee[2 * queue.length];
+            System.arraycopy(queue, 0, newArray, 0, queue.length);
+            queue = newArray;
+        }
+
+        queue[back] = employee;
+        back++;
+    }
+
+    public Employee remove() {
+        if (size() == 0) {
+            throw new NoSuchElementException();
+        }
+
+        Employee employee = queue[front];
+        queue[front] = null;
+        front++;
+        if (size() == 0) {
+            front = 0;
+            back = 0;
+        }
+
+        return employee;
+    }
+
+    public Employee peek() {
+        if (size() == 0) {
+            throw new NoSuchElementException();
+        }
+
+        return queue[front];
+    }
+
+    public int size() {
+        return back - front;
+    }
+
+    public void printQueue() {
+        for (int i = front; i < back; i++) {
+            System.out.println(queue[i]);
+        }
+    }
+}
diff --git a/Data_Structures/queues/array_queue/Employee.java b/Data_Structures/queues/array_queue/Employee.java
@@ -1,3 +1,5 @@
+package data_structures.queues.array_queue;
+
 public class Employee {
 
     private String firstName;
@@ -62,5 +64,4 @@ public String toString() {
                 ", id=" + id +
                 '}';
     }
-
-}
+}
diff --git a/Data_Structures/queues/array_queue/MyQueue.java b/Data_Structures/queues/array_queue/MyQueue.java
@@ -0,0 +1,28 @@
+package data_structures.queues.array_queue;
+
+public class MyQueue {
+    public static void main(String[] args) {
+
+        Employee janeJones = new Employee("Jane", "Jones", 123);
+        Employee johnDoe = new Employee("John", "Doe", 4567);
+        Employee marySmith = new Employee("Mary", "Smith", 22);
+        Employee mikeWilson = new Employee("Mike", "Wilson", 3245);
+        Employee billEnd = new Employee("Bill", "End", 78);
+
+        ArrayQueue queue = new ArrayQueue(10);
+        queue.add(janeJones);
+        queue.add(johnDoe);
+        queue.add(marySmith);
+        queue.add(billEnd);
+
+        queue.remove();
+        queue.remove();
+
+        queue.add(mikeWilson);
+
+        queue.printQueue();
+        System.out.println("peaking: " + queue.peek());
+        System.out.println("removing: " + queue.remove());
+        System.out.println("peaking: " + queue.peek());
+    }
+}
diff --git a/Main.java b/Main.java
@@ -0,0 +1,6 @@
+public class Main {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}
diff --git a/README.md b/README.md
@@ -1 +1 @@
-# Java Data Structures and Algorithms
+# Java Data Structures and algorithms
diff --git a/algorithms/recursion/Factorial.java b/algorithms/recursion/Factorial.java
@@ -1,5 +1,7 @@
+package algorithms.recursion;
+
 /**
-* time: O(n) Quadratic Time 
+* time: O(n) Linear Time 
 */
 public class Factorial {
 
diff --git a/algorithms/search/BinarySearch.java b/algorithms/search/BinarySearch.java
@@ -1,3 +1,4 @@
+package algorithms.search;
 /**
  * Time Complexity: O(log n) Linear time
  * Space Complexity: O(1) constant time
diff --git a/algorithms/sort/BubbleSort.java b/algorithms/sort/BubbleSort.java
@@ -1,3 +1,4 @@
+package algorithms.sort;
 /**
  * Stable sort
  * time: O(n^2) Quadratic Time
diff --git a/algorithms/sort/CountingSort.java b/algorithms/sort/CountingSort.java
@@ -1,3 +1,5 @@
+package algorithms.sort;
+
 /**
  * UnStable sort implementation
  * time: O(n) Linear Time
diff --git a/algorithms/sort/InsertionSort.java b/algorithms/sort/InsertionSort.java
@@ -1,3 +1,5 @@
+package algorithms.sort;
+
 /**
  * Stable sort
  * time: O(n^2) Quadratic Time
diff --git a/algorithms/sort/MergeSort.java b/algorithms/sort/MergeSort.java
@@ -1,4 +1,4 @@
-/**
+package algorithms.sort; /**
  * Stable sort
  * time: O(nlogn) loglinear complexity
  * not an in-place Algorithm
diff --git a/algorithms/sort/QuickSort.java b/algorithms/sort/QuickSort.java
@@ -1,12 +1,11 @@
-/**
+package algorithms.sort;
+/*
  * UnStable sort
  * time: O(nlogn) loglinear complexity.
  * In the worst case, it makes O(n2) comparisons, though this behavior is rare.
  * in-place Algorithm
  */
 
-import java.util.Arrays;
-
 public class QuickSort {
 
     public static void quickSort(int[] arr, int start, int end) {
diff --git a/algorithms/sort/RadixSort.java b/algorithms/sort/RadixSort.java
@@ -1,3 +1,5 @@
+package algorithms.sort;
+
 /**
  * Stable sort
  * time: O(nw) time, where n is the number of keys, and w is the key length.
@@ -25,11 +27,14 @@ public static void countSort(int[] input, int position, int radix){
             countArray[i] += countArray[i - 1];
         }
 
+        //build the output tempArray
         int[] tempArray = new int[len];
         for (int i = len - 1; i >= 0 ; i--) {
-            tempArray[--countArray[getDigit(position, input[i], radix)]] = input[i];            
+            int tempDigit = getDigit(position, input[i], radix);
+            tempArray[--countArray[tempDigit]] = input[i];            
         }
 
+        //copy array to the original array
         for (int i = 0; i < len; i++) {
             input[i] = tempArray[i];
         }
diff --git a/algorithms/sort/SelectionSort.java b/algorithms/sort/SelectionSort.java
@@ -1,3 +1,5 @@
+package algorithms.sort;
+
 /**
  * UnStable sort
  * time: O(n^2) Quadratic Time
diff --git a/algorithms/sort/ShellSort.java b/algorithms/sort/ShellSort.java
@@ -1,3 +1,5 @@
+package algorithms.sort;
+
 /**
  * UnStable sort
  * time: O(n^2) Quadratic Time(could be better depending on the Gap)
diff --git a/data_structures/hashtables/UniqueCharacter.java b/data_structures/hashtables/UniqueCharacter.java
@@ -0,0 +1,49 @@
+package data_structures.hashtables;/*
+ * Time Complexity: O(n) Linear time
+ * Space Complexity: O(1) constant time
+ **/
+import java.util.HashMap;
+import java.util.Map;
+
+public class UniqueCharacter {
+
+    static boolean isUniqueChars(String str) {
+        if (str.length() > 128) return false;
+        boolean[] charSet = new boolean[128];
+
+        for (int i = 0; i < str.length(); i++) {
+            int val = str.charAt(i);
+            //System.out.println(val + " : " + str.charAt(i) + " : " + charSet[val]);
+            if (charSet[val]) { // Already found this char in string
+                return false;
+            }
+            charSet[val] = true;
+        }
+        return true;
+    }
+
+    static boolean isUniqueChars2(String str) {
+        if (str.length() > 128) return false;
+        Map map = new HashMap<Integer, Boolean>(128);
+
+        for (int i = 0; i < str.length(); i++) {
+            int val = str.charAt(i);
+            //System.out.println(val + " : " + str.charAt(i) + " : " + charSet[val]);
+            if (map.containsKey(val)) { // Already found this char in string
+                return false;
+            }
+            map.put(val, true);
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        // using string boolean
+        System.out.println(isUniqueChars("Joel"));
+        System.out.println(isUniqueChars("jjjj"));
+
+        // using hashMap
+        System.out.println(isUniqueChars2("Joel"));
+        System.out.println(isUniqueChars2("jjjj"));
+    }
+}
diff --git a/data_structures/linked_lists/doubly_linked_list/MyLinkedList.java b/data_structures/linked_lists/doubly_linked_list/MyLinkedList.java
@@ -1,3 +1,5 @@
+package data_structures.linked_lists.doubly_linked_list;
+
 /**
  * insert node at head: O(1) constant time
  * insert node at tail: O(1) constant time
@@ -6,7 +8,7 @@
  * remove node from middle: O(n) Linear time
  * search: O(n) Linear time
  **/
-public class Main{
+public class MyLinkedList{
 
 	public static void main(String[] args) {
 		StudentDoublyLinkedList linkedList = new StudentDoublyLinkedList();
diff --git a/data_structures/linked_lists/doubly_linked_list/StudentDoublyLinkedList.java b/data_structures/linked_lists/doubly_linked_list/StudentDoublyLinkedList.java
@@ -1,3 +1,5 @@
+package data_structures.linked_lists.doubly_linked_list;
+
 public class StudentDoublyLinkedList{
 
 	private StudentNode head;
diff --git a/data_structures/linked_lists/doubly_linked_list/StudentNode.java b/data_structures/linked_lists/doubly_linked_list/StudentNode.java
@@ -1,3 +1,5 @@
+package data_structures.linked_lists.doubly_linked_list;
+
 public class StudentNode{
 	private int grade;
 	private String name;
diff --git a/data_structures/linked_lists/jdk_linked_list/Employee.java b/data_structures/linked_lists/jdk_linked_list/Employee.java
diff --git a/data_structures/linked_lists/jdk_linked_list/MyLinkedList.java b/data_structures/linked_lists/jdk_linked_list/MyLinkedList.java
diff --git a/data_structures/linked_lists/singly_linked_list/MyLinkedList.java b/data_structures/linked_lists/singly_linked_list/MyLinkedList.java
diff --git a/data_structures/linked_lists/singly_linked_list/StudentNode.java b/data_structures/linked_lists/singly_linked_list/StudentNode.java
diff --git a/data_structures/linked_lists/singly_linked_list/StudentSinglyLinkedList.java b/data_structures/linked_lists/singly_linked_list/StudentSinglyLinkedList.java
diff --git a/data_structures/stacks/array_stack/ArrayStack.java b/data_structures/stacks/array_stack/ArrayStack.java
diff --git a/data_structures/stacks/array_stack/MyStack.java b/data_structures/stacks/array_stack/MyStack.java
diff --git a/data_structures/stacks/linked_list_stack/LinkedListStack.java b/data_structures/stacks/linked_list_stack/LinkedListStack.java
diff --git a/data_structures/stacks/linked_list_stack/MyStack.java b/data_structures/stacks/linked_list_stack/MyStack.java
diff --git a/data_structures/stacks/linked_list_stack/Node.java b/data_structures/stacks/linked_list_stack/Node.java

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+package data_structures.arrays;`
	`2`	`+`
`1`	`3`	`import java.util.Arrays;`
`2`	`4`
`3`	`5`	`public class Array {`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+package data_structures.arrays;`
	`2`	`+`
`1`	`3`	`public class ArrayTest {`
`2`	`4`
`3`	`5`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//merge sorted Array`
	`1`	`+package data_structures.arrays;//merge sorted Array`
`2`	`2`
`3`	`3`	`class MergeSortedArrays {`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+package data_structures.arrays;`
	`2`	`+`
`1`	`3`	`/**`
`2`	`4`	`* Time Complexity: O(2n) Linear time`
`3`	`5`	`* Space Complexity: O(1) constant time`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+package data_structures.arrays;`
	`2`	`+`
`1`	`3`	`import java.util.HashMap;`
`2`	`4`	`import java.util.Map;`
`3`	`5`