update

Author: khalil2535

data_structures/graph/UnDirectedGraph.java

@@ -9,10 +9,10 @@
  */
 public class UnDirectedGraph<E> {
 
-    ArrayList<vertix<E>> vertixes;
+    ArrayList<Vertex<E>> vertexes;
 
     public UnDirectedGraph() {
-        this.vertixes = new ArrayList<>();
+        this.vertexes = new ArrayList<>();
     }
 
     /**
@@ -22,7 +22,7 @@ public UnDirectedGraph() {
      */
     public boolean addEntity(E entity) {
         if (!contatin(entity)) {
-            return vertixes.add(new vertix<>(entity));
+            return vertexes.add(new Vertex<>(entity));
         } else {
             return false;
         }
@@ -32,11 +32,12 @@ public boolean addEntity(E entity) {
      *
      * @param entity1
      * @param entity2
+     * @param space
      * @return true if added or false if not
      */
-    public boolean addConnection(E entity1, E entity2) {
+    public boolean addConnection(E entity1, E entity2, int space) {
         if (contatin(entity1) && contatin(entity2)) {
-            return vertixOf(entity1).connect(vertixOf(entity2));
+            return vertexOf(entity1).connect(vertexOf(entity2), space);
         }
         return false;
     }
@@ -47,53 +48,90 @@ public boolean addConnection(E entity1, E entity2) {
      * @return true if contains or false if not
      */
     public boolean contatin(E entity) {
-        return vertixes.stream().anyMatch((v) -> (v.item == entity));
+        return vertexes.stream().anyMatch((v) -> (v.item == entity));
     }
 
     /**
      *
      * @param entity
-     * @return the vertix for the entity
+     * @return the Vertex for the entity
      */
-    private vertix<E> vertixOf(E entity) {
-        for (vertix<E> vertix : vertixes) {
-            if (vertix.item == entity) {
-                return vertix;
+    private Vertex<E> vertexOf(E entity) {
+        for (Vertex<E> vertex : vertexes) {
+            if (vertex.item == entity) {
+                return vertex;
             }
         }
         return null;
     }
 
-    class vertix<E> {
+    /**
+     *
+     * @deprecated not supported yet
+     */
+    public ArrayList<E> dfs() {
+        ArrayList<Vertex<E>> unVisitedVertexes = (ArrayList<Vertex<E>>) vertexes.clone();
+        ArrayList<E> visited = new ArrayList<>();
+        Vertex<E> first = vertexes.get(0);// adding first item
+        visited.add(first.item);
+        Vertex<E> temp = first;
+        // start dfs
+        recursiveInnerDFS(visited, unVisitedVertexes, temp);
+        // end
+        return visited;
+    }
+
+    private void recursiveInnerDFS(ArrayList<E> visited, ArrayList<Vertex<E>> unVisited, Vertex<E> v) {
+        v.connections.stream().map((connection) -> (Vertex<E>) connection[0]).forEachOrdered((temp) -> {
+            if (!visited.contains(temp.item)) {
+                visited.add(temp.item);
+                unVisited.remove(temp);
+            } else {
+                recursiveInnerDFS(visited, unVisited, temp);
+            }
+        });
+
+    }
+
+    @Override
+    public String toString() {
+        return vertexes.toString();
+    }
+
+    class Vertex<E> {
 
         E item;
-        ArrayList<vertix<E>> connections;
+        ArrayList<Object[]> connections;
 
-        public vertix(E entity) {
+        public Vertex(E entity) {
             this.item = entity;
             connections = new ArrayList<>();
         }
 
-        public boolean connect(vertix<E> v) {
-            if (connections.contains(v)) {
+        public boolean connect(Vertex<E> v, int space) {
+            if (inRealtionWith(v)) {
                 return false;
-            } else {
-                connections.add(v);
-                v.connections.add(this);
-                return true;
             }
+            Object[] a1 = new Object[2];
+            a1[0] = v;
+            a1[1] = space;
+            connections.add(a1);
+            Object[] a2 = new Object[2];
+            a2[0] = this;
+            a2[1] = space;
+            v.connections.add(a2);
+            return true;
         }
 
         @Override
         public String toString() {
             return item.toString();
         }
 
-    }
+        public boolean inRealtionWith(Vertex<E> v) {
+            return connections.stream().anyMatch((connection) -> (connection[0] == v));
+        }
 
-    @Override
-    public String toString() {
-        return vertixes.toString();
     }
 
 }

data_structures/graph/tests/GraphTest.java

@@ -12,10 +12,36 @@ public static void main(String[] args) {
         UnDirectedGraph g = new UnDirectedGraph();
         Object A = "A";
         Object B = "B";
+        Object C = "C";
+        Object D = "D";
+        Object E = "E";
+        Object F = "F";
+        Object G = "G";
+        Object H = "H";
+        Object I = "I";
+        Object J = "J";
         g.addEntity(A);
         g.addEntity(B);
-        g.addConnection(A, B);
+        g.addEntity(C);
+        g.addEntity(D);
+        g.addEntity(E);
+        g.addEntity(F);
+        g.addEntity(G);
+        g.addEntity(H);
+        g.addEntity(I);
+        g.addEntity(J);
+        g.addConnection(A, B, 1);
+        g.addConnection(A, D, 1);
+        g.addConnection(A, C, 1);
+        g.addConnection(A, E, 1);
+        g.addConnection(B, C, 1);
+        g.addConnection(B, F, 1);
+        g.addConnection(C, D, 1);
+        g.addConnection(F, H, 1);
+        g.addConnection(D, G, 1);
+        g.addConnection(G, I, 1);
         System.out.println(g);
+        System.out.println(g.dfs());
 
     }
 

data_structures/stacks/Stack.java

@@ -1,8 +1,10 @@
 package data_structures.stacks;
 
+import java.util.Arrays;
+
 public class Stack<T> {
 
-    private T items[];
+    private final T items[];
     int pointer;
 
     public Stack(int capacity) {
@@ -35,7 +37,7 @@ public T pop() {
         }
     }
 
-    public T showTop() {
+    public T peek() {
         if (!isEmpty()) {
             return items[pointer];
         } else {
@@ -47,6 +49,10 @@ public int size() {
         return pointer + 1;
     }
 
+    public int indexOf(T item) {
+        return Arrays.binarySearch(items, item);
+    }
+
     @Override
     public String toString() {
         String stack = "------------\n";