initial commit :)

Author: jumbuna

.DS_Store

@@ -21,3 +21,6 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+
+#out dir
+/out

.gitignore

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/$CACHE_FILE$

@@ -0,0 +1,20 @@
+import com.jumbuna.ds.Queue;
+import com.jumbuna.ds.Stack;
+import com.jumbuna.ds.Vector;
+
+import java.util.Arrays;
+
+public class Main {
+    public static void main(String[] args) {
+        Vector<Integer> vector = new Vector<>();
+        vector.insert(10);
+        vector.insert(20);
+        vector.insert(30);
+        vector.insert(40);
+        vector.insert(50);
+
+        for(int i = 0; i < vector.size(); i++) {
+            System.out.println(vector.elementAt(i));
+        }
+    }
+}

.idea/misc.xml

@@ -0,0 +1,35 @@
+package com.jumbuna.algs;
+
+public class BinarySearch {
+    //iterative
+    public static  <T extends Comparable<T>> int binarySearchR(T[] array, T value, int start, int end) {
+        if(start < end) {
+            int midian = (start +end)/2;
+            if(array[midian].equals(value)) {
+                return midian;
+            }
+            if(array[midian].compareTo(value) > 0) {
+                return binarySearchR(array, value, start, midian-1);
+            }else {
+                return binarySearchR(array, value, midian+1, end);
+            }
+        }
+        return array[start].equals(value) ? start : -1;
+    }
+    //recursive
+    public static  <T extends Comparable<T>> int binarySearchI(T[] array, T value, int start, int stop) {
+        int midian;
+        while(start < stop) {
+            midian = (start+stop)/2;
+            if(array[midian].equals(value)) {
+                return midian;
+            }
+            if(array[midian].compareTo(value) > 0) {
+                stop = midian-1;
+            }else {
+                start = midian+1;
+            }
+        }
+        return array[start].equals(value) ? start : -1;
+    }
+}

.idea/modules.xml

@@ -0,0 +1,19 @@
+package com.jumbuna.algs;
+
+public class QuickSort {
+    public static <T extends Comparable<T>> void quickSort(T[] array, int start, int stop) {
+        if(start < stop) {
+            int pivot = stop;
+            for(int i = stop-1; i >= 0; i--) {
+                if(array[i].compareTo(array[pivot]) > 0) {
+                    T temp = array[pivot];
+                    array[pivot] = array[i];
+                    array[i] = array[pivot-1];
+                    array[pivot-1] = temp;
+                }
+            }
+            quickSort(array, start, pivot-1);
+            quickSort(array, pivot+1, stop);
+        }
+    }
+}

.idea/workspace.xml

@@ -0,0 +1,82 @@
+package com.jumbuna.ds;
+
+public class LinkedList<T> {
+    private class Node {
+        Node(T element, Node n) {
+            data = element;
+            next = n;
+        }
+        T data;
+        Node next;
+    }
+    private Node head = null;
+    private Node tail = null;
+    private int nodeCount = 0;
+
+    public void insertFront(T element) {
+        if(element != null) {
+            if(nodeCount == 0) {
+                head = tail = new Node(element, null);
+            }else {
+                head = new Node(element, head);
+            }
+            ++nodeCount;
+        }
+    }
+
+    public void insertBack(T element) {
+        if(element != null) {
+            if(nodeCount == 0) {
+                head = tail = new Node(element, null);
+            }else {
+                tail.next = new Node(element, null);
+                tail = tail.next;
+            }
+            ++nodeCount;
+        }
+    }
+
+    public T removeFront() {
+        if(nodeCount == 0) {
+            throw new IndexOutOfBoundsException("list is empty");
+        }
+        T temp = head.data;
+        head = head.next;
+        --nodeCount;
+        return temp;
+    }
+
+    public T removeBack() {
+        if(nodeCount == 0) {
+            throw new IndexOutOfBoundsException("list is empty");
+        }
+        Node t = head;
+        while(!t.next.equals(tail)) {
+            t = t.next;
+        }
+        T temp = tail.data;
+        t.next = null;
+        tail = t;
+        --nodeCount;
+        return temp;
+    }
+
+    public T valueAt(int i) {
+        if(i >= nodeCount) {
+            throw new IndexOutOfBoundsException("max index is "+i);
+        }
+        Node temp = head;
+        for(int j = 0; j != i; j++) {
+            temp = temp.next;
+        }
+        return temp.data;
+    }
+
+    public int size() {
+        return nodeCount;
+    }
+
+    public boolean empty() {
+        return nodeCount == 0;
+    }
+}

dsAlgJava.iml

@@ -0,0 +1,25 @@
+package com.jumbuna.ds;
+
+public class Queue<T> {
+    private LinkedList<T> list = new LinkedList<>();
+
+    public void push(T element) {
+        list.insertBack(element);
+    }
+
+    public T pop() {
+        return list.removeFront();
+    }
+
+    public T peek() {
+        return list.valueAt(0);
+    }
+
+    public int size() {
+        return list.size();
+    }
+
+    public boolean empty() {
+        return list.empty();
+    }
+}

out/.DS_Store

@@ -0,0 +1,25 @@
+package com.jumbuna.ds;
+
+public class Stack<T> {
+    private LinkedList<T> list = new LinkedList<>();
+
+    public void push(T element) {
+        list.insertFront(element);
+    }
+
+    public T pop() {
+        return list.removeFront();
+    }
+
+    public T peek() {
+        return list.valueAt(0);
+    }
+
+    public int size() {
+        return list.size();
+    }
+
+    public boolean empty() {
+        return list.empty();
+    }
+}