From 464374e49d9aafddb21ff2a8add851934d6995f0 Mon Sep 17 00:00:00 2001
From: hussien alrubaye <hussien89aa@yahoo.com>
Date: Sat, 13 Mar 2021 20:37:49 -0500
Subject: [PATCH 1/2] add interview questions

---
 CodingInterviews/.classpath                   |  10 ++
 CodingInterviews/.project                     |  17 ++++
 .../.settings/org.eclipse.jdt.core.prefs      |  14 +++
 CodingInterviews/src/com/bst/BST.java         |  57 +++++++++++
 CodingInterviews/src/com/bst/Node.java        |  13 +++
 .../src/com/linkedList/LinkedListManager.java |  42 ++++++++
 .../src/com/linkedList/LinkedListU.java       |  31 ++++++
 .../src/com/linkedList/ListNode.java          |  12 +++
 CodingInterviews/src/com/problem1/Cell.java   |  15 +++
 .../src/com/problem1/ShortPath.java           |  71 ++++++++++++++
 .../src/com/problem11/TreeNetwork.java        |  68 +++++++++++++
 .../src/com/problem12/Mirror.java             |  63 ++++++++++++
 .../src/com/problem13/GraphLevel.java         |  90 ++++++++++++++++++
 .../src/com/problem14/FirendCircle.java       |  70 ++++++++++++++
 .../src/com/problem15/WordDistance.java       |  72 ++++++++++++++
 .../src/com/problem16/WordSimilar.java        |  46 +++++++++
 .../src/com/problem17/WordBreak.java          |  88 +++++++++++++++++
 .../src/com/problem18/SprialMatrix.java       |  63 ++++++++++++
 CodingInterviews/src/com/problem2/GCell.java  |  22 +++++
 .../src/com/problem2/TripPlaner.java          |  67 +++++++++++++
 .../src/com/problem20/TopMoviesInStream.java  |  36 +++++++
 .../src/com/problem21/MerageLinkedList.java   |  29 ++++++
 .../com/problem3/FindPathBetweenTwoNodes.java |  73 ++++++++++++++
 .../src/com/problem4/SimilarTree.java         |  63 ++++++++++++
 .../src/com/problem5/LCSOnes.java             |  68 +++++++++++++
 .../src/com/problem6/BinarySearch.java        |  52 ++++++++++
 CodingInterviews/src/com/problem7/LCS.java    |  44 +++++++++
 CodingInterviews/src/com/problem8/Stair.java  |  15 +++
 .../src/com/problem8/StairCaseDemo.java       |  41 ++++++++
 .../src/com/problem9/Parentheses.java         |  55 +++++++++++
 .../src}/collection/com/HashMapClass.java     |   0
 .../src}/collection/com/HashSetClass.java     |   0
 .../collection/com/LinkListArrayList.java     |   0
 .../src}/collection/com/Student.java          |   0
 .../src}/collection/com/TreeSetExample.java   |   0
 .../src}/collection/com/VectorExample.java    |   0
 .../src}/collection/com/myQueue.java          |   0
 .../src}/collection/com/myStack.java          |   0
 .../src}/com/ds/DynamicArray.java             |   0
 .../src}/com/ds/DynamicArrayDemo.java         |   0
 .../src}/com/ds/LinkedListD.java              |   0
 .../src}/com/ds/LinkedListDDemo.java          |   0
 .../src}/com/ds/LinkedListU.java              |   0
 .../src}/com/ds/LinkedListUDemo.java          |   0
 .../src}/com/ds/Node.java                     |   0
 .../src}/com/ds/NodeD.java                    |   0
 .../src}/com/ds/OneDArray.java                |   0
 .../src}/com/ds/QueueArray.java               |   0
 .../src}/com/ds/QueueArrayDemo.java           |   0
 .../src}/com/ds/QueueDArray.java              |   0
 .../src}/com/ds/QueueDArrayDemo.java          |   0
 .../src}/com/ds/QueueLinkedList.java          |   0
 .../src}/com/ds/QueueLinkedListDemo.java      |   0
 .../src}/com/ds/StackArray.java               |   0
 .../src}/com/ds/StackArrayDemo.java           |   0
 .../src}/com/ds/StackDArray.java              |   0
 .../src}/com/ds/StackDArrayDemo.java          |   0
 .../src}/com/ds/StackLinkedList.java          |   0
 .../src}/com/ds/StackLinkedListDemo.java      |   0
 .../src}/com/ds/Student.java                  |   0
 .../src}/com/ds/TwoDArray.java                |   0
 .../src}/com/ds/hash/Entry.java               |   0
 .../src}/com/ds/hash/HashTableArray.java      |   0
 .../src}/com/ds/hash/HashTableArrayDemo.java  |   0
 .../src}/com/graph/BFSGraph.java              |   0
 .../src}/com/graph/BFSGraphDemo.java          |   0
 .../src}/com/graph/DFSGraph.java              |   0
 .../src}/com/graph/DFSGraphDemo.java          |   0
 .../src}/com/graph/Node.java                  |   0
 .../src}/com/graph/adjList.java               |   0
 .../src}/com/search/BinarySearch.java         |   0
 .../src}/com/search/DataSet.java              |   0
 .../src}/com/search/InterploationSearch.java  |   0
 .../src}/com/search/LinearSearch.java         |   0
 .../src}/com/sort/BubbleSorting.java          |   0
 .../src}/com/sort/HeapSort.java               |   0
 .../src}/com/sort/MergeSort.java              |   0
 .../src}/com/sort/QuickSorting.java           |   0
 .../src}/com/sort/SelectionSorting.java       |   0
 .../src}/com/tree/BST.java                    |   0
 .../src}/com/tree/BSTDemo.java                |   0
 .../src}/com/tree/Node.java                   |   0
 bin/collection/com/HashMapClass.class         | Bin 1657 -> 0 bytes
 bin/collection/com/HashSetClass.class         | Bin 1493 -> 0 bytes
 bin/collection/com/LinkListArrayList.class    | Bin 1367 -> 0 bytes
 bin/collection/com/NodeS.class                | Bin 766 -> 0 bytes
 bin/collection/com/Student.class              | Bin 805 -> 0 bytes
 bin/collection/com/TreeSetExample.class       | Bin 1592 -> 0 bytes
 bin/collection/com/VectorExample.class        | Bin 1860 -> 0 bytes
 bin/collection/com/myQueue.class              | Bin 1625 -> 0 bytes
 bin/collection/com/myStack.class              | Bin 887 -> 0 bytes
 bin/com/ds/DynamicArray.class                 | Bin 1299 -> 0 bytes
 bin/com/ds/DynamicArrayDemo.class             | Bin 1367 -> 0 bytes
 bin/com/ds/LinkedListD.class                  | Bin 1234 -> 0 bytes
 bin/com/ds/LinkedListDDemo.class              | Bin 946 -> 0 bytes
 bin/com/ds/LinkedListU.class                  | Bin 1171 -> 0 bytes
 bin/com/ds/LinkedListUDemo.class              | Bin 946 -> 0 bytes
 bin/com/ds/Node.class                         | Bin 402 -> 0 bytes
 bin/com/ds/NodeD.class                        | Bin 468 -> 0 bytes
 bin/com/ds/OneDArray.class                    | Bin 1336 -> 0 bytes
 bin/com/ds/QueueArray.class                   | Bin 1635 -> 0 bytes
 bin/com/ds/QueueArrayDemo.class               | Bin 1141 -> 0 bytes
 bin/com/ds/QueueDArray.class                  | Bin 2030 -> 0 bytes
 bin/com/ds/QueueDArrayDemo.class              | Bin 1092 -> 0 bytes
 bin/com/ds/QueueLinkedList.class              | Bin 1343 -> 0 bytes
 bin/com/ds/QueueLinkedListDemo.class          | Bin 963 -> 0 bytes
 bin/com/ds/StackArray.class                   | Bin 1556 -> 0 bytes
 bin/com/ds/StackArrayDemo.class               | Bin 1082 -> 0 bytes
 bin/com/ds/StackDArray.class                  | Bin 1943 -> 0 bytes
 bin/com/ds/StackDArrayDemo.class              | Bin 1098 -> 0 bytes
 bin/com/ds/StackLinkedList.class              | Bin 1184 -> 0 bytes
 bin/com/ds/StackLinkedListDemo.class          | Bin 914 -> 0 bytes
 bin/com/ds/Student.class                      | Bin 401 -> 0 bytes
 bin/com/ds/TwoDArray.class                    | Bin 1060 -> 0 bytes
 bin/com/ds/hash/Entry.class                   | Bin 685 -> 0 bytes
 bin/com/ds/hash/HashTableArray.class          | Bin 1483 -> 0 bytes
 bin/com/ds/hash/HashTableArrayDemo.class      | Bin 950 -> 0 bytes
 bin/com/graph/BFSGraph.class                  | Bin 2008 -> 0 bytes
 bin/com/graph/BFSGraphDemo.class              | Bin 647 -> 0 bytes
 bin/com/graph/DFSGraph.class                  | Bin 2115 -> 0 bytes
 bin/com/graph/DFSGraphDemo.class              | Bin 647 -> 0 bytes
 bin/com/graph/Node.class                      | Bin 377 -> 0 bytes
 bin/com/graph/adjList.class                   | Bin 300 -> 0 bytes
 bin/com/search/BinarySearch.class             | Bin 1453 -> 0 bytes
 bin/com/search/DataSet.class                  | Bin 543 -> 0 bytes
 bin/com/search/InterploationSearch.class      | Bin 1506 -> 0 bytes
 bin/com/search/LinearSearch.class             | Bin 1336 -> 0 bytes
 bin/com/sort/BubbleSorting.class              | Bin 1344 -> 0 bytes
 bin/com/sort/HeapSort.class                   | Bin 2008 -> 0 bytes
 bin/com/sort/MergeSort.class                  | Bin 1894 -> 0 bytes
 bin/com/sort/QuickSorting.class               | Bin 1507 -> 0 bytes
 bin/com/sort/SelectionSorting.class           | Bin 1358 -> 0 bytes
 bin/com/tree/BST.class                        | Bin 1245 -> 0 bytes
 bin/com/tree/BSTDemo.class                    | Bin 725 -> 0 bytes
 bin/com/tree/Node.class                       | Bin 434 -> 0 bytes
 135 files changed, 1407 insertions(+)
 create mode 100644 CodingInterviews/.classpath
 create mode 100644 CodingInterviews/.project
 create mode 100644 CodingInterviews/.settings/org.eclipse.jdt.core.prefs
 create mode 100644 CodingInterviews/src/com/bst/BST.java
 create mode 100644 CodingInterviews/src/com/bst/Node.java
 create mode 100644 CodingInterviews/src/com/linkedList/LinkedListManager.java
 create mode 100644 CodingInterviews/src/com/linkedList/LinkedListU.java
 create mode 100644 CodingInterviews/src/com/linkedList/ListNode.java
 create mode 100644 CodingInterviews/src/com/problem1/Cell.java
 create mode 100644 CodingInterviews/src/com/problem1/ShortPath.java
 create mode 100644 CodingInterviews/src/com/problem11/TreeNetwork.java
 create mode 100644 CodingInterviews/src/com/problem12/Mirror.java
 create mode 100644 CodingInterviews/src/com/problem13/GraphLevel.java
 create mode 100644 CodingInterviews/src/com/problem14/FirendCircle.java
 create mode 100644 CodingInterviews/src/com/problem15/WordDistance.java
 create mode 100644 CodingInterviews/src/com/problem16/WordSimilar.java
 create mode 100644 CodingInterviews/src/com/problem17/WordBreak.java
 create mode 100644 CodingInterviews/src/com/problem18/SprialMatrix.java
 create mode 100644 CodingInterviews/src/com/problem2/GCell.java
 create mode 100644 CodingInterviews/src/com/problem2/TripPlaner.java
 create mode 100644 CodingInterviews/src/com/problem20/TopMoviesInStream.java
 create mode 100644 CodingInterviews/src/com/problem21/MerageLinkedList.java
 create mode 100644 CodingInterviews/src/com/problem3/FindPathBetweenTwoNodes.java
 create mode 100644 CodingInterviews/src/com/problem4/SimilarTree.java
 create mode 100644 CodingInterviews/src/com/problem5/LCSOnes.java
 create mode 100644 CodingInterviews/src/com/problem6/BinarySearch.java
 create mode 100644 CodingInterviews/src/com/problem7/LCS.java
 create mode 100644 CodingInterviews/src/com/problem8/Stair.java
 create mode 100644 CodingInterviews/src/com/problem8/StairCaseDemo.java
 create mode 100644 CodingInterviews/src/com/problem9/Parentheses.java
 rename {src => DataStructureAndAlgorithms/src}/collection/com/HashMapClass.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/HashSetClass.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/LinkListArrayList.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/Student.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/TreeSetExample.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/VectorExample.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/myQueue.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/collection/com/myStack.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/DynamicArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/DynamicArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/LinkedListD.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/LinkedListDDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/LinkedListU.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/LinkedListUDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/Node.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/NodeD.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/OneDArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueDArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueDArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueLinkedList.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/QueueLinkedListDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackDArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackDArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackLinkedList.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/StackLinkedListDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/Student.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/TwoDArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/hash/Entry.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/hash/HashTableArray.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/ds/hash/HashTableArrayDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/BFSGraph.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/BFSGraphDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/DFSGraph.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/DFSGraphDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/Node.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/graph/adjList.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/search/BinarySearch.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/search/DataSet.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/search/InterploationSearch.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/search/LinearSearch.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/sort/BubbleSorting.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/sort/HeapSort.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/sort/MergeSort.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/sort/QuickSorting.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/sort/SelectionSorting.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/tree/BST.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/tree/BSTDemo.java (100%)
 rename {src => DataStructureAndAlgorithms/src}/com/tree/Node.java (100%)
 delete mode 100644 bin/collection/com/HashMapClass.class
 delete mode 100644 bin/collection/com/HashSetClass.class
 delete mode 100644 bin/collection/com/LinkListArrayList.class
 delete mode 100644 bin/collection/com/NodeS.class
 delete mode 100644 bin/collection/com/Student.class
 delete mode 100644 bin/collection/com/TreeSetExample.class
 delete mode 100644 bin/collection/com/VectorExample.class
 delete mode 100644 bin/collection/com/myQueue.class
 delete mode 100644 bin/collection/com/myStack.class
 delete mode 100644 bin/com/ds/DynamicArray.class
 delete mode 100644 bin/com/ds/DynamicArrayDemo.class
 delete mode 100644 bin/com/ds/LinkedListD.class
 delete mode 100644 bin/com/ds/LinkedListDDemo.class
 delete mode 100644 bin/com/ds/LinkedListU.class
 delete mode 100644 bin/com/ds/LinkedListUDemo.class
 delete mode 100644 bin/com/ds/Node.class
 delete mode 100644 bin/com/ds/NodeD.class
 delete mode 100644 bin/com/ds/OneDArray.class
 delete mode 100644 bin/com/ds/QueueArray.class
 delete mode 100644 bin/com/ds/QueueArrayDemo.class
 delete mode 100644 bin/com/ds/QueueDArray.class
 delete mode 100644 bin/com/ds/QueueDArrayDemo.class
 delete mode 100644 bin/com/ds/QueueLinkedList.class
 delete mode 100644 bin/com/ds/QueueLinkedListDemo.class
 delete mode 100644 bin/com/ds/StackArray.class
 delete mode 100644 bin/com/ds/StackArrayDemo.class
 delete mode 100644 bin/com/ds/StackDArray.class
 delete mode 100644 bin/com/ds/StackDArrayDemo.class
 delete mode 100644 bin/com/ds/StackLinkedList.class
 delete mode 100644 bin/com/ds/StackLinkedListDemo.class
 delete mode 100644 bin/com/ds/Student.class
 delete mode 100644 bin/com/ds/TwoDArray.class
 delete mode 100644 bin/com/ds/hash/Entry.class
 delete mode 100644 bin/com/ds/hash/HashTableArray.class
 delete mode 100644 bin/com/ds/hash/HashTableArrayDemo.class
 delete mode 100644 bin/com/graph/BFSGraph.class
 delete mode 100644 bin/com/graph/BFSGraphDemo.class
 delete mode 100644 bin/com/graph/DFSGraph.class
 delete mode 100644 bin/com/graph/DFSGraphDemo.class
 delete mode 100644 bin/com/graph/Node.class
 delete mode 100644 bin/com/graph/adjList.class
 delete mode 100644 bin/com/search/BinarySearch.class
 delete mode 100644 bin/com/search/DataSet.class
 delete mode 100644 bin/com/search/InterploationSearch.class
 delete mode 100644 bin/com/search/LinearSearch.class
 delete mode 100644 bin/com/sort/BubbleSorting.class
 delete mode 100644 bin/com/sort/HeapSort.class
 delete mode 100644 bin/com/sort/MergeSort.class
 delete mode 100644 bin/com/sort/QuickSorting.class
 delete mode 100644 bin/com/sort/SelectionSorting.class
 delete mode 100644 bin/com/tree/BST.class
 delete mode 100644 bin/com/tree/BSTDemo.class
 delete mode 100644 bin/com/tree/Node.class

diff --git a/CodingInterviews/.classpath b/CodingInterviews/.classpath
new file mode 100644
index 0000000..c0f260f
--- /dev/null
+++ b/CodingInterviews/.classpath
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-12">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/CodingInterviews/.project b/CodingInterviews/.project
new file mode 100644
index 0000000..64db0a7
--- /dev/null
+++ b/CodingInterviews/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>CodingInterviews</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/CodingInterviews/.settings/org.eclipse.jdt.core.prefs b/CodingInterviews/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..71f736f
--- /dev/null
+++ b/CodingInterviews/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,14 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=12
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=12
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=12
diff --git a/CodingInterviews/src/com/bst/BST.java b/CodingInterviews/src/com/bst/BST.java
new file mode 100644
index 0000000..34f4381
--- /dev/null
+++ b/CodingInterviews/src/com/bst/BST.java
@@ -0,0 +1,57 @@
+package com.bst;
+ 
+
+public class BST {
+     public Node root;
+     
+     public BST() {
+    	 root = null;
+     }
+     
+     /*
+      * Build Tree
+      */
+	public void add (int value, Node rootClone) {
+		
+		if( root ==null) {
+			root = new Node(value, null, null);
+			return;
+		}
+		
+		if( value > rootClone.value) {
+			
+			if( rootClone.rightNode  == null) {
+				rootClone.rightNode = new Node(value, null, null);
+			}else {
+				add(value, rootClone.rightNode);
+			}
+		}
+		
+		if( value < rootClone.value) {
+			
+			if( rootClone.leftNode  == null) {
+				rootClone.leftNode = new Node(value, null, null);
+			}else {
+				add(value, rootClone.leftNode);
+			}
+		}
+		
+		
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+
+}
diff --git a/CodingInterviews/src/com/bst/Node.java b/CodingInterviews/src/com/bst/Node.java
new file mode 100644
index 0000000..6bd44cd
--- /dev/null
+++ b/CodingInterviews/src/com/bst/Node.java
@@ -0,0 +1,13 @@
+package com.bst;
+
+public class Node {
+	  public  int value;
+	  public  Node leftNode;
+	  public  Node rightNode;
+	  public Node(int value, Node leftNode, Node rightNode) {
+		this.value = value;
+		this.leftNode = leftNode ;
+		this.rightNode = rightNode;
+	  }
+
+}
diff --git a/CodingInterviews/src/com/linkedList/LinkedListManager.java b/CodingInterviews/src/com/linkedList/LinkedListManager.java
new file mode 100644
index 0000000..7cd38e9
--- /dev/null
+++ b/CodingInterviews/src/com/linkedList/LinkedListManager.java
@@ -0,0 +1,42 @@
+package com.linkedList;
+
+public class LinkedListManager {
+
+	public static void main(String[] args) {
+		
+		LinkedListU<String> ls = new 	LinkedListU<String>();
+		ls.add(1);
+		ls.add(2);
+		ls.add(3);
+		ls.add(4);
+		ls.add(5);
+		ls.add(6);
+		ls.display();
+
+		deleteKthElement(ls.head, 2);
+		System.out.println("After delete");
+		ls.display();
+
+	}
+	
+	static void deleteKthElement(ListNode root, int k) {
+		
+		//init
+		ListNode slowPtr = root;
+		ListNode fastPtr = root;
+		
+		// move fast ptr to slow + k
+		while(k>0) {
+			fastPtr = fastPtr.next;
+			k--;
+		}
+		
+		while(fastPtr.next != null) {
+			slowPtr = slowPtr.next;
+			fastPtr = fastPtr.next;
+		}
+		
+		slowPtr.next = slowPtr.next.next;
+		
+	}
+}
diff --git a/CodingInterviews/src/com/linkedList/LinkedListU.java b/CodingInterviews/src/com/linkedList/LinkedListU.java
new file mode 100644
index 0000000..625c1a6
--- /dev/null
+++ b/CodingInterviews/src/com/linkedList/LinkedListU.java
@@ -0,0 +1,31 @@
+package com.linkedList;
+
+public class LinkedListU<T> {
+	
+	ListNode head;
+		public LinkedListU() {
+		 head= null;
+		}
+	public void add(Object value){
+		ListNode  newNode=new ListNode(value, null);
+		if(head==null)
+			head=newNode;
+		else{
+			newNode.next=head;
+			head= newNode;
+		}
+	}
+	public void delete(){
+		head=head.next;
+		
+	}
+	public void display(){
+		ListNode n=head;
+		while(n!=null){
+			System.out.println((T)n.value);
+			n=n.next;
+		}
+	}
+
+
+}
diff --git a/CodingInterviews/src/com/linkedList/ListNode.java b/CodingInterviews/src/com/linkedList/ListNode.java
new file mode 100644
index 0000000..33cfacc
--- /dev/null
+++ b/CodingInterviews/src/com/linkedList/ListNode.java
@@ -0,0 +1,12 @@
+package com.linkedList;
+
+public class ListNode {
+ 
+	Object value;
+	ListNode next;
+	public ListNode(Object value,ListNode next) {
+		 this.value=value;
+		 this.next=next;
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem1/Cell.java b/CodingInterviews/src/com/problem1/Cell.java
new file mode 100644
index 0000000..981a255
--- /dev/null
+++ b/CodingInterviews/src/com/problem1/Cell.java
@@ -0,0 +1,15 @@
+package com.problem1;
+
+public class Cell {
+
+	public int rowIndex;
+	public int colIndex;
+	public int distance;
+	public Cell( int rowIndex,int colIndex,int distance) {
+		this.rowIndex = rowIndex;
+		this.colIndex = colIndex;
+		this.distance =distance;
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem1/ShortPath.java b/CodingInterviews/src/com/problem1/ShortPath.java
new file mode 100644
index 0000000..fc7af60
--- /dev/null
+++ b/CodingInterviews/src/com/problem1/ShortPath.java
@@ -0,0 +1,71 @@
+package com.problem1;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class ShortPath {
+
+	public static void main(String[] args) {
+		 
+		//We give 9 for post location
+		int[][] grid = {{1,1,1,1,0},{0,0,0,1,0},{0,0,1,1,0}, {0,0,1,0,0},{0,0,0,9,0} };
+		print(grid);
+		
+		Queue<Cell> queue = new LinkedList<Cell>();
+		//Set robot location
+		move(grid,queue, 0,0, 0);
+		
+		while ( !queue.isEmpty()) {
+			
+			Cell botCell =  queue.poll();
+			// left
+			
+			move (grid, queue, botCell.rowIndex -1, botCell.colIndex, botCell.distance +1);
+			
+			//right
+			move (grid, queue, botCell.rowIndex +1, botCell.colIndex, botCell.distance +1);
+			
+			// top
+			
+			move (grid, queue, botCell.rowIndex, botCell.colIndex -1, botCell.distance +1);
+			
+			
+			//button
+			
+			move (grid, queue, botCell.rowIndex, botCell.colIndex +1, botCell.distance +1);
+			
+		}
+		System.out.println("Not path found");
+		
+	}
+	
+	static void move( int[][] grid, Queue<Cell> queue, int newRow, int newCol, int newDistance) {
+		
+		// make sure the robot in the grid
+		if( newRow >=0 && newRow < grid.length &&  newCol >= 0 && newCol < grid[0].length) {
+			
+			if ( grid[newRow][newCol] == 1) {
+				queue.add(new Cell(newRow, newCol, newDistance));
+				grid[newRow][newCol] = -1; // cell is visited
+			}else if(  grid[newRow][newCol] == 9) {
+				//path is found
+				System.out.println("Path is found, Distnace: "+ newDistance);
+				System.exit(0);
+			}
+			
+		}
+	}
+
+	static void print( int[][] grid) {
+		
+		for(int i=0;i<grid.length ; i++) {
+			
+			for (int j=0;j<grid[0].length; j++) {
+				System.out.print(grid[i][j] + " ");
+			}
+			System.out.println("");
+		}
+	}
+	
+	
+}
diff --git a/CodingInterviews/src/com/problem11/TreeNetwork.java b/CodingInterviews/src/com/problem11/TreeNetwork.java
new file mode 100644
index 0000000..e9fa62e
--- /dev/null
+++ b/CodingInterviews/src/com/problem11/TreeNetwork.java
@@ -0,0 +1,68 @@
+package com.problem11;
+
+import java.util.ArrayList;
+
+import com.bst.Node;
+
+public class TreeNetwork {
+
+	public static void main(String[] args) {
+		 
+		//create the tree
+		Node node1 = new Node(1, null, null);
+		Node node2 = new Node(2, null, null);
+		Node node3 = new Node(3, null, null);
+		Node node4 = new Node(4, null, null);
+		Node node5 = new Node(5, null, null);
+		
+		node1.leftNode = node3;
+		node1.rightNode = node2;
+		
+		node2.leftNode = node5;
+		node2.rightNode = node4;
+		
+		TreeNetwork treeNetwork=new TreeNetwork();
+		treeNetwork.serialize(node1);
+		System.out.println(treeNetwork.serializeList);
+		
+		Node head = treeNetwork.deSerialize();
+		
+		TreeNetwork treeNetwork1=new TreeNetwork();
+		treeNetwork1.serialize(head);
+		System.out.println(treeNetwork1.serializeList);
+		
+	}
+	
+	ArrayList<Integer> serializeList = new ArrayList<Integer>();
+	void serialize(Node node) {
+		
+		if(node != null) {
+		    serializeList.add(node.value);
+			serialize(node.leftNode);
+			serialize(node.rightNode);
+		
+		}else {
+			serializeList.add(-1);
+		}
+	}
+	
+	int index =0;
+	Node deSerialize() {
+		
+		if( index >serializeList.size()-1 ||  serializeList.get(index)==-1) {
+			index ++;
+			return null;
+		}
+		
+		Node newNode = new Node(serializeList.get(index++), null, null);
+		newNode.leftNode = deSerialize() ;
+		newNode.rightNode = deSerialize() ;
+		return newNode; 
+	}
+	
+	
+	
+	
+	
+
+}
diff --git a/CodingInterviews/src/com/problem12/Mirror.java b/CodingInterviews/src/com/problem12/Mirror.java
new file mode 100644
index 0000000..299fa09
--- /dev/null
+++ b/CodingInterviews/src/com/problem12/Mirror.java
@@ -0,0 +1,63 @@
+package com.problem12;
+
+import com.bst.Node;
+
+public class Mirror {
+
+	
+	public static void main(String[] args) {
+		
+		new Mirror().buildTress();
+	}
+	
+	
+	void  buildTress() {
+		
+		// Tree 1
+		 Node node1  = new Node(1, null, null);
+		 Node node2  = new Node(2, null, null);
+		 Node node3  = new Node(3, null, null);
+		 Node node4  = new Node(4, null, null);
+		 Node node5  = new Node(5, null, null);
+		 
+		 // build Tree 1
+		 node1.leftNode = node3;
+		 node1.rightNode = node2;
+		 node2.leftNode = node5;
+		 node2.rightNode = node4;
+		 
+		 explore1(node1);
+		 
+		 
+		 System.out.println();
+		 // build Tree 2
+		 node1.leftNode = node2;
+		 node1.rightNode = node3;
+		 node2.leftNode = node4;
+		 node2.rightNode = node5;
+		 explore2(node1);
+		
+	}
+	
+	// TLR
+	void explore1(Node node) {
+		if( node !=null) {
+			System.out.print( node.value +"\t");
+			explore1(node.leftNode);
+			explore1(node.rightNode);
+		}
+	}
+	
+	
+	// TRL
+	void explore2(Node node) {
+		if( node !=null) {
+			System.out.print( node.value +"\t");
+			explore2(node.rightNode);
+			explore2(node.leftNode);
+
+		}
+	}
+	
+	
+}
diff --git a/CodingInterviews/src/com/problem13/GraphLevel.java b/CodingInterviews/src/com/problem13/GraphLevel.java
new file mode 100644
index 0000000..3cffb26
--- /dev/null
+++ b/CodingInterviews/src/com/problem13/GraphLevel.java
@@ -0,0 +1,90 @@
+package com.problem13;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import javax.management.Query;
+
+import com.bst.Node;
+ 
+
+public class GraphLevel {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		
+		// Tree 1
+		 Node node1  = new Node(1, null, null);
+		 Node node2  = new Node(2, null, null);
+		 Node node3  = new Node(3, null, null);
+		 Node node4  = new Node(4, null, null);
+		 Node node5  = new Node(5, null, null);
+		 Node node6  = new Node(6, null, null);
+		 
+		 // build Tree 1
+		 node1.leftNode = node3;
+		 node1.rightNode = node2;
+		 node2.leftNode = node5;
+		 node2.rightNode = node4;
+		 node3.leftNode = node6;
+		 
+		 ArrayList<ArrayList<Integer>> listOfLevels = new GraphLevel().getLevels(node1);
+		 for (ArrayList<Integer> level : listOfLevels) {
+			System.out.println(level);
+		}
+		 
+		 // balance
+		 ArrayList<ArrayList<Integer>> listOfLevels1 = new GraphLevel().getLevels(node1.leftNode);
+		 ArrayList<ArrayList<Integer>> listOfLevels2 = new GraphLevel().getLevels(node1.rightNode);
+		 System.out.println(listOfLevels1.size() + "," + listOfLevels2.size());
+		 if(listOfLevels1.size() == listOfLevels2.size()) {
+			 System.out.println(" Tree balance");
+		 }else {
+			 System.out.println(" Tree not balance"); 
+		 }
+		 
+	}
+	
+	
+	ArrayList<ArrayList<Integer>> getLevels( Node node){
+		
+		ArrayList<ArrayList<Integer>> listOfLevels = new ArrayList<ArrayList<Integer>>();	
+		
+		Queue<Node> nodesQueue = new LinkedList<Node>();
+		nodesQueue.add(node);
+		int preLevel =1;
+		int currentLevel=0;
+		ArrayList<Integer> levelElements = new ArrayList<Integer>();
+		while( !nodesQueue.isEmpty()) {
+			
+			Node newNode = nodesQueue.poll();
+			levelElements.add(newNode.value);
+			if( newNode.leftNode != null) {
+				nodesQueue.add(newNode.leftNode);
+				currentLevel++;
+			}
+			
+			if( newNode.rightNode != null) {
+				nodesQueue.add(newNode.rightNode);
+				currentLevel++;
+			}
+			
+			preLevel --;
+			if(preLevel==0) {
+				listOfLevels.add(levelElements);
+				preLevel = currentLevel;
+				currentLevel = 0;
+				levelElements = new ArrayList<Integer>();
+				
+			}
+		}
+		
+		
+		
+		return listOfLevels;
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem14/FirendCircle.java b/CodingInterviews/src/com/problem14/FirendCircle.java
new file mode 100644
index 0000000..2758b78
--- /dev/null
+++ b/CodingInterviews/src/com/problem14/FirendCircle.java
@@ -0,0 +1,70 @@
+package com.problem14;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class FirendCircle {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		//input
+		int[][] connections = {
+				{1,1,0,0,0},
+				{1,1,1,0,0},
+				{0,1,1,0,0},
+				{0,0,0,1,1},
+				{0,0,0,1,1}
+		};
+		
+		ArrayList<ArrayList<Integer>> listOfCircles = new FirendCircle().getCircles(connections);
+		for (ArrayList<Integer> circle : listOfCircles) {
+			System.out.println(circle);
+		}
+	}
+	
+	
+	ArrayList<ArrayList<Integer>> getCircles(int[][] connections){
+		
+		ArrayList<ArrayList<Integer>> listOfCircles =  new ArrayList<ArrayList<Integer>>();
+		
+		// save if person in any circle
+		boolean[] visited = new boolean[ connections.length];
+		
+		for(int row=0;row< connections.length ; row++) {
+			
+			if(visited[row] == true) {
+				continue;
+			}
+			
+			visited[row] = true;
+			
+			Queue<Integer> circleQueue = new LinkedList<Integer>();
+			
+			circleQueue.add(row);
+			ArrayList<Integer> listOfFirends = new ArrayList<Integer>();
+			while( !circleQueue.isEmpty()) {
+				
+				int userID = circleQueue.poll();
+				listOfFirends.add(userID);
+				
+				for( int userFirendsID =0;userFirendsID< connections[0].length;userFirendsID++) {
+					
+					if( connections[userID][userFirendsID]== 1 && visited[userFirendsID]!= true) {
+						circleQueue.add(userFirendsID);
+						visited[userFirendsID] = true;
+					}
+				}
+				
+			}
+			
+			listOfCircles.add(listOfFirends);
+			
+		}
+		
+		
+		return listOfCircles;
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem15/WordDistance.java b/CodingInterviews/src/com/problem15/WordDistance.java
new file mode 100644
index 0000000..341b0d3
--- /dev/null
+++ b/CodingInterviews/src/com/problem15/WordDistance.java
@@ -0,0 +1,72 @@
+package com.problem15;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class WordDistance {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+ 
+		// input
+		String[] dic = {"hot","dot","dog","lot","log","cog"};
+		String start= "hit";
+		String end = "cog";
+		
+		boolean isFound =new WordDistance().findPath(dic, start, end);
+		System.out.println("isFound: "+ isFound);
+	}
+	
+	
+	boolean findPath( String[] dic,String startWord, String endWord) {
+		
+		boolean isFound =false;
+		
+		boolean[] visited = new boolean[dic.length];
+	 
+		Stack<String> stack = new Stack<String>();
+		stack.push(startWord);
+		
+		while(!stack.isEmpty()) {
+			
+			String word = stack.pop();
+			if( distance( word, endWord)==0) {
+				stack.push(word);
+				System.out.println(stack);
+				isFound= true;
+				break;
+			}
+			
+			for(int i=0;i<dic.length;i++) {
+				
+				if(visited[i] == true) {
+					continue;
+				}
+				
+				int distnace = distance(word, dic[i]);
+				if( distnace == 1) {
+					visited[i] = true;
+					stack.push(word);
+					stack.push(dic[i]);
+					break;
+				}
+			}
+			
+		}
+	 
+		return isFound;
+		
+	}
+	
+	int distance(String word1, String word2) {
+		int distnace =3; // we assume all words has lenight 3
+		for(int i=0;i<word1.length();i++) {
+			if( word1.charAt(i) == word2.charAt(i)) {
+				distnace--;
+			}
+		}
+		
+		return distnace;
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem16/WordSimilar.java b/CodingInterviews/src/com/problem16/WordSimilar.java
new file mode 100644
index 0000000..6d8ec82
--- /dev/null
+++ b/CodingInterviews/src/com/problem16/WordSimilar.java
@@ -0,0 +1,46 @@
+package com.problem16;
+
+import java.util.Arrays;
+
+public class WordSimilar {
+
+	public static void main(String[] args) {
+
+		String  word1 = "loop";
+		String word2 ="pool";
+
+		
+		boolean isSimilar = new WordSimilar().isSimilar(word1, word2);
+		System.out.println("Similar?:" + isSimilar);
+		
+	 
+	}
+	
+	boolean isSimilar(String word1,String word2) {
+		
+		 
+		if(word1.length()!= word2.length()) {
+			return false;
+		}
+		
+		// sort
+		char[] word1Array = word1.toCharArray();
+		Arrays.sort(word1Array);
+		
+		char[] word2Array = word2.toCharArray();
+		Arrays.sort(word2Array);
+		
+		// check if all character are similar
+		for(int i=0;i< word1Array.length ;i++) {
+			
+			if(word1Array[i] != word2Array[i]) {
+				return false;
+			}
+		}
+		
+		return true;
+		
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem17/WordBreak.java b/CodingInterviews/src/com/problem17/WordBreak.java
new file mode 100644
index 0000000..1c0338c
--- /dev/null
+++ b/CodingInterviews/src/com/problem17/WordBreak.java
@@ -0,0 +1,88 @@
+package com.problem17;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+ 
+class Option{
+	
+	int nextIndex;
+	public ArrayList<String>  listOfWords = new ArrayList<String>();
+	
+	public Option(int nextIndex, ArrayList<String>  listOfWords) {
+		
+		this.nextIndex = nextIndex;
+		this.listOfWords.addAll(listOfWords);
+	}
+	
+	
+}
+
+public class WordBreak {
+
+ Set<String> dictionary = new HashSet<>();
+	
+	public WordBreak() {
+
+		dictionary.add("mobile") ;
+		dictionary.add("samsung") ;
+		dictionary.add("sam") ;
+		dictionary.add("sung") ;
+		dictionary.add("man") ;
+		dictionary.add("mango") ;
+		dictionary.add("icecream") ;
+		dictionary.add("and") ;
+		dictionary.add("go") ;
+		dictionary.add("i") ;
+		dictionary.add("like");
+		dictionary.add("ice") ;
+		dictionary.add("cream") ;
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		new WordBreak().breakWordNow("ilikesamsungandmango");
+	}
+	
+	void breakWordNow(String word) {
+		
+		Queue<Option> q = new LinkedList<Option>();
+		
+		q.add( new Option(0,new ArrayList<String>()));
+		
+		while(!q.isEmpty()) {
+			
+			
+			Option option = q.poll();
+			
+			if( option.nextIndex >= word.length()) {
+				
+				System.out.println(option.listOfWords);
+				
+			}
+			
+			for( int i=option.nextIndex;i<=word.length() ;i++ ) {
+				
+				String oneWord = word.substring(option.nextIndex,i);
+				if( dictionary.contains(oneWord)) {
+					
+					Option newOption = new Option(i, option.listOfWords);
+					newOption.listOfWords.add(oneWord);
+					q.add(newOption);
+					
+					
+				}
+				
+				
+			}
+			
+		}
+		
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem18/SprialMatrix.java b/CodingInterviews/src/com/problem18/SprialMatrix.java
new file mode 100644
index 0000000..8725438
--- /dev/null
+++ b/CodingInterviews/src/com/problem18/SprialMatrix.java
@@ -0,0 +1,63 @@
+package com.problem18;
+
+import java.util.ArrayList;
+
+public class SprialMatrix {
+
+	public SprialMatrix() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+
+		int[][] array = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
+		
+		ArrayList<Integer>  listElementasSprial= new SprialMatrix().printSprial(array);
+		for (Integer element : listElementasSprial) {
+			System.out.println(element);
+		}
+	 
+	}
+	
+	ArrayList<Integer> printSprial(int[][] array) {
+		
+		ArrayList<Integer>  sprialList = new ArrayList<Integer>();
+		int firstRow=0;
+		int lastRow= array.length-1;
+		int firstCol= 0;
+		int lastCol= array[0].length-1;
+		
+		while( firstRow<lastRow && firstCol < lastCol) {
+			
+			
+			// up
+			for(int i=firstCol ;i<= lastCol ;i++) {
+				sprialList.add(array[firstRow][i]);
+			}
+			
+			for(int i= firstRow+1 ;i<= lastRow;i++) {
+				sprialList.add(array[i][lastCol]);
+			}
+			
+			for(int i=lastCol-1 ;i >= firstCol ;i--) {
+				sprialList.add(array[lastRow][i]);
+			}
+			
+			for(int i= lastRow-1; i> firstCol ;i--) {
+				sprialList.add(array[i][firstCol]);
+			}
+			firstRow++;
+			lastRow--;
+			firstCol++;
+			lastCol--;
+			
+		}
+		
+		
+		return sprialList;
+		
+		
+	}
+ 
+
+}
diff --git a/CodingInterviews/src/com/problem2/GCell.java b/CodingInterviews/src/com/problem2/GCell.java
new file mode 100644
index 0000000..3f0456f
--- /dev/null
+++ b/CodingInterviews/src/com/problem2/GCell.java
@@ -0,0 +1,22 @@
+package com.problem2;
+
+import java.util.ArrayList;
+
+public class GCell {
+
+	public int rowIndex;
+	public int colIndex;
+	public ArrayList<Integer> listOfCities;
+	public GCell( int rowIndex,int colIndex,ArrayList<Integer> listOfCities) {
+		this.rowIndex = rowIndex;
+		this.colIndex = colIndex;
+		this.listOfCities = new ArrayList<Integer>();
+		if(listOfCities != null) {
+           this.listOfCities.addAll(listOfCities);
+		}
+		this.listOfCities.add(colIndex);
+				
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem2/TripPlaner.java b/CodingInterviews/src/com/problem2/TripPlaner.java
new file mode 100644
index 0000000..548d694
--- /dev/null
+++ b/CodingInterviews/src/com/problem2/TripPlaner.java
@@ -0,0 +1,67 @@
+package com.problem2;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class TripPlaner {
+
+	public static void main(String[] args) {
+		 
+		//We give 9 for post location
+		int[][] grid = {{1,1,1,1,0},{0,1,0,1,0},{0,0,1,1,0}, {0,0,1,1,0},{0,0,0,1,0},
+				 {0,0,0,0,1}};
+		print(grid);
+		
+		Queue<GCell> queue = new LinkedList<GCell>();
+		//Set robot location
+		move(grid,queue, 0,0, null);
+		
+		while ( !queue.isEmpty()) {
+			
+			GCell botCell =  queue.poll();
+			 
+			// down
+			
+			move (grid, queue, botCell.rowIndex + 1, botCell.colIndex, botCell.listOfCities);
+			
+			//right
+			move (grid, queue, botCell.rowIndex + 1, botCell.colIndex+ 1, botCell.listOfCities);
+	 
+		}
+		System.out.println("Not path found");
+		
+	}
+	
+	static void move( int[][] grid, Queue<GCell> queue, int newRow, int newCol, ArrayList<Integer> listOfCities) {
+		
+		// make sure the robot in the grid
+		if( newRow >=0 && newRow < grid.length &&  newCol >= 0 && newCol < grid[0].length) {
+			
+			 if(  grid[newRow][newCol] == 1 && newCol == grid[0].length-1 ) {
+				//path is found
+				 listOfCities.add(newCol);
+				System.out.println("Path is found, Distnace: "+ listOfCities);
+				System.exit(0);
+			}else if ( grid[newRow][newCol] == 1) {
+				 
+				queue.add(new GCell(newRow, newCol, listOfCities));
+				grid[newRow][newCol] = -1; // cell is visited
+			}
+			
+		}
+	}
+
+	static void print( int[][] grid) {
+		
+		for(int i=0;i<grid.length ; i++) {
+			
+			for (int j=0;j<grid[0].length; j++) {
+				System.out.print(grid[i][j] + " ");
+			}
+			System.out.println("");
+		}
+	}
+	
+	
+}
diff --git a/CodingInterviews/src/com/problem20/TopMoviesInStream.java b/CodingInterviews/src/com/problem20/TopMoviesInStream.java
new file mode 100644
index 0000000..71c4c6b
--- /dev/null
+++ b/CodingInterviews/src/com/problem20/TopMoviesInStream.java
@@ -0,0 +1,36 @@
+package com.problem20;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+public class TopMoviesInStream {
+
+	public static void main(String[] args) {
+
+      int[] streamRating = {3,4,5,2,4,5,1,1,2};
+ 
+      
+      kthTopRating(streamRating, 3);
+      
+       
+
+	}
+	
+	static void kthTopRating( int[] streamRating, int k) {
+	      
+	      PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
+	   
+	      // streaming
+	      for(int i=0;i<streamRating.length;i++) {
+	    	  
+	    	  pq.add(streamRating[i]);
+	    	  if(pq.size() > k) {
+	    		  pq.poll();
+	    	  }
+	    	  
+	    	   System.out.println(pq.toString());
+	      }
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem21/MerageLinkedList.java b/CodingInterviews/src/com/problem21/MerageLinkedList.java
new file mode 100644
index 0000000..1afee78
--- /dev/null
+++ b/CodingInterviews/src/com/problem21/MerageLinkedList.java
@@ -0,0 +1,29 @@
+package com.problem21;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+
+import com.linkedList.LinkedListU;
+
+public class MerageLinkedList {
+
+	public static void main(String[] args) {
+ 
+		
+		LinkedList<LinkedList<Integer>> ls = new  LinkedList<LinkedList<Integer>>();
+		ls.add(new LinkedList<Integer>(Arrays.asList(1,2,3,4)));
+		ls.add(new LinkedList<Integer>(Arrays.asList(5,10,15,20)));
+		ls.add(new LinkedList<Integer>(Arrays.asList(50,60,63,77)));
+		
+		mergeLists(  ls);
+	}
+	
+	static void mergeLists(LinkedList<LinkedList<Integer>> ls ) {
+	 
+		 for (LinkedList<Integer> linkedList : ls) {
+			  
+	       System.out.println(linkedList.toString());
+		}
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem3/FindPathBetweenTwoNodes.java b/CodingInterviews/src/com/problem3/FindPathBetweenTwoNodes.java
new file mode 100644
index 0000000..5aa79de
--- /dev/null
+++ b/CodingInterviews/src/com/problem3/FindPathBetweenTwoNodes.java
@@ -0,0 +1,73 @@
+package com.problem3;
+
+import java.util.ArrayList;
+
+import com.bst.BST;
+import com.bst.Node;
+
+public class FindPathBetweenTwoNodes {
+
+	public static void main(String[] args) {
+		 //  build the tree
+		BST bst = new BST();
+		bst.add(8, bst.root);
+		bst.add(5, bst.root);
+		bst.add(10, bst.root);
+		bst.add(9, bst.root);
+		bst.add(11, bst.root);
+		bst.add(5, bst.root);
+		bst.add(4, bst.root);
+		bst.add(6, bst.root);
+		
+		findPath(4, bst.root);
+		findPath(9, bst.root);
+		System.out.println("steps:" + steps);
+		System.out.println("visited Nodes:"+ listVisited);
+		
+	}
+	
+	static int steps =0;
+	static ArrayList<Integer> listVisited = new ArrayList<Integer>();
+	
+	public static void findPath( int searchValue, Node currentNode) {
+		
+		// find path
+		if(! listVisited.contains(currentNode.value)) {
+			listVisited.add(currentNode.value);
+			steps++;
+		}else {
+			steps--;
+		}
+		
+		if( currentNode.value ==  searchValue ) {
+			return;
+		}
+		if( searchValue > currentNode.value) {
+			findPath(searchValue, currentNode.rightNode);
+		}
+		if( searchValue < currentNode.value) {
+			findPath(searchValue, currentNode.leftNode);
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+
+}
diff --git a/CodingInterviews/src/com/problem4/SimilarTree.java b/CodingInterviews/src/com/problem4/SimilarTree.java
new file mode 100644
index 0000000..429a164
--- /dev/null
+++ b/CodingInterviews/src/com/problem4/SimilarTree.java
@@ -0,0 +1,63 @@
+package com.problem4;
+
+import java.util.LinkedList;
+
+import com.bst.BST;
+import com.bst.Node;
+
+public class SimilarTree {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+          BST bst1 = new BST();
+          bst1.add(4, bst1.root);
+          bst1.add(3, bst1.root);
+          bst1.add(6, bst1.root);
+          
+          BST bst2 = new BST();
+          bst2.add(6, bst2.root);
+          bst2.add(3, bst2.root);
+          bst2.add(4, bst2.root);
+          
+          LinkedList<Integer> listOfNodes1 = new LinkedList<Integer>();
+          explore(bst1.root, listOfNodes1);
+          
+          LinkedList<Integer> listOfNodes2 = new LinkedList<Integer>();
+          explore(bst2.root, listOfNodes2);
+          
+          if(listOfNodes1.equals(listOfNodes2)) {
+        	  System.out.println("Trees are equal");
+          }else {
+        	  System.out.println("Trees are not equal");  
+          }
+          System.out.println(listOfNodes1);
+          System.out.println(listOfNodes2);
+          
+          
+          
+	}
+	
+	public static void explore( Node currentNode, LinkedList<Integer> listOfNodes) {
+		
+		if(currentNode== null) {
+			return ;
+		}
+		//print the value
+		explore(currentNode.leftNode, listOfNodes);
+		listOfNodes.add(currentNode.value);
+		explore(currentNode.rightNode, listOfNodes);
+	}
+
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+}
diff --git a/CodingInterviews/src/com/problem5/LCSOnes.java b/CodingInterviews/src/com/problem5/LCSOnes.java
new file mode 100644
index 0000000..051a1da
--- /dev/null
+++ b/CodingInterviews/src/com/problem5/LCSOnes.java
@@ -0,0 +1,68 @@
+package com.problem5;
+
+import java.util.ArrayList;
+
+public class LCSOnes {
+
+	public static void main(String[] args) {
+		 
+		int arr[] = {1,1,0,1,0,1,1,0,1,0}; // input
+		
+		// first convert the problem
+		ArrayList<Integer> list = new ArrayList<Integer>();
+		
+		int sequenceOnesTotal =0;
+		for( int i=0; i<arr.length ;i++) {
+			
+			if(arr[i] ==1) {
+				sequenceOnesTotal++;
+				if(sequenceOnesTotal>0 && i == arr.length-1) {
+					list.add(sequenceOnesTotal);
+				}
+			}else {
+				if(sequenceOnesTotal>0) {
+					list.add(sequenceOnesTotal);
+				}
+				list.add(arr[i]);
+				sequenceOnesTotal = 0;
+			}
+			
+		}
+		
+		System.out.println(list);
+		int maxSequece =0;
+		for(int i=0;i<list.size() ; i=i+2) {
+			
+			int len = list.get(i);
+			if( (i+1)< list.size()) {
+				len+= 1;
+			}
+			if( (i+2)< list.size()) {
+				len+= list.get(i+2);
+			}
+			if(len > maxSequece) {
+				maxSequece = len;
+			}
+			
+		}
+		
+		System.out.println("maxSequece: "+ maxSequece);
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem6/BinarySearch.java b/CodingInterviews/src/com/problem6/BinarySearch.java
new file mode 100644
index 0000000..4c104a6
--- /dev/null
+++ b/CodingInterviews/src/com/problem6/BinarySearch.java
@@ -0,0 +1,52 @@
+package com.problem6;
+
+public class BinarySearch {
+
+	public static void main(String[] args) {
+
+     int arr[]  = { 1,5,10,20,35,40,60,80,90,100};
+     int search =61;
+     
+     // Binary search
+     int low =0;
+     int  high = arr.length -1;
+     int mid =0;
+     boolean isFoud = false;
+     
+     // find elment in Log(N)
+     while(!isFoud) {
+    	// break the loop when element not found
+    	 if(low>high) {
+    		 System.out.println("Element isnot there");
+    		 break;
+    	 }
+    	 mid = low+((high-low)/2);
+    	 if( arr[mid]== search) {
+    		 System.out.println("Element is found");
+    		 break;
+    	 }else if(arr[mid]> search) {
+    		 high = mid -1;
+    	 }else if ( arr[mid]< search) {
+    		 low = mid +1;
+    	 }
+    	 
+    	 
+    	 
+    	 
+     }
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem7/LCS.java b/CodingInterviews/src/com/problem7/LCS.java
new file mode 100644
index 0000000..cb9bbb4
--- /dev/null
+++ b/CodingInterviews/src/com/problem7/LCS.java
@@ -0,0 +1,44 @@
+package com.problem7;
+
+public class LCS {
+
+	public LCS() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+		 
+		String text = "aaabcdeeeefffffgmklmooo";
+		
+		int index =0;
+		char currentChar =  text.charAt(index);
+		index++;
+		int sequence =1;
+		int maxSequence =0;
+		
+		while(index < text.length()) {
+			
+			
+			if(text.charAt(index) != currentChar) {
+				sequence++;
+			}else {
+				 
+				if(sequence > maxSequence) {
+					maxSequence = sequence;
+				}
+	
+			    sequence =1;
+			}
+			currentChar =  text.charAt(index);
+			
+			index++;
+		}
+		System.out.println("max Seququece:" +  maxSequence);
+		
+		
+		
+		
+		
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem8/Stair.java b/CodingInterviews/src/com/problem8/Stair.java
new file mode 100644
index 0000000..70887bf
--- /dev/null
+++ b/CodingInterviews/src/com/problem8/Stair.java
@@ -0,0 +1,15 @@
+package com.problem8;
+
+import java.util.ArrayList;
+
+public class Stair {
+
+	public int number;
+	public  ArrayList<Integer> visited = new ArrayList<Integer>();
+	public Stair( int number, ArrayList<Integer> visited) {
+		this.number = number;
+		this.visited.addAll(visited);
+		this.visited.add(this.number);
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem8/StairCaseDemo.java b/CodingInterviews/src/com/problem8/StairCaseDemo.java
new file mode 100644
index 0000000..5854459
--- /dev/null
+++ b/CodingInterviews/src/com/problem8/StairCaseDemo.java
@@ -0,0 +1,41 @@
+package com.problem8;
+
+import java.util.ArrayList;
+import java.util.Stack;
+
+public class StairCaseDemo {
+
+	public static void main(String[] args) {
+   
+		int step = 5;
+		
+		Stack<Stair> stairStack = new Stack<Stair>();
+		stairStack.add(new Stair(0, new ArrayList<Integer>()));
+		int numberOfTimes =0;
+		while(!stairStack.isEmpty()) {
+			Stair currentStair = stairStack.pop();
+			if(currentStair.number == step) {
+				System.out.println(currentStair.visited);
+				numberOfTimes++;
+				continue;
+			} 
+			
+			int oneStair = currentStair.number +1;
+			if(oneStair <= step) {
+				stairStack.add(new Stair(oneStair, currentStair.visited));
+			}
+			
+			int twoStair = currentStair.number +2;
+			if(twoStair <= step) {
+				stairStack.add(new Stair(twoStair, currentStair.visited));
+			}
+			
+			
+		}
+		
+		System.out.println("numberOfTimes:"+ numberOfTimes);
+		
+
+	}
+
+}
diff --git a/CodingInterviews/src/com/problem9/Parentheses.java b/CodingInterviews/src/com/problem9/Parentheses.java
new file mode 100644
index 0000000..2bd03e5
--- /dev/null
+++ b/CodingInterviews/src/com/problem9/Parentheses.java
@@ -0,0 +1,55 @@
+package com.problem9;
+
+import java.util.Stack;
+
+public class Parentheses {
+
+	public static void main(String[] args) {
+
+    String text = "((()()))";
+    Stack<Character> st1 = new Stack<Character>();
+    for(int i=0;i<text.length();i++) {
+    	st1.push(text.charAt(i));
+    }
+    
+    Stack<Character> st2 = new Stack<Character>();
+    boolean isValid = true;
+    
+    while(!st1.isEmpty()) {
+    	
+    	 char parn = st1.pop();
+    	 
+    	 if(parn == ')') {
+    		 st2.push(parn);
+    	 }else {
+    		 if(st2.isEmpty()) {
+    			 isValid =false;
+    			 break;
+    		 }else {
+    			 st2.pop(); // take one close out
+    		 }
+    		 
+    	 }
+    	
+    }
+    
+    if( isValid && st1.isEmpty()  && st2.isEmpty()) {
+    	System.out.println("Expresion is Valid");
+    }else   {
+    	System.out.println("Expresion is not Valid");
+    }
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+
+}
diff --git a/src/collection/com/HashMapClass.java b/DataStructureAndAlgorithms/src/collection/com/HashMapClass.java
similarity index 100%
rename from src/collection/com/HashMapClass.java
rename to DataStructureAndAlgorithms/src/collection/com/HashMapClass.java
diff --git a/src/collection/com/HashSetClass.java b/DataStructureAndAlgorithms/src/collection/com/HashSetClass.java
similarity index 100%
rename from src/collection/com/HashSetClass.java
rename to DataStructureAndAlgorithms/src/collection/com/HashSetClass.java
diff --git a/src/collection/com/LinkListArrayList.java b/DataStructureAndAlgorithms/src/collection/com/LinkListArrayList.java
similarity index 100%
rename from src/collection/com/LinkListArrayList.java
rename to DataStructureAndAlgorithms/src/collection/com/LinkListArrayList.java
diff --git a/src/collection/com/Student.java b/DataStructureAndAlgorithms/src/collection/com/Student.java
similarity index 100%
rename from src/collection/com/Student.java
rename to DataStructureAndAlgorithms/src/collection/com/Student.java
diff --git a/src/collection/com/TreeSetExample.java b/DataStructureAndAlgorithms/src/collection/com/TreeSetExample.java
similarity index 100%
rename from src/collection/com/TreeSetExample.java
rename to DataStructureAndAlgorithms/src/collection/com/TreeSetExample.java
diff --git a/src/collection/com/VectorExample.java b/DataStructureAndAlgorithms/src/collection/com/VectorExample.java
similarity index 100%
rename from src/collection/com/VectorExample.java
rename to DataStructureAndAlgorithms/src/collection/com/VectorExample.java
diff --git a/src/collection/com/myQueue.java b/DataStructureAndAlgorithms/src/collection/com/myQueue.java
similarity index 100%
rename from src/collection/com/myQueue.java
rename to DataStructureAndAlgorithms/src/collection/com/myQueue.java
diff --git a/src/collection/com/myStack.java b/DataStructureAndAlgorithms/src/collection/com/myStack.java
similarity index 100%
rename from src/collection/com/myStack.java
rename to DataStructureAndAlgorithms/src/collection/com/myStack.java
diff --git a/src/com/ds/DynamicArray.java b/DataStructureAndAlgorithms/src/com/ds/DynamicArray.java
similarity index 100%
rename from src/com/ds/DynamicArray.java
rename to DataStructureAndAlgorithms/src/com/ds/DynamicArray.java
diff --git a/src/com/ds/DynamicArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/DynamicArrayDemo.java
similarity index 100%
rename from src/com/ds/DynamicArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/DynamicArrayDemo.java
diff --git a/src/com/ds/LinkedListD.java b/DataStructureAndAlgorithms/src/com/ds/LinkedListD.java
similarity index 100%
rename from src/com/ds/LinkedListD.java
rename to DataStructureAndAlgorithms/src/com/ds/LinkedListD.java
diff --git a/src/com/ds/LinkedListDDemo.java b/DataStructureAndAlgorithms/src/com/ds/LinkedListDDemo.java
similarity index 100%
rename from src/com/ds/LinkedListDDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/LinkedListDDemo.java
diff --git a/src/com/ds/LinkedListU.java b/DataStructureAndAlgorithms/src/com/ds/LinkedListU.java
similarity index 100%
rename from src/com/ds/LinkedListU.java
rename to DataStructureAndAlgorithms/src/com/ds/LinkedListU.java
diff --git a/src/com/ds/LinkedListUDemo.java b/DataStructureAndAlgorithms/src/com/ds/LinkedListUDemo.java
similarity index 100%
rename from src/com/ds/LinkedListUDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/LinkedListUDemo.java
diff --git a/src/com/ds/Node.java b/DataStructureAndAlgorithms/src/com/ds/Node.java
similarity index 100%
rename from src/com/ds/Node.java
rename to DataStructureAndAlgorithms/src/com/ds/Node.java
diff --git a/src/com/ds/NodeD.java b/DataStructureAndAlgorithms/src/com/ds/NodeD.java
similarity index 100%
rename from src/com/ds/NodeD.java
rename to DataStructureAndAlgorithms/src/com/ds/NodeD.java
diff --git a/src/com/ds/OneDArray.java b/DataStructureAndAlgorithms/src/com/ds/OneDArray.java
similarity index 100%
rename from src/com/ds/OneDArray.java
rename to DataStructureAndAlgorithms/src/com/ds/OneDArray.java
diff --git a/src/com/ds/QueueArray.java b/DataStructureAndAlgorithms/src/com/ds/QueueArray.java
similarity index 100%
rename from src/com/ds/QueueArray.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueArray.java
diff --git a/src/com/ds/QueueArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/QueueArrayDemo.java
similarity index 100%
rename from src/com/ds/QueueArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueArrayDemo.java
diff --git a/src/com/ds/QueueDArray.java b/DataStructureAndAlgorithms/src/com/ds/QueueDArray.java
similarity index 100%
rename from src/com/ds/QueueDArray.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueDArray.java
diff --git a/src/com/ds/QueueDArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/QueueDArrayDemo.java
similarity index 100%
rename from src/com/ds/QueueDArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueDArrayDemo.java
diff --git a/src/com/ds/QueueLinkedList.java b/DataStructureAndAlgorithms/src/com/ds/QueueLinkedList.java
similarity index 100%
rename from src/com/ds/QueueLinkedList.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueLinkedList.java
diff --git a/src/com/ds/QueueLinkedListDemo.java b/DataStructureAndAlgorithms/src/com/ds/QueueLinkedListDemo.java
similarity index 100%
rename from src/com/ds/QueueLinkedListDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/QueueLinkedListDemo.java
diff --git a/src/com/ds/StackArray.java b/DataStructureAndAlgorithms/src/com/ds/StackArray.java
similarity index 100%
rename from src/com/ds/StackArray.java
rename to DataStructureAndAlgorithms/src/com/ds/StackArray.java
diff --git a/src/com/ds/StackArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/StackArrayDemo.java
similarity index 100%
rename from src/com/ds/StackArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/StackArrayDemo.java
diff --git a/src/com/ds/StackDArray.java b/DataStructureAndAlgorithms/src/com/ds/StackDArray.java
similarity index 100%
rename from src/com/ds/StackDArray.java
rename to DataStructureAndAlgorithms/src/com/ds/StackDArray.java
diff --git a/src/com/ds/StackDArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/StackDArrayDemo.java
similarity index 100%
rename from src/com/ds/StackDArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/StackDArrayDemo.java
diff --git a/src/com/ds/StackLinkedList.java b/DataStructureAndAlgorithms/src/com/ds/StackLinkedList.java
similarity index 100%
rename from src/com/ds/StackLinkedList.java
rename to DataStructureAndAlgorithms/src/com/ds/StackLinkedList.java
diff --git a/src/com/ds/StackLinkedListDemo.java b/DataStructureAndAlgorithms/src/com/ds/StackLinkedListDemo.java
similarity index 100%
rename from src/com/ds/StackLinkedListDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/StackLinkedListDemo.java
diff --git a/src/com/ds/Student.java b/DataStructureAndAlgorithms/src/com/ds/Student.java
similarity index 100%
rename from src/com/ds/Student.java
rename to DataStructureAndAlgorithms/src/com/ds/Student.java
diff --git a/src/com/ds/TwoDArray.java b/DataStructureAndAlgorithms/src/com/ds/TwoDArray.java
similarity index 100%
rename from src/com/ds/TwoDArray.java
rename to DataStructureAndAlgorithms/src/com/ds/TwoDArray.java
diff --git a/src/com/ds/hash/Entry.java b/DataStructureAndAlgorithms/src/com/ds/hash/Entry.java
similarity index 100%
rename from src/com/ds/hash/Entry.java
rename to DataStructureAndAlgorithms/src/com/ds/hash/Entry.java
diff --git a/src/com/ds/hash/HashTableArray.java b/DataStructureAndAlgorithms/src/com/ds/hash/HashTableArray.java
similarity index 100%
rename from src/com/ds/hash/HashTableArray.java
rename to DataStructureAndAlgorithms/src/com/ds/hash/HashTableArray.java
diff --git a/src/com/ds/hash/HashTableArrayDemo.java b/DataStructureAndAlgorithms/src/com/ds/hash/HashTableArrayDemo.java
similarity index 100%
rename from src/com/ds/hash/HashTableArrayDemo.java
rename to DataStructureAndAlgorithms/src/com/ds/hash/HashTableArrayDemo.java
diff --git a/src/com/graph/BFSGraph.java b/DataStructureAndAlgorithms/src/com/graph/BFSGraph.java
similarity index 100%
rename from src/com/graph/BFSGraph.java
rename to DataStructureAndAlgorithms/src/com/graph/BFSGraph.java
diff --git a/src/com/graph/BFSGraphDemo.java b/DataStructureAndAlgorithms/src/com/graph/BFSGraphDemo.java
similarity index 100%
rename from src/com/graph/BFSGraphDemo.java
rename to DataStructureAndAlgorithms/src/com/graph/BFSGraphDemo.java
diff --git a/src/com/graph/DFSGraph.java b/DataStructureAndAlgorithms/src/com/graph/DFSGraph.java
similarity index 100%
rename from src/com/graph/DFSGraph.java
rename to DataStructureAndAlgorithms/src/com/graph/DFSGraph.java
diff --git a/src/com/graph/DFSGraphDemo.java b/DataStructureAndAlgorithms/src/com/graph/DFSGraphDemo.java
similarity index 100%
rename from src/com/graph/DFSGraphDemo.java
rename to DataStructureAndAlgorithms/src/com/graph/DFSGraphDemo.java
diff --git a/src/com/graph/Node.java b/DataStructureAndAlgorithms/src/com/graph/Node.java
similarity index 100%
rename from src/com/graph/Node.java
rename to DataStructureAndAlgorithms/src/com/graph/Node.java
diff --git a/src/com/graph/adjList.java b/DataStructureAndAlgorithms/src/com/graph/adjList.java
similarity index 100%
rename from src/com/graph/adjList.java
rename to DataStructureAndAlgorithms/src/com/graph/adjList.java
diff --git a/src/com/search/BinarySearch.java b/DataStructureAndAlgorithms/src/com/search/BinarySearch.java
similarity index 100%
rename from src/com/search/BinarySearch.java
rename to DataStructureAndAlgorithms/src/com/search/BinarySearch.java
diff --git a/src/com/search/DataSet.java b/DataStructureAndAlgorithms/src/com/search/DataSet.java
similarity index 100%
rename from src/com/search/DataSet.java
rename to DataStructureAndAlgorithms/src/com/search/DataSet.java
diff --git a/src/com/search/InterploationSearch.java b/DataStructureAndAlgorithms/src/com/search/InterploationSearch.java
similarity index 100%
rename from src/com/search/InterploationSearch.java
rename to DataStructureAndAlgorithms/src/com/search/InterploationSearch.java
diff --git a/src/com/search/LinearSearch.java b/DataStructureAndAlgorithms/src/com/search/LinearSearch.java
similarity index 100%
rename from src/com/search/LinearSearch.java
rename to DataStructureAndAlgorithms/src/com/search/LinearSearch.java
diff --git a/src/com/sort/BubbleSorting.java b/DataStructureAndAlgorithms/src/com/sort/BubbleSorting.java
similarity index 100%
rename from src/com/sort/BubbleSorting.java
rename to DataStructureAndAlgorithms/src/com/sort/BubbleSorting.java
diff --git a/src/com/sort/HeapSort.java b/DataStructureAndAlgorithms/src/com/sort/HeapSort.java
similarity index 100%
rename from src/com/sort/HeapSort.java
rename to DataStructureAndAlgorithms/src/com/sort/HeapSort.java
diff --git a/src/com/sort/MergeSort.java b/DataStructureAndAlgorithms/src/com/sort/MergeSort.java
similarity index 100%
rename from src/com/sort/MergeSort.java
rename to DataStructureAndAlgorithms/src/com/sort/MergeSort.java
diff --git a/src/com/sort/QuickSorting.java b/DataStructureAndAlgorithms/src/com/sort/QuickSorting.java
similarity index 100%
rename from src/com/sort/QuickSorting.java
rename to DataStructureAndAlgorithms/src/com/sort/QuickSorting.java
diff --git a/src/com/sort/SelectionSorting.java b/DataStructureAndAlgorithms/src/com/sort/SelectionSorting.java
similarity index 100%
rename from src/com/sort/SelectionSorting.java
rename to DataStructureAndAlgorithms/src/com/sort/SelectionSorting.java
diff --git a/src/com/tree/BST.java b/DataStructureAndAlgorithms/src/com/tree/BST.java
similarity index 100%
rename from src/com/tree/BST.java
rename to DataStructureAndAlgorithms/src/com/tree/BST.java
diff --git a/src/com/tree/BSTDemo.java b/DataStructureAndAlgorithms/src/com/tree/BSTDemo.java
similarity index 100%
rename from src/com/tree/BSTDemo.java
rename to DataStructureAndAlgorithms/src/com/tree/BSTDemo.java
diff --git a/src/com/tree/Node.java b/DataStructureAndAlgorithms/src/com/tree/Node.java
similarity index 100%
rename from src/com/tree/Node.java
rename to DataStructureAndAlgorithms/src/com/tree/Node.java
diff --git a/bin/collection/com/HashMapClass.class b/bin/collection/com/HashMapClass.class
deleted file mode 100644
index 31bfe8dce8801a4a8fd3efd49360cfd58d7ef191..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1657
zcmaJ>TXz#x7~LnNog|$~dPPLEAWBMGg0?D}ia-R3q%9H*B6vAX4#}jGnXJhP%lsAp
zfY166tgPkoRezEX;y#m!nE?87F5hK;_wUcYfBg->77i>V1Wwd^*Hty`_+Gx|xAQk-
zx49!bMOSva7Lo$lmV6}huJjuDz5Ny?1*W$h&(W6zj^tLW0?DFZR~Z~Z+Qt;71&)>-
zPwn>F`zp92_gy70U-oO#t;)bL|A?5>O{Xhxviv_T6bRpzjwi63yI&r=Qqh6qH43X$
z3v&X;LPk$JZl0zOR6U9!gDlb+EMnQhlEB<pzvOAvP=SqOcv--DB;B6cduXhbR%2!&
zu|f*3(2*-`M;pjjZJfkw48PN3HZJC33d0l?o~Oi7BcT*l1g5G^OZHPZ&F5{|?77Ck
z85?inErFEsbkMITTA9m52w{{Y6=smbISZ=-v*Yl|u(5`9>N;8lQu~1kDz00K=ma>A
z3l{P$&lq6DwedFIVa%TTp4Jyf2(dmWSlAL+7^|{v&RjDNr|}*xT6lk=c`E&`R&5&}
z;6rB4H<?=+rpfX1w^&Whnkv~Q?DnXlp|xSDul5|bu7V5-NY7vsAKSQW9Gq?_eN*)f
z{i=;3J|RhVI?AgHY`mZ{@j6T(v&Pp2#EL<>VUSAC0E}8LR@+Gc<JL_ZW#d+gZdFZF
z8Ms{=d$>iS_J<nJCNzT1;5P19sEo2YnHU>ifYWAmOs-r`#8N!Gk#|*7)h}(_!&j7T
z%I<DhKu#+ENf|UaaSJb)B!NV;EpU7o-SeZwK@{XiB@6lg)|<TL$pP<oMniu2zW}#m
zc^r*dj1<LliP*ChEo%p~7VZrT4+Jt5zZcZhb;m51x%kdHZ~9TdE_t2`!Y!t_$DD~F
zArz-AY*m~ByOH}4Nbtq=#na+1&s*@GI`<f<pF(zqr(v6OhNnFg;62M<8ZY4}DMtA(
zLMD0ZC&=D=%<Z?9t^b0B`QrnexVx5B=KcEcT{G`f;d_8L4sljs_eX4P9AZP@cWmzb
zjCY@)K$MTx55b)~z?J!H1ANNgXW?&vodG_l!d-zMp8jEcO~Uwk8Y!M>o-<s5Hdg58
zI(;m1!?bvJF(1aU5+*?7J|0j$1s7lA8%9#ZS$vD{m>5aAiFU}_=c`7_A`(wI&PfY(
ai;xx@4;Lt{$V=cM8oV=<-9!_u>GVHuhM6@0

diff --git a/bin/collection/com/HashSetClass.class b/bin/collection/com/HashSetClass.class
deleted file mode 100644
index e14d9b19b116234628a62489485393736350858f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1493
zcmaJ>%Tg0j5Iq+H6XNhnAc_d0pe8(w4}1=wh%YpN5(-OQUBVPxm}IDApk(9TDtEf_
z2VCnSmRe=G_D?Lo!N<8X6G*Dm&F$&i-RE|n?w)VIK79c&jwJ&P0=;?HaqPUO++rs0
z7BY8bc|B))Gmb2m4MYSwHsp@XII_5wSy<Vir$F<BDk^VEpfQzR7KqHat9A^HXfe@*
zW`XvsD%$hgg%!KBBv%|;Af9#e(pi=zrS<SK;;pN)KwtJhDOiLrNL3U_rk-Z^Q^|QH
zRa~>u%LY0HI(@^or<`j3F?66MiY|sP${nTEq=|z##H8iwsz7(D1}!MeN<WF>ut3wY
z+K{_Z9AWS@zjScFiK7@0h$_!6NzX0mgwg?o|L$yfZ?)h!h71hWF_+sddv?LZ37ljC
z?lwv64uX}NdB9RU7G%qUbpR<08%UF~{hF%SCPpyIq>A=40(4d1uj!3t;B@`NK2I^6
z!8rqG1rk1L{i7z%V_d-4(s?+fx{jMYrgdr;O<cld`mW3Jyq^U}fUI3*(;ZdZv{wgc
zSsy6do`DI0gZo8rCTI@FD+Wuq=NgN-;kU;^GKw4IenxYz&Hc2=(i#UO@t4L6G)RZ0
znhu1}oR~)Cu|Hikwkm_#D4lZxJvGL<%=Ex9oG!`wncdy0&h4q1*znPb;L7hrNZ1sS
z!WpX@kbk(2)qvI|^bh~moG0^}b8;(OrdZD1F6HgpO0QdIn3liAr*#i-3@n{{4>a(L
zYs%B0mZ21sO~W4$edn8FJhd5!;s8%GaG-3Z)`B*)^M=9VIl-EE_xdwB9)IALkHixd
zbUzx2_XHx;dVQ^ezPY!EzsIrBk2odp6=M}-_<cd(&F>$)k6+=%XIR9VoF9u%RdD^$
zSbRDVp++oTRxool@)ijO^+amWwBo~k*R@2TYgt4WPm|TOGV?YhdG>LqhY&{^35?Qi
zQQqYLA&VX?;V_<}7b`ddMb9m+{tgDPOA=pDzQUl-%Xm;b<8Bc@ikG;JJ7gw}P29yS
zxmm(>+{1kmzk_~a&oZMq`VLbD{_}hO3w!<#_WT#<_mKWcM1Eq_K!<@;+fPgy;G(B=
K7Zz!4K<*C{s$GZx

diff --git a/bin/collection/com/LinkListArrayList.class b/bin/collection/com/LinkListArrayList.class
deleted file mode 100644
index 1466b91ec83e1ad65762830d33cd6bedd0aaf779..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1367
zcmah|+foxj5IvIwcL}RN5D>h8fSMp7ii%251QZn`USeUPWm!YAg#(*i+-$J;1<N=6
z5q*GCs{8;y%JNK>#Bi~Endv!mx~ETf&#&J<ege3P=LRAI{RPi)>_VVCH&gIRnVfRh
za;h9m`@Y=NhJlzs+p64<8ArM+nJ3GuqzfFGRIUnc3q+HtMS<9?SG41ZqS-<djtI0e
zlD$wVE!+MJx$M{iiJVuE&Z6{{KJS9D;GHT94CMZoN0x7tq;dtilCN`r^T`Lka#ymc
zMFZ^u9o36UpqxxyK^$#pHgTK*p34o@f-ame&@FK6FIg+K(1Tv;k;S4wXR_gqP;)l*
z%ET#wrbV?XH%**jz-d|r`UQ?R#&Xx}qK+6xpMH6eKJ&6<mra~w;qta`yVAr3!uby}
zP$p7@=PRyM#b#VY+Q7)3n&&smfnBmNiVXAfDlC6zn4a=7PpLm(6>M3`8n`Uby}vj!
z73CCd-^3Mx7O5NSFu95TI4<FuZrAuez4e-E#tjQMF~J1o`nv71H0i@i(@?F@d-u_-
z4l!xr7C0(q;Dwj0S2A_Lh1@%sF)&^0<6d<ZW_6~<x)$uXChiGX4(HV_hI-f!>925_
zIu02SfrxZi)$rBogy<G=tfJBxV=LZQ><Xu}y@BvdLu7RAo!rg!+Vl=Jkae`lgPLyB
z|6BvD8uK5#c;2h{1$$2E@6vVPD~{^M;w+dle=rcC#lObY;3>mhaBmvkhWWL69p|dA
z38ICowQE~A%2P9rp_K@o#W-SQ0$+B}wzQ4JLORj$9i0)pOeap(j5=~UM0U_e?%9c0
zPb@JILbQhJ*7>@X46Sb%-od4%#Mm~jrnhi?3)wA9)zG^{dt!CC7QIPpi9&0cV8%Lc
zlc#nn>ZPJVY8j!9Yy9O?L?0r7JUZ|Oohb9Ge?&Jv<3v^eFjZ0`=5U|8iBEVyew4m%
iF;6Q-robcQSg*%q^z$xcE!0^Hb=DKI1fG%?!LvWSgFc%8

diff --git a/bin/collection/com/NodeS.class b/bin/collection/com/NodeS.class
deleted file mode 100644
index e71e7e88898416a14db3470c2af577d6914c1c54..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 766
zcmZ`$O>fgc6r8o)grrWKrfr}tAE6wuT~rH+TdE3FffOl}gQG|sH)d7bI(Fnbs6U8f
zFGv(54u~^93NikWQi*Wbx4X0N&CGlI`_GS`0AAop9h$&akVKIRvM`CgAenim$p_`v
zVF+~2<tOPyGCuR(P0yK9M~(SQ^dy<hWh$qU5-@_~G7}I(9%FUIV{f#Ic_2_b3ga+4
z7TC3it8<(QSx#uA2_2S+b#w%D+nF>V&^1xVo&2<AqJgG>H40;Ox|mH>IxgLGM@b-~
ziA=-%UV%pTF}xILuuIxj<3wP`{*M8+A^6_%GZ|dGmGg>X+a4|3FNZR4hD~~TXyP7r
z1e$)bNCWjI%!jf$PL=Xi_WDZB=8-zgYiYm_&tjP^Qf9pTm+uy`9PrU<pT`6ADXw#^
zLF2D-GK|RQ!kFXhFd19Cy=R8b-EzO9?e5)R!+myx%`b#BY%_LYFg|6pN#LLj7d;~V
zvJ7_%QW6w0f-hDfq)~v)S2AO=<yI{BD>e?eK4Z<e)~^Zag-pAkJESv@zMdBny|Uz%
x#4g1I_KGUe>b#=D{Yt^96dLZqFNkk=kaL$U)R+RU+;(n4!=obh@wnLc{{r)_lJx)p

diff --git a/bin/collection/com/Student.class b/bin/collection/com/Student.class
deleted file mode 100644
index b9ffbbd17c7187233503647b9fd398db8a9c479b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 805
zcmZ`$O>fgc6r8o4xJjHQq-_W^e6-~dJ5qDumZ}m|LW&gN;3^WwjcWx5$F5wbzlQ_I
zT##syI3UjaD8#I7NF?ZCXZ=2QX5RD9U*En1c#dZ#G=a7khoSGKK^zUdcrkF(<%J)m
zCJce*TwcpTD5Kfn?R3s26J>$jb@nV?T*^dFLtns%<bqdgye_+G5=671fG%e&iIG70
zB#46al)Alt8%OqpJZJHRUxki_g&LZC+_NVYklBKXE%mi)p@OPFV;n^Oo8@BaC+E3|
z);RWLIFU)9;v#9J?}ICW&iMbM(qDy>a}fVL7TE9I)o0VcU`O3erT5{rye#<lHb==9
zHMB=n8hv8n0Uioe-FTUJ{;NPO$|_cTtQJLWH<(2-T_!BO+}KG$w2@hF`{XW*r$Zc2
zSLZ1~<8S81h*0|?s(cL=vCilnJ9OR+=PS0I{tfOq-5czDW=g{zu?2%zCYmJJ!ZxwZ
z%+vfC?xVwq1euJ;zLbzg0nS~>%o!^yUFQpS`aB;|(pP_iPbe8HZN<8tX|`z`v{$2A
zoy;9H$<)ep+d0o)-7fZ77wGbZ0j+K|Ur_f^p=%eq6{r6L;uepUNIqDZE#OhZC~F!=
LQh0#F>^}Mpt-qW-

diff --git a/bin/collection/com/TreeSetExample.class b/bin/collection/com/TreeSetExample.class
deleted file mode 100644
index 08af4d98942e122c2386b215d1909603c1f9b594..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1592
zcmaJ>OK%fb6#lL=$=GHfj+3|~5Rw2bc4BaW@SKqH22;n-I5ncIZk$n=F!lszg2;{^
zfLI|Rv0;gX!~z6~3R2ZIKct)f1|Hv?85<8uJBxeoIp;gC@1D6IKfnJAz!YxkhzX3;
zT*t9$p6xaYHMd@vZ(3Hx@-97)^%cj`p$Vjx<$YOjWMiptePNkcfu3o*VS6(IUD;e!
zK)c{BT1j*vVW1m50=*@>VU^eF3s!SpE;yDzy5!cRQ<Y6y$)Qs7?%1mWqow~X!eoNF
zv>O7M?CsLGVk%zKZY-I(s*XN^KHsqB*-op6BvMGkF+le@dEZuI#=sBQ$+G3*qQGFb
zBU;d!nfoJ-VS(<dy)4(`*iGkiJSpcr21YR^5Vt+6DLuET3d#i`{Jh0bZzix8`*rM#
za93Gh^{l#qAMq0laMwuVVBl=Kg&S<eV?&m#o7<4ZgpM3Z`_@w{wt-3HSyaP%zyJfS
z{2jMr>Npfl?DLew&p4vvut2{bHJa4GQA`QwE2<8MR7bdJGp$NHZr}t?5_?Ckmi;O?
z1Z3?r>6nOqW3E3hI;L6bcXwRo$W)RrF{5VY7lGky@%uUOF}&aeVdo5-#|3s?b6459
zD5{1osk$#ynJxNrD4R>1r~WObL?9*|nmVp49CeOYm+kQ~2Rdvmx@i=Qs1b04{Y8g(
zeWf+X2RdBCu+xFcznGA}8Ac07E;29w0iE0`=vFM6Dsa97-Ku_iYeE%#d&QHryR&j7
z{1uZGcdc2oF5Bv7?T@|!ht$Ae93+Y_2N2_lzd2W(Qh~eR-aWC2_-o&s<f_adU>jE>
z0C3+<DS;j6rH0PpIRkZ5_wEByw>J4oOs4xcFnDt^Jrr!Aw9A(^Ff#iB={Fe9|A_+v
zf8*c=3OpYZc=qLA>eHvF2xFBGet>x^bw+IBjB@wIo`{r+ihA3~OsBOM$S~xP7UnYF
z;_L=4D%sEXk7`zfYIY6-T$6~i-CnktVWT5#b3dPr9Qu$)nj_qYi?o#Z1kGb7Y8b*j
z4C5ho;W2jO2|b=-4_<PAi!q<Lsel|@!BxhO;}wdyM(T2SgkKpc#z+#g)OFE+9A)Y>
tTqkyddw{>u#{bsF&$aOt;^v9ZK>LKej+Bn<j!(E9oYM6Doz@ttUjdcac-H^`

diff --git a/bin/collection/com/VectorExample.class b/bin/collection/com/VectorExample.class
deleted file mode 100644
index f3b4137c6691b2c999f0eed54542b27c41fc13ac..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1860
zcmaJ>U2_vv7=BKhvYT|9mQ<(+En84b8cKxXS5vD{S}i6N4Mqzno+hX1X*auZvs+s(
z{2R_VTr$J8&X|re<DFi3p?|=?;>UZ=W}zk2i<~`qzu)J1&-?p7KmP*YGIkC0F`TM-
zjw5P;^xQ(tYZj_>_x!~j-fTI-K!RaplW+5a!`((<Wo?tx48}HnczcT>Q_|WnkWSaN
z$dIhahRcJ{7Yyfm4CW$<4p<3%={Ab<<aA_Cx-yt&=+EY=42cD=E>h^nkcA{t28QEG
z_T@?;jiXARA&2a8u9^hH3l;`&gkiWOU2!99t_lAZUvsFIOv$Tpr^<b){&$6mU_-VU
zCQAPY1l5;la_KT0&)(^+KUXzziecbNi$GIFO;|V$n<2&P^+iWCg-fU%%kJ}xpe!oS
zGt~TwPxuNGFH@8<T|E=$2#O`yNFs|V1G%{U2)EsKAet8PI8RnysG>)~rB}E~m<EKb
z;LW0e3k+jV8H@nG8cL@wd=sx}vhE98wrA}Wrg2H3IrB`dU6yiH)!OS8-oTrLM_b+}
zOo^>!<@mORStuHLt0mkz4HogSuipcSi^}623-frF!3?}eNz`R~UC8zd77Scv7}b3o
z?9jqBRj<)fO*^iMC5F@2#5xb1z^?HYugPH7mTt}0EOZ-9;{yxJstq%?G4UZ)zwU=J
zxM-pr-!GY1iSIKeJ|bu;)VR&p1L505uT)QG);3XL7+;7JM(W<QpIE5kQ%WnMsi4U_
z5jU*|d(jP>!sjYz(Zni4I@KMZw#|JptB@NS#9e%0;BzYG>GRv?Y2hBeWEgbCPVi*>
z4uadAKNW6GQCDM_e%^c@N}&m2pXs4#r~n(!1c-;`&;W|pO$%F!z5z|2YKw;2g-5S<
zgSX3`FXHC)q}`^m<9>rc8-30zBoo?841I#$=~$Gv2UB{%2e-g(E8YY{m4Mf_%DmOx
z45^A2`Zcj6_3k*Z7%wQ;F-hB|pLQvuAFUkv8g%P}Nk4j6NYOb+k_9BR&C#hnSW}OY
zULDxO$d4HPUYj4IGpz#+kl|U3P_W}9vmz&q;YIqF#0k6<1!N)Fsl<QAu}b;O$qvTz
znMr+~)#od8{(x5>V|q1H*u%wq2bVi|tAn`?-isBBk>dR)ihSm}_Acr3#=aOg4~y|}
zPmB(3l_^8!Gs^S`lig%{xPAU7++pZ|XX+iS>ry1i9ER`y{Y$}-fP&*XGP>m?fiR3A
zlBIEyZj&UR#V9HyStXF}5jcWi`G&OLVge6n?LLGJ%86g;`v=ZwDD4O?wD6UV`x|`C
n*8|L;jez(HNv;4-Lg`GpZEH#2-*{voZQ$-W$-X98A9nr&e!j=b

diff --git a/bin/collection/com/myQueue.class b/bin/collection/com/myQueue.class
deleted file mode 100644
index 98b641ae661f2edce55e37c243584757b763e9d3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1625
zcmZ`(OLG%P5dKD%S!uOkA>#+;B_1J?UrK`GgvbUG62KsAKt_%Um$fu@mPotuYL_Z;
z&Mj3r=a?fLp(q<dRVues@dL;|Nd85NZ+3;Xa@m)e?wRhdyT9(4xBvg~Cx98OYKRF8
zSDkuYRz1tH3st94XteM8(w7?I0_jKQW3x~<?Ty0H+9MhX9GJ6g%ey4dm&;cK;#ZxT
z)X|5efqoni7${k`T=W}j(p@&!>QW$6a;j#%V!D>nJBM-aN2?_;TG~5$k;o0xvYB4)
zhf+6-vgca%MloMW;xGm^WO{New_BcU7&w9<=I8iKcPMnWoWdP?di0lOqnN;mKx)lw
zS=H>Os#eEQ9Mdo+Fc<{uwKs4aCj_*nf~Yg8q1;|MX*eZtB=Gk=t6m@zKgn9jYI!<N
zBB|pH&S^L+aJXC0g6+u-=^FS5=NaL#S@-4Ax+;4iABoX1E2facxQ0A=?#2oFWnco6
ztlF&AcI6j#u9$zIoTm*G@Cn&%vg^z?7md=fRAhXnYQC@!QYC@U1r9b{$F;n6$e@NV
z1V*|^k?!C&NKVJBs(%*aYMD-8PGGFZJ-hC>*_P+mr0umdaK3iWWjVY|;0k%V;kR1S
zvUSYk8#Q=W6=M;;I&-p+XR6<^+MCig6Sz*PWVX#D-4+bo#4R4!W+NEVZcjSSyffVm
z4(Z??6DS}y*~l<t(Cwg5&TVY7DR4A$(Zd7{lFhJ`8li`K-$uLn;eDKs00hW$k?KB7
z!zH3kM+|!+?dNb|e}`RfvBP*#h0)87?^fkCOTB2L^G8f8&TtwWJANoYj1oTqt{Sxh
zcfq}Xd>e`9!L`m+U4sTGu109U{UEg@4q<>NbQaGD6zAE0FObd*Z(;NePOfevTbf7@
zyu#_%_&A1@iF7I=>k;|Tj!gfF*O(I6!lw#rCcv5{)|a;@1FS7vT$v1zLP_C-l0s1u
z{U*2YRfy1)GQ}>|;?x_=uVyZ%k8R^?<rC`P_V=jQ;vJQUQ$+j=^Dl9OD2kpwD0&`X
zm}?3Nl9DDZ$4N?#w9HVu!cVV+K`ir!dx#;d)3%8bJi#b_=A-=;WB838zvBd+^2>RJ
zQ}`QMykn34<?o{?9}j6I&TVRG{DVa-k@Sc71$S_lJ$#DGxJRiEWm;sphgQowR`++T
ND!dg~p<N8$zXwVnj~V~~

diff --git a/bin/collection/com/myStack.class b/bin/collection/com/myStack.class
deleted file mode 100644
index cea69387237e0e8d84a0279aa8e0fecacb648d87..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 887
zcmZuvU2hUW6g>m9yWlDm3f5}<Xl>;~yM9!CplM=Ee4=VXLt}gzwi`NiKghC}@B{oo
z`aly+jL-fk;~5q$C@*v8-kCY)+%xy*udm+$?BThAlt9G^J<oMw6$Z8w`nEr6$I|&=
zAR|yXlOLt+$)IPy>7MbD!1BHdRD2+iuGTsNnU~>-n?o8|3rkoQ$hTDBz8?BrH#(AC
z&lM=PLPvTX87ZAli<$UT4FuL&i`kn*_N59aull}qp`sl}D(E$99Rn-mnj8#c<=GR>
zITVmJu}YOMPJ9&%bfIG5D%ObC9}Z3hcB(UQNmI?*|0NUa0>+^XWY3LE+#uwUJBZyV
zi<`J@;MSZu?GcZB3wN+dW5OYQDkqpKwBJ&4OyREdn_AFa3)|S?y?)piSgkH#H&C6&
zpR}Dr9rq111WJ>}=dmq3z%DiSHJwN2%CnvRHI7Ees7LEd3w#ww4XAx3(SBhpzoRn$
zi=+OZpWOcU^8SpQQ`!Rp<l5mda@<!+&xAFdvR&N>ZKE3;Ng%}?$B3)J%w`mfOZ9V@
zpC`vTuKJioT;gg?_ZBWQ%i;?1tmwy|2$o`Od_&>gIj68uER9h<ZWOO2;kpiAu+bP}
z>j&<QQPUJ@Xo_``XgHHuo<tQAZIGf)0!>><psDa7GZR~QgvTU)!c0p_Dtp`sJY_9~
GXTJe7Xvn4j

diff --git a/bin/com/ds/DynamicArray.class b/bin/com/ds/DynamicArray.class
deleted file mode 100644
index a3565e7d368318573853ed45745d6e651e2a5710..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1299
zcmZuxU2hUm5Iq+bw$Lq7C{=;B7QbMtMeE0dtt47w(uCRvNE7Qzx69gYg@wSP;?FUC
z^g$D?#>D;rf0BvDb9ZS=3lH4AGjr$6nKKi9|ND6a;65Iz2nZz2W}{f^6rc4RqhXs*
z+HIq!LJ^4X8*hzb-Eek`8$0`!=?W+{!!?-ls(e1S%wWg<U<rsdf$)m$*ltN6m@jNH
zvf8X!Q3NreA%bWG0v9x>7?Zb24IzZ-Dcg?qqTAT9+ErtxPNYP+X&UuSqisvO?^N79
zyCaY)kDyHw(`R#ft>e7(sDzbjb-BbWb=Pt$9(xid{~&GF$gdSfH5#edyN=;@+vFJL
z8-fUgY^P?uXKJhKr4A<+Hlu7er{OBD3B)X?LxfeMWtg_xqew)eR;pFE8kR$h#4v;e
z$ZNQS%TegKrDEZDOkLNm7rohaG~C7_nVHR2Z{xK<AwObVYlRU`f$@gzoKhNZ)@uWn
zW4$}ICMvFBzF9X~{kcRd&2HPYp4)PAlY`5&D0hXtSE`SOJ1PykFwZW7+|U4jTn(O(
z%i>u=E)e76w6^#{@SD)TL(_xb5Yv@k;5Yt--XIb(28HJs&xn^f$;>1@nxBa&q-af_
z@m!=Oq{#g`Px+N~!unUlk3R9{V~0KO!~kA+2v2%^yfiZ8n`L$YGamnS-eixe#LX;y
zJ_j84fT#T@ePAiXEZgCt^R?fEdQxHzR~V7f>{B=ioz;mQQ??H=FN^3eX>BRnlxm@J
zDpJgoJ4s=uNHR50H+xbyi|e>?rml?nt#P6Ibq|On1<&b+xcNAfJwQ4e+AGauJ|dJU
zNiy-7A1L%kq<ABmWlx~oAqpNv8ZmN6Qm7PVn#Y{SM)y%q*yK?3R0#3S9o_=WO5!eW
g!2xA*eTGZKk0S6FDIxw)p8)RB6X0K<KaL0g0m+Tvy8r+H

diff --git a/bin/com/ds/DynamicArrayDemo.class b/bin/com/ds/DynamicArrayDemo.class
deleted file mode 100644
index bf1162f7c25d1426bd43322c24e1ae95a9818aa4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1367
zcmah}%Tg0T6g?dR6T$$2@DN3f;v*0xDn1FIJT)4?swh>It0rmVU@}QfCRn)k1KhfF
z<yscO0!#KT-05HV2|i9IK?sG#BHh!s@9Ug<I$wWpeF1PC3kEy_y{UXInl46X)@_-y
zQj?A&*Jo5NZ@?=MSe0usnw54Yy125cQm#PLm}Oh;gg`@ha7n;Bolh%28qjQ_5lsT^
z3CmUsrQC{gp2(G~66j3iQ!=|G9ZR2UMz8zADhl)^{!>22)H!L{0zKhpiM=+Gu4CDm
z*x-_Z4uRky(S8Kb>_-=R40H>0?8U}yS7nrAq8G;mj5V1psm15ILVR#viJDtXCpvE8
z1o{cKP$Ks3@IJRHA?&0Xrw}r5x{j{odeK!m6K8Oi(fLYrHQ35W9}|O1BueID2F`H^
zdrejWPL-@|S~)&k5NJ$Vuhpm@0|;x52M_e|j}hH(#Ka|BCb*1pby#IgaUB~qaRpa7
zKUpX!J1x*(kGifdu@7Lxq)2WE_}qN;QlKlmpQu`8KW^cUf!iEM1x7tU6QjCiqo6To
zZ6C%sli94wDccPd<(f)|tRm3`Fk#{@?y+O`t})gPrN*|dHKkK>CSK`eD52mX@(}Q(
zC3766E-Fh{{KYx=dS$K`cGWp_Sm4;c;qPi>g4tS=u1vk0mxY?N{mFdENvSzYi@*Ee
zyBgLUQ5M9>R|t6c#fQVy;3>*oaBm#igzsbJ+Rs&Ag8?mE&8h?UR-T&ChIU#QEF5?%
zNq=l3u)N847YVd{La>a!4V>J@z;fsLO<atWF;vEI8Q03V83~w2dbA$t(RQRq`w<>&
zurtPf8pc1MgNI0e8RKP4zVV2D-SGQAKQ$X(Xf~!O7R`x|s5`h0k%bZ7B*@QG@?w*j
zSLEd_nR!Rw4SH>%6FUgvEBEjGbI?qNs%&8zGd%h54YQadm!Hvx`*^_7#A(-jSMMJ3
V>k%z}cz$8WKtQz8lAy(d`M>8qK#2eV

diff --git a/bin/com/ds/LinkedListD.class b/bin/com/ds/LinkedListD.class
deleted file mode 100644
index 03c1418667302a0227fa3df8c70a211f02f5fce3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1234
zcmZuxT~8W86g|V&3an@qP{CSjYYU4NZS5z<ml~hYHi3}#afOMl!a`uN^#}B~_}oTo
z(k6X1>96SzXxg4xRtw_8&dj}Y?>*<9JMi<*w;ur3@KS?MV4~V=<ZGRL(XtO^t!Q<e
zO$`Bo@dNY7%-2nOFaKuuKvo@rz`itV0<of(veT@|&4NH^-LfrbL%^TORv7l0{s{bt
z>d-I}hQO$fAVLCTM3Fn)#;$Ca&E2{re6d+I>lL$YDcf@foPDb!5WfWK<3_mTV9Igp
zGHvFD`1NwRu)!q1StIpCrg*)rLbjq|N<i;#DuN_t6#JCG>J2%UKs^Npt!yRC>{%VR
zRmTBaesq-Mj*fZd7-_ZTk=5+7zu=Ks@46ZckrL2s`9YPZcqPZI9&Vd0Pn}Rr)}_M>
zt!8yvb@Mok3=9p~fuWU-JC1DV$YF`yH@lo)qSw6D%)f10wo`K2(rgqIxn&)9u@J!u
z9&1<?m~;sZ2I_c%1VLLWw{8mvevwkM+pfwjOU-h;Z%)gqf<U-r?b)W&ZSy*_UVb$!
z|HiP3Tu7O3RPf`w;TqtXZ;5M|)((8`UBoy?#1LoDKhx_+jBCuz3^F6cSPf(J>Ah%-
z;})%n0na2YJ~bq~+9yO**el<We4i8I9MjvzDfA0OjU^(TV0uZ}XGp7!t~uAQ7zA7f
zb3_HPqlgeIiWEk%z#D^H@?@YG&G#@oMnqHklR*@VxJTx`K9(ztQY`PgReisa(vXZZ
zc=1Y*cb*_|LvcDqnncx!(#&0#W|AOr7EJa@6CaXBd3w@3xI+0v6dy^<s?x<1Onkw^
z+$kP?MV?!_n7jD<>%R;scW~2`bA}aCY$%N>p40qcC<&6iS{`zccWcbxKLYQ11Dn0x
T_y`-1G3_Zse0YZE?*8H*eE{J%

diff --git a/bin/com/ds/LinkedListDDemo.class b/bin/com/ds/LinkedListDDemo.class
deleted file mode 100644
index 73ff10043d3b2450821e0b679521e894f2986f9a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 946
zcmZuvSx*yD7(KV8%(M<r+forXaGg?QTySmS1!9b8)C7YuKHYXMb#N9kGd1aN@<|^c
z(ZnC%k20RyL8RK3Z@u??=UaaM`t}3BIyMaC1nRvgaNNY{c;QFocDy9r-c~_mU`n98
zFF#4gmto&|)!kRURA9R8g<iTTkhdGV0#jR&t4heDXrX{<fjQ!+mxG|I;y1GED}hQU
z>PdfB#-8?%gH!1TFA-SiOs?J{av;5s^z8SYzbtmr*bDou#;$?0ME?JC31t*b)C7#@
zgCtR2s3Ua?=deJ|(sc#q?Nf+ZUqm#q$f7S)C{0|X<;x+h%L0YBQYpWPC0sSIJT{b_
zVUnuA!Zlnccr@UA<}++Ba$b{aO2SG8EfY5dX1Z!Giq(><e3f!&HdYKY1gfL{#(!97
zVwFuCXb_)s7$bc$2Ho761xHWbaJ}S!tWDe%u;gB<;*(Nk+_$)KzM9Uevq2g6xq<40
z@e1U8rfL(G!^PCc_c=WHvr~J*`}V0(AG6*hMrkJ+#69)Q(+5)f=k(U}Jg^Loly?f`
zXz{iv4SEi>pf0Q&!Td5xmnd}_{BVZS${tY9&?{mVbByTEp9z+u-uRC4yCa@vvr;|8
ze6w<XBrlBQCCab3Qn_)6Tg^k<*7lvuzNdX%G!I>LZB(uRljUbwphjzv1(%q$nOh}=
nb&`0@Y@4gn<mwp#JitSGCiNrc1)k8;#Iwj#S^_P`a%les_dw1+

diff --git a/bin/com/ds/LinkedListU.class b/bin/com/ds/LinkedListU.class
deleted file mode 100644
index 0f86fecba599a7655263b249fb01ba1b059f12a7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1171
zcmZux+fEZv6kVq+9cDU|0=7_!3aHQvQtuCz@M7ZA04A+Xd>lFx7?@6*c8c-={)9ik
zvj!y5#8(o(#t$&+I@1ALN+##b?0xpyYp;EF`}5DY9{`@=g@TB{bfeWQTivqZc!#!S
zI9>m(f|x++z&tX`uIcTScXki#hA$A?w@pi6!U!STEz7P5#5Wwz@izsc`9hshujtkg
zMM8&yaTP@97(-lOk|g$aueob?YUZwMlig@FOt)@!9BGHnn7{9I1#VsP43tK?%rNA*
zeF@9n5Wi8YRW=EVnieZh=Z)*CDuud&S%JiWCJh;6W%2U@%QrwSc>?`~y2|hc9k->z
zm}h@rr^b#<w-?A8;S*3i`@Mv+FIC@c9B!HIP<Y(3UEAk@VmaNmYaXk3fK>%6L)TF~
z?)r99M;-+VYxT&N?(1?|<u@J2^Q(TxHk%b$SV_kn+|}?9Wd-X3GeJSafjS-`P13f+
zx}JdG(yFaqr(wT#<Ta%Ru3%ke5Kybmo@e^K4v+I2wU?uv-5hmciPI3}^a(DG1os%f
zIVRjyTHA;OXIk+bT2Y)q|4eTbN$$x2IYvaBu?i;X)BDj#VT#uDkY|P#rwHjV_a`DH
z_v&|K-j&2T=C+Eb&@YfEu94^jsWoYzAs5(^I2I7k2ZgH8_)H;zEG8%<i51eyA{P5;
z!y-r^TTW7qGqFf)WT3EBM#;jKxKu=bBdZ`IRV-iizzBPw7iBr8$PINt<Ed1dptAoR
z&__BTJ^c>cyUP5LSczVciH#FXf5H9IDT-gQ##hcLUHtuZU3P}|G|LQg<jnGG7CAnW
mIn&P-GRvsP6wBW<&-(YWa9!*;#U=@R!jK4_@=r*<pZ^0#i_-7_

diff --git a/bin/com/ds/LinkedListUDemo.class b/bin/com/ds/LinkedListUDemo.class
deleted file mode 100644
index 4c3719b7320b5096050fde4d961fa0b1c2aca87b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 946
zcmZuvSx*yD7(KT@XIcj+rBuWXT&ENn7hGF-(HLVIH9>2PPq&>*9h`;COilWmeA0)K
zXyOm>M;XuUAX4qix88fc^DRGreft4m3)=>A0@ZF5IBw#!yzrxPTV9gBd7^^Iz_dVV
zUw)E~FT<Ymva_$csX)Hzg<iTNFlE=;0@IHpR~0dZf`u961?GvPUi5>GieJl)uLR1i
zs4M-pj6Lli1*g*wULvsEnq0j><Uo2M>DljFe_8CNu^09lwYGr;BLDxnh!P4WDgwr{
zev&9J)RC%%(^w{F>AC_-_6fwSFCv;)VbSL*lqSy6^5uZm1%a8jQYpWHRa`Q#Ha3*q
zL6WM#!ev|`c+}^7mNINFa$b>YO2SG84HMS{W;<#xiq)#Ce3f!&Hr5T)1QtjAjsLJv
z#|E1?&>%kNFh=@#47#~Z3yz+=;d;pdS(~^eV9C8y#mA*exMOkSe3j3tvq2g6xPiq9
z;}yvHOjRZ<hl{C>?{jeQXQ%dr_stWdK4QH?jN)$8kGtxrrw^p^&*^RId0-73Den}>
z(c*1U8uT1$K|Qm62=mJ*U8K}$@WUxeD|<jaORs=A%rl}te<oOtdiy&{?+$sI_448n
zOZD=Zkvuz+=PAG9V)^P2*Xu*v(Du#DzO8*-bPBrY=BQjACc)<@D=fCc%qrtH%Wsgt
n7Bde>poxXi>uN>-cX5vhCiQ*h1s>AV#IwjFS^^Ema%lbr+^Wv7

diff --git a/bin/com/ds/Node.class b/bin/com/ds/Node.class
deleted file mode 100644
index cf748321ccbaea63a63240d23e828c16899dc1c3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 402
zcmZWlyH3ME5S+6eJ9eBH!m|XbBp}?-foPDZtWba~QJ$R>IC5;su_JzqB0{3z1NbP!
zoT1>M(~WlbW@mQq{p0lwz!~-(7y`YtT!gb_I4x(&fhDjpmn#|OvUmt@lDSH2fzC?i
zjS?6}f8WjptU^7J(~o`#v20&tMOI%59F6{W{o;;eid@m&gNeQm7XtxvG>%<x8Xq0l
zIvV<L&=m-xtWeWtk*MlUCV4wnnaVttRi^XrqE$a;O9Ah;Y^qdUXPW5hB~SGZIHaP<
zZ!maiK!lbj3LY08vB&J549yEBFYqVFYX&E4Y(BGOV2e0}MYM?y+qxJKw^=#(YQs(|
TN`cl!@Fi%C3>xe*GqCpwBW6i#

diff --git a/bin/com/ds/NodeD.class b/bin/com/ds/NodeD.class
deleted file mode 100644
index 0efdecd4490bfb18dc1bee1e29b4f447bb89e3df..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 468
zcmZXQ%TB^T7=_QY<yI>oRJ^U+LA^94?lf*Rt_UtP?1wVZA*D5i5?{*&F>&Do_)x|(
zm4#>~^IvDa^Ur*Ky?+2W$3X>_fET6Ha6AhK=~&%V;0QD)av{T5CXeCWXriLIKxrZ4
zTnV)Le|r}KPNH6Trr!TeV!isDsfAASnLzncCwhJ*aMt}#SiiTP^@ikMb2Jw=>K<G)
z1nh2aScAZphZ4#rYI~@lYNBlqHB<!}eVwR5J{_s-L5|{L_B4|5P-fcXtD-Z1(wxt|
zPxCBNx7r+Zi?28}FU28|Hh;@(YSF?d6`nfug3HAQt;Z~e1&7`b-mn=QEzt~)muLki
xOZcy>Tj<bs$TA#<gc?_!gf<yFtOh^#vAa_73thpEUnpBeWVCH+?lH5l{|#n9ROSEx

diff --git a/bin/com/ds/OneDArray.class b/bin/com/ds/OneDArray.class
deleted file mode 100644
index c0ce63fa9d66f5a1cc7e04734ea7a89326c0354c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1336
zcmZ`&-BMFm6#jN{l6^Qth=G7;Y8zYIgaD~ZDH5^8A1X8uYZQm!rki9>JT^IDk`qVn
zyzmYB1Ul34rZd`3C(LNe1N5Tr;sYpt`w-g^=*?dH+w1pRYwf?^zT5>cjWvmoK)ljy
z<g4v`$<x;sS}nCLVe$38dZ6-k<<;_~&HK9I3q&uup6g#02xqcu0@l@LRXYfyFNO%B
z0)s`@)2p4vrf%I<n{_RaC^jpqzNT8P!M#Vzzvs4%?qJ>mV>XoQ35;YmivQ&=`z_b2
z6|!r6IF2ES#0S-tx7)sM#4wB`D{FRGXma1#ZRT&%)2F{yje>(wj7gjj7z$#4sE*+z
zP6@~@<56b~R%R*727M$j&?~g;cdFX+ZG23-d!2S$yPks-(uV&TQ}yAZ8N<eBjJB*j
zW#e<+ifWs;j6meB(z-4&E--qK?UjyOuj-bK3EFw8q30ZAF=aC4N$`kFradW~i{U&j
zFpKdqO+FZyZOG!Q7-sM_C#tr#v{x0FJSyNJ-(FD#8y8vC#6nHanVf|fE@7U{S2d;-
zOD4lNCd0P^DR%LH;~2v$F<iwp0o!lx&sktNbJ!)A-l7>2>07E*;|2{Ku_T;~7i=K)
zp^YV$<1%)8e{y^~zVUwTdeh|6$)1{Pby#_<?5oO8D{3p)UWsLi8xku5PPy4>RrI23
z7JcB~&ogBjjx^W~{xKlL8-E8+NtCA)l#%fr*uMp8ho@144*fi1`v#Q9i25*qLB7yg
zbZBRSys-atin(xnxRkT(QZ5pAO1Wq}TFS|Ie<?iw41>QTo=Z)2G4ePhQn}qHd#~kR
zNUcnSUm>-gI2}K=gHOs6R)9W@1RxTCvsM720r(;ufc3fP?o1>+V?D#Uv1rmdzsm5h
zkX=vYb}%{l2fplLIx)+G_qi@Ecd^jL^~aV-TFJ<hy?+ePFbvOI{G}iV3pSbck)eYG
zS&x!!iYQIC<CGWpI*TDJ(!Pu&e#8hGw0eXS_!(n(O8E=%b9$McO|!-93%<h*N(;YY
z3Crx-Y5IPTc@AL~4^hMlZ;x;mt0=Leo3u^CdV{pY52AmM22$b{fn-)8%!x^cxlO|m
G?z{t+V;{u;

diff --git a/bin/com/ds/QueueArray.class b/bin/com/ds/QueueArray.class
deleted file mode 100644
index 84be988a270449ab9a678385c547434aa79f9250..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1635
zcmZvb>vG#v6ouEZmH1MnN$e<28`3(V7h8cEO2VZMf!+cEw*j2-422)ajv7>C$;fgU
z^CAqtfZ+vNhNKKL@Blm%!`hM>J2m6c?VNq~`u5t}|NQ&s-vBmnKZBIQe8=zB4*IoE
z2ll|e83fia15IJ>k@eWBxt4cW+iO3vJE1~8+Ku8AieEHdjHoMUpV?NRpmr6eb^_ny
zDXs5(Z!1i1Ii3@4^SiQJZSis2Kd|#iV^+r*%qgTR)m9D)1s!>0<!wR76sF~EQAaLb
zThft1R$;c`c=r84w`~XeR@<dOq2YHdw`B#6d?$-q__fm~Y-6HG!Y-aZG3-4*wKN&N
zwZC8A=9y`yzcX-M1*1|OGvJo*ySC-k^H{^B3|^+KBX^Qb9hY%MA@kUB2ln1W>Q^58
zUk-(tW@vT3xo7o~DzZ-hZnx)#L%N#SZ&b$A;|A5MtvtPYMaM;y1>~BJ8eUV-+c8~B
zgd?LL<ZvAu8N6|-&&^>!w7WVs@g}4E0h?#UDvn?KByha283wl1t!MEzA-|P@DLei0
zLmHCD4QypVhl)|*r%&j37i@i|CrMmS+#ADZR>wOeJ|jH)yIn#^J4Xg4^>O=-oz%Z@
z%KnppT+=!9tZ)#p&Z$b3O%qFYbW~8z;zNbAC)9SgCx+(YvwKo)n(-X-rauTe_KqV{
zH5=(ggMUqc6e?T$HzwJ(Czr5F=`{ao8ZQnq?~vh*o*d`s$x-KXijila^FG6`AyWJS
z7tLolYc3yQ-ZX#5{9i~Pp=hR#V92fXlp$%H<NbV;JWHV*e|ao0**T`Wz;x%izZj>(
zGG5{r6U#r0Vk>+XQCV4LH2BWhNie=-cG)XYT&{WT;AdpDKd|~FEjMmyk^FQNHWx|7
z=}L*zNI+IZ;3_YsE$|3ik|?#wCrT?+F;YLVNIpgNS7alpNc080;+Wpbgr2O7=`AsT
z6=tIM3lYTNP4gJ*$9VNe=)d9h!du69=c)NQb+xbPF98IkwB8h)6l*ux07Gn#>t2g`
zw@5QfC}0UfB)V5=bB%8sBpBJhnJ`io@8Nx-jNFmE=d>D9MKR_kZV~b})l#?<&BYH1
zwn^-}5%!E=e?V;YB%w8~H>3hXDlpbZJ&H%9Ox9Jhu5m;zQSmaHaAl0qOc*b4EOt*A
a<MEL_VT|`aB4N_Y1p<B?VKx%nd;bCMxhSsy

diff --git a/bin/com/ds/QueueArrayDemo.class b/bin/com/ds/QueueArrayDemo.class
deleted file mode 100644
index 37f5bc9761f58371d88b7331d0c5837b93e2ba53..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1141
zcmZ{jYflqF7=_Q!mTlKn3WefbQHxtDtP0*JqFgi~X+(o*LX01lcBo6*-LmYG@U!$o
zF_QQLjK9fvrn^8Z_+_r|yz`th@BI4n<0pVQywNZqFjn(gR(;R<5Xw+4`M!OyDqEh0
zq(FAZ-nXr$?KZ6StsPkl1O^uz*9jH{5@xX~kX-TVQbz(A11Ss&3{@Ogz6)Dh(*J00
zHKo8v#jDxPs_i>!9xo<?FV3F8c;(#7%S_y|9akW4eyW^8Yy`gJHp<1ShGBu>GiP;V
zky9X}Okl1Rt2*+ytYMtNr&-qAKsKar;0mq^X!~|El<V8-uC-#%WpP+pCB1Io25t(Z
zx+c*xvnMdJhEy5c#vKh4ea3AZ>;<xA;4bdbG%uuwW6@#9v))rrKvmLil{HM#kW<V^
z>~iQd>(WodB<iZ%<s;4OC}2v-Ed4`r;*VmUHZTLLdn%?LHGB2N*ecm01CKGw$F<vS
z>DC3N&(qf<xsQzw74XEsQ#=z$2VS%((0^UbrsD-DbzUIXmD+EDfdwT>Yb#%xeE+2F
zH&`dRbE-f<>~iO91+jYa{WW*cKCV0SZ1_TtuH!dfWDb493;mjW>!>2m_5Y3;#f}N^
zMfsC}0ghPyY&Fg-_JVzC>JaI#-EEz%+6E6?U~5DH>@RYb!6giFMIHW)B+~)gN62ob
z5BYsc>F*fp;94ma_k(etJsHFi-*D>)h0T%shbWdhc+kPa4(2*|{@)Enmw=+1B!yzk
zkYX5VevS+U>X;($EIBJAmE=_P`G^oNvB+5lpYaN>$-l&zQWmW&b0o0BwE?XD1>o5U
A{Qv*}

diff --git a/bin/com/ds/QueueDArray.class b/bin/com/ds/QueueDArray.class
deleted file mode 100644
index 280a1dde8c0281b4039435a75524ec0ad9140fac..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2030
zcmZuxZF3V<6n<{rn{Hpzw6tkUTM(0NAyDy+lqhYfRs#i6qf|ezP1mxRY+|y(iGRY6
zj-Patk9<If7RDL*0sbUsbbQY4LbkM%$?m=9-gBPkJm;MK`@cV50Jw~uI6?}e)kZzP
z*UsPWm>qNdTB~Jr<A^8>KQJB|`I=$x=eKqrm{mt1>7Ke56;fZ8UcXULh}<!amV(+;
zh;FnRHoYQk>w8lnwqn_qQ{+ConXB-%*4Q(X2xCY?KZX^;*<7U$B%~pUgsjFiL=ltK
zxQ0H@c1lAW35B7OWt%rU^<A^IZS2+vFj{I<jatQMS+e(y5$C?uW~9>bEXj8Ks7tr`
z(rxmD`zzbqg(96|R(qpUt0|<jxqt+#jYiEh>_QR?I2*?qg^`{<{-K69a84oq(5Q9H
zt*=QSyK_<ug@LkTRKK}lH2pjhR{MIrS#!G7)h|Fg8$kC;RLE75RBK7Yd1wlQrrqwe
z%r&EFR4s9h+vazhj#(G6dgOdx@w}vA8E^68zUh?Rvau?gNxY4B<9O#~Q*<1wmUnxh
zt>HbqPfe<gW>*r*Wlv~}&D;q_h5ou__qg>pYI}hlnf7+^b<<CJ?1<(*bA`ULwQm~^
zlche{94jT+tZK+&P71QF;W{=Hv|X=C6)Aw*ayxza7@x$!h7ELlx!a~p8a_pdw;CO`
zaoSVNYUFRVEZZqNEz_tM61Yj7zm?gUv)XfJz3Ft5xP?1$+~$n9A|G|pP{uYDZc3Dz
zEo~I21;bkQKI_PwyzI6FJj{$Zf8|D}RW&y(Y4>4Q5pQ5G2#!K_W&27Xmak6nxC!%A
zC(MsPgny10pOCR~-yAge%^`HHEEF`}AK<Qw5P!gF{TT-J%mGGp{V7KNLihkFJ#>Jy
zJSKkUl`tmxoN|Nr6G$d_0Am=WeF(D{<{2>Vg+m6@+%d4sKEY<V7ErNdcpF@w#+*;%
zD@K>I34+UiB(nDl5|QVae-f4lk0LI7%)OR!p}cStK2#4tECTQ*{|q}y7j})0v`c=1
zG((hh=w~L$x1j!pgbU?@zJ@m*z?(USCzb%-DaOx1_wjxp1rc~jbe)LaJH(=Xm#fG<
z%1V>qPb`-COoy1VPTkX@wwJD__9Qi&qS690jdRp;k*l8COFku{-~#eQ?uj910dk8x
z<fp_Z_lV@AV;1y7T)di@euSy%=>6hM=2t{BMPZzpd5+6$g&w6@_7x~+lszYtIEXVy
z;Vjbp6wXs~p{09KU(s5?6}JhZBv#-mM6VQ9xC#fTE(EA15&9QtrT$^BD*1%@j92-V
z^2LPPi^p7fZRzzzE>NeKkKU6)EMDVXMUfmnpmzu#x^wWOUnZSOTsy?tPZ;<EAC2BP
z#Fly@SW=+nl9VnjrAsgNdeSS>64f}5Q5Ikf7m0I;O}88<lJ4`FrTU+}Dv~!Yawg2Y
UvkEixdv}ZkKX++<;nThQKRknF*Z=?k

diff --git a/bin/com/ds/QueueDArrayDemo.class b/bin/com/ds/QueueDArrayDemo.class
deleted file mode 100644
index f539fe1c90981a11d5c340642c15a4ba24152a1e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1092
zcmah|TW=Ck5dIFAE^JpzxwYDQX%$_HcD>-OAhj);kdRh`!8ATCaKvqvU0imX)PJQ9
zpf>Rb_@j(-SSnCSe3^4*&Ro84X3nqQKYjwp<E4ZEL%L~qv{p}h<8hCdcN|AQDf5mk
zA;b_n(vNk`)UCF5&^Y2vmtn4GScY3-2&&mSLuk)#aT!5G6@)RzuuwHDzVCG!+<B`v
zOwJIm+D+Z8>y9Dxkul_cG<pon)!Eexl)0lD7Qs{BSH~!7u47p3Lbfhpkuv`qEF*@5
zfRdyPY9(8jk;bxwC5FXunu_J}Hg^<U!es{OST{X>@Ie%-WGAYP+zKM;s)8%H$`Bs*
zi6Ny<IQq>YSW#TZx`ef<*40jWF7GI~ft%De+oLX~{9wb@UK1ggXmPz$kZ_A(X$;e6
zyXzTdi#rjhRJ~?==36o{*bpRh=WzUOk3f7^!6r1K*XFJW8;-0ZV(%+>fQK|oz1!th
zi(z$|_f%bCpTQ#qkMV>d;@bWrLsFe=)u^(JXCN9|42dC)X@Uxh0<zQ<oJ|^TNO#(_
z1&J9WW?-MF$c+7<-AGTb)JgYjt+F%xixY!7n`nuW$Tiz@n*5a^mNa>8{Wk@Ctbv+F
ze+3B8jrN<QM4Cn?qcglQK;+BtStco-K>_n572ko*3#3JH5esAy!QT<0bilh)#16v)
z`X9O2{5PcfSjoi{|MC^rPLVl`-yR^F>*G!z_xi~9@$~;50!|PD&N?C_r6KMp-Qxsf
rg<kRm@Hqji6Ep!e?ZY8kiL@y8v5gl5c84@U!?*0xjbV>$0hIp$F6H_Z

diff --git a/bin/com/ds/QueueLinkedList.class b/bin/com/ds/QueueLinkedList.class
deleted file mode 100644
index 17a72f681035e0cb90064290b2195f85d12b0fca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1343
zcmZ`&TT@a|7+o8YBX|JwLSllTT>wq;l9dqY<oJYk!LjM_h<ofP9O!Vc{6)Q5quJC<
zZ`n-0$!S`fgJWntoNw>_UG}%u+TZ#0`|EcA^H|d05r~v))$Dd7`=TkEvS?a+a=U0Y
z91UK9zFlMA$W{z%C;Mz`SC$<C?@MXe0-<8NY`wNES8@W~t9H#|+?O{k(<umarP7;B
zf690OUC?#(!0!i3b#%k0c6~ZD_yodiE7zOVEopBUTNNqLU#yjl%BEqP>fCmEoi}Df
zVEDZCCBy^~=`1^_pO?n|Q<LA=$Q2a&)?ETasp4hIx%8%n5dr;g!U04vsu;xtX8uug
z-p*C0^OWB7vwBQNLUH$6^1Y)R<2ojkqo;1meY4gi)9!tv(rl@51(bkh$#?2{fndoo
z%6n@@y{(hBBHyaV6c|jUuksP_m&_f@aGEw#x>IRt;KyBLHB5IrdFi0x$f}NenBjBQ
znta_M_d2tdeQukUQ*vx+RC7I;<0H0uCd@`cR_hh#Ab|ULpkYB^poPA(M#n=uB8j@X
zrea-Ep7)y84wYBJ<aFG`Eg~RJfk3I&w99hURAVxDX#}QKCxKLcWAQ5Q!c`ZNoWd^t
z3?6<QN?NFqr0rsa14|p==@l~s*Kp<py%}+gpfcf)t;B1z{qWNIXf+n~AVk|wkM5RX
z0E0XYb$B8?30%i;yU7niP+*q7A^Lh!h!fmc%N!wiiU61JPxNJ`RA-v-2gIg`AU>rM
zj*(Og{qa_Yg5`yRm1&{xMK6Iw5k#E8CJ@GLMkfhyj=*w+wuDFvZo&o7hD#_)dcy0)
z0&9F!;ex_4vlN9p{P>5TA*vy&N12^Mnwc5;J?x_N`@)^lIN!l1_z6?}v!5|94i&*8
zEEY5FCQgcKcS^OnkZE%Ako7LBaS9B|79ytzMz|a0&lF>?IA$@1MV^%S5w~ZXO@di2
g8^z%wrZ~8<Jh8Xgg#2enYE;96$BcVWX!CjU2i7?Vc>n+a

diff --git a/bin/com/ds/QueueLinkedListDemo.class b/bin/com/ds/QueueLinkedListDemo.class
deleted file mode 100644
index bccce68960624ccad51706bf3ec02b1c7199abf2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 963
zcma)4+iufP5S){nonYFK8zGeYrMZ-vOMr(|l@Jw0$ZA1Bkq}Q#aui%*yNw;Bd=@;U
z0wlyUABC9X6lg>u@v`gP<1=Swc7Oc*@(n-}k2S;uDm~vd`+@mtEXUGvy!WziIYGE1
zU0*{&AbVhcu+5?E4b1)Sf$W6>sV&EI!fk<gwbl_xJoWoBgE-O#l1K@x5=QQg-L4$H
zw!1?qkhA=rJ?z*cN7X0IMEK4L1lFwO3|d5YZO0QRRo_~FnY6=^;|*H1j)rqQTMUpv
z7HJ&?V!V)^t;&*t^C$}>Beep>>M78fJc8<|@Q!6qY#nO?+VgP`NXJX#GOlX4GUrKq
z5`@w<a1Gb#hd-u0#TlmKn=i>SBv)y>E%p3O1GjLSh&%E~*)340*8XLnp*sIYq&9;(
zHZ(K@@{tkq_y+D^lgNka$srA!llI3i>as@zx}INPr+_#TC@+}@XHl9T<K*!7C^wee
z**Ycegu^y*GHri6>d9x0+Kuvp&D&H8=_xJcssb^7akUsVRwlDxPS%g1e~gYZjOrM?
zaE8&C{lI*dRT?W;Wk+59Ot2X9{#Rt*9CI@px%?ExM(#osFEW0@rN$IDzGHog+J6>`
zMjVPpJ&GwL$XMr-D~ttFsF2t?2{lRS3A=k-2t~CtqeE49S?SotJ=`bR2dtEgS*OV_
KfrsqH@aPxgh}{za

diff --git a/bin/com/ds/StackArray.class b/bin/com/ds/StackArray.class
deleted file mode 100644
index bbf5f273762505b94e9f03f279e3dd63c324fc77..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1556
zcmaJ=+j7%Z6kW%5;!EWuIL1j62%&`{D-^f1K*4Fsr36w8bjBGo&_19zB8bY8#*$&&
zU+4#Pc;gd*A!(;G^aJ`)9o9Y;c7i*VM(0Rp-_}}t>z{xB`WwL4xRpgp;ZQs1)V8Bq
zGq&5mT<Lc0eij*pnJ4yByXM*cPVMg26Q><36tq?QDa`)V_|T)Skcr%19R;<akdA{;
zVRF^=-FS@_bEDegb}iU;3P@whKmpTqGpnsU2*W@YIeD8kFo8*VJ8U42oWgX&^_@Gt
z&X&{Nw6{DKC^dq%?X~Q#E8odsCVuQjjBkuFBC^WCh<^A!YJS{(b#t@6CTzl9^q4Tr
zajMl;fdG#gSjKU(bffj2=ZR}|pYPQm@EqH(7w{=gW^sZnN17!@1E1lPg0VI5ZP{Lr
z{HV%<JgQj9!aC54W<QFZj)BwooL)hXZ8<!s=mxbPyRIKM<E~?O>N(UDijg#R*^QPT
z5ncgb;;SsqQX&oGV1&VmIH!;eC5h*MK$}@zf2S@j%=*r=4T6v^jOYx8grXJofZVo2
z-4&sJ$v_>e416l&?ml8O%m@Fa6B&gvH01*-4m0PQ?v8KAy)FfsFsp2m^x&$2Ytn<9
z8(r^&Ufj>&y28|uxzh>bK6~kE$Z1A#lAA%V+jiDnnWbqBSkLwu;iF)#ZeALvwl;o*
z;{=fA&m<3rmMdh8_0G}dK0%KHKH_TdD@2MnuweaxqP4h-8OwTunYT#qqGY9ZQGP{h
z8WpY;#!9vf^W=G#ndf6>n$tF&1@k<SYe834+`&3ZpUh*CyTTD1O{)LK%o1l>dsy1T
zC(mKLhFLnZhc8}P_urtLc}N5VRN_-!X$qE%#<HNfP025d5@s;V^(fa<L^Z-=4)K^c
zj|;3i!Xq}p^9`Rg)GUqsbrN7d%MlH8Qdb1YY`;J*^CvF8Ov^IFF{#}uy5@lATvBsX
zNlx}vDlz0+tdaP4Oq0T8-H6{4DJ)8HMN3f>DZZx^>g9U{&Nc?BY*Uq$5r}~p3lw9K
zG8~}<OT3T4B%_fSRsw8^_11@CRCEKxCJ+a<8$_7MQsyhCnX638Jvxglx*e(iQ{==x
WMM`6e$jLrMicEV`Yq61N^20m%M;UAY

diff --git a/bin/com/ds/StackArrayDemo.class b/bin/com/ds/StackArrayDemo.class
deleted file mode 100644
index 3cda94a0ca89983a0f0101e02d27c51e56c5a72c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1082
zcmZuv+fEZv6kVqjrX8m+P+C;Hp{P?Tj3VNt6{KDgk}4)OHHt5%<yZ#img$tFpW+wz
ztPjO#;s^K-euF<?)O|W_Xj5L!zMj3;-h2K0`|SsSHEbz}F=XnVW9~K0O33RUwt|4S
zp9sfO5NFU2_#roK?l#Pw+JUHt3=>7mwZaXCF(X%Hh(GrBgo-gFHH>3|VXADo;zi4;
ziQpBl*@9uF?A5tl<$)#bo--cqTTO<!@`=q0RM_E`%aAp8%f}!pVPLt9LawS{nqhk6
zuL>P$31pTE7~8q3iY!hmn4{$5D%)--8Y0ke24@+RLvFXk&U@KwJ2%j*msXHP&uKW1
z3slr^HTP*{#z0=Q83L8WC0tgpFtoQyyBP{c!xb#j&b$__FcW>YJo6=u6VgzEJKZ+d
zG+c*4dA{c}%o>AmdTmrJ;f8`dL%KWBa1{;95~kwI!nP}+n;LH77DK{nK6QLMY)klq
zg-f1i3+@tt+qk1(ZD?1$poVqaWzcF-ZdI<VOM$nv6CO0^l<5-=#Sm-K!0FK|(}lCc
zylDG<ZWyEK#eseI@3KKPQeDzM=YEe?YQ<{>b@9xS#7hq|dPVLF3n1LYejr8~QI=kX
zER!T7Ilgp+#OH2UrB{YQA5PJ$MF}KRWF;|)De}nAzbGR{^4)jnZxTmD`Mj=vMW%!K
zysq_?R9~6wD^q<%kCabHeZj?i2Uk1Dkyz<q_2a+a((zhiibG;rB?J;#l6ub|fqBvv
zDY8r`*D1D1_)3JXOtMN0*rhCqKO14hJ=`ZNi3%Q|Kob<nlCwpghoo(E<FP*|DbSPT
K*d#{`kNyLlf%4J-

diff --git a/bin/com/ds/StackDArray.class b/bin/com/ds/StackDArray.class
deleted file mode 100644
index f9a604cdbaa255f1a5cf709c633ae02117fb8800..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1943
zcmaJ>ZF3q`6n-ucNXRBdLSCBprmY2Hi;eFkMVqwIC~c}lI#xe)L)K&~>>|6=!9U{o
z&2jqC57lX6#~J$r{7Idu<8$tA0x20`xG(44d!FY!=N$g|_pj#w-p0KIA`0o6+bHaM
zg^F+1zPov&)iOH?#1v8w%|~XTZaRB~t(}Kf%~we3Q+-ik?CbKYH;M`|&;HR;P@4)-
z-)$<yS8d1kOFYSL=Bk|5-CZk*C`Jt=afa8jx#|!UUNexupsdCW3?MG6aRWmbR5(+%
z9qUfJv17Hi&7C>{(q*@1)~jaAmVIc9`TMq~kSX_vL~0W!pLCi>&(5B5e|3AiSdw^}
zZEv4Mvi-s4s!38@FtCVWg;C4#+AV9{Y??LO?<gc3>xWI>Y6#apq2%QS0~hf+FYZ}>
zMXN?BHj~IApFr*?0d3!|7qsr4fn~fwMQd)ev-Pb)E_+G}Hgl&K6^0wO)8#ho)^~e$
zWZK=0==|O`o1v(2+uLZ@>!LxfCy+JQty`v3OtO&PP2e3Sup4D~Xy84(&j25p^|mF9
zC$jfX^T8r$O08s0AOuy%91K<LJ;(H^uEIbz$IOU)B?BK~MPbnPZZ(>9zava;7+Ax)
zg0U0Os|vENvHL@~g^v^1I1*M@cBSJnMFu{B6s+53k&g#K+HT=)%Xa*V-?Gd`aS)#|
z$DZ`aqU|kOjivzJ##RD%Sg|_vlTQrX#pevZDPHQ%D>X#7wzF5%9bxM#i83y>SjBC(
zYSxA=MV`{B2zv60KqzEax3BeNA=IeUZ^Aih6lI^wkL|<}(qMXKQ|TS?FwA=fcTGh2
z1*Y?VVkAFvfK)#J6sf-vJwQ4iIY8!jo<=djae^Mf){OD}5Itn*;Veclsn4_*Owl5r
zX^pBlgSV8nOkswz!Yt-O^zZ3e-Yp1dX5hgg=JQ{16?;Hnn$luku5>A+2@a%4AWir&
z%yaC*FC4=!P>3ahbm8SJfM?@|@Q(>E{+9BGIDdU+_A#bs2lh*IGrwYBrX-xwbI)*z
zN(h6P7Ga)&1yW3s#S}&v@ECE%>HQo76E^w4>oJ=pT&DCaW1e5(D#BM|C~y_+VYn1B
ze3KrMh`hwOQZF>ut5^vcf5R6d=A;P2Un;iy3kGA)@Ya*43_J>G#`U!YO()QQGNjX$
zL@XkS0Mc!mPd>mkvMbUM!KyBhpLirG%2T83hxq7cjQoL{=}!+)R!>ABVX{&V(zeUA
zEq6&w>jFH_Xf7~c7n!R|%vhG+Tu;{WA+dSleQ}(%i2yaE7@SqeFeIDdl79porHb$I
zvdE&zME*~a%RP#u`xFsNk0K*<%0KH6WR0_c#3kzIzi}0`MIiOn9>?)M$6^u35p3)6
I%TVL$e<A2q*#H0l

diff --git a/bin/com/ds/StackDArrayDemo.class b/bin/com/ds/StackDArrayDemo.class
deleted file mode 100644
index 5b449dfb2307057804fd39d7375c23aec18449b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1098
zcmah|YflqF6g^W4+b*jVC<O%-P_zYQec+2C2vn0M4Vcu_5I+s=SQgveX1gW9f2ALa
zO5zXjM;XtsJX&mGCYhOg=RVH4_s;J>KYsyO!W#n-fmGS6+m)tW3}pFpZr%6gVNTUO
z15ts*zC4h2O}bTkdv{-z1A&1R$8~~LfxdL6BoN*7D#}D3;uiWbATU&LT(#Az?<)Vj
z+^s2rk%Cv2wUYE5EuSi*!Jg9;m?-qlo@L~^bX>wqe=J;}C<eacR<oIsfni4e*V#k@
zqZ&$*5z_fg$wUeh2F3-3FT&*AKvk7*;To<B7zeV}Qrn+&vV5i^+o@Sr2c5ET12-A8
z(Q57qjHNs5!rBm39MhOJFw<4J;$bsTbqlv~hgI`hEaF(`?0EJ&@(IXF$$HknU4iin
zlp)!TmQ$-JKZdlxVA1)arklD`%O>V9ubD1fLUUdt4f}zGMcCw6Re^Rs>04g=KC<u_
zPuNh|XehTLFx5@ID?3Xtho=^v;kiI8@WMxdWV*9nr<qN>1j#H5jGmC`rfFeCLpB<k
zd5s;8O25ic812z#fk>0(O7@r%PDrYIunrq%!<Fe_ztYjKv%an}h*|Vnep$VB^r$8;
zeS$@eA2VRp_+x+wZ=7=O1|^%P;MqTagxJ@UXOp{r1|0^uTcH8ZE0p56iXm#W^AAKB
z4)}14#7_Saf5}3^`i`+SCeJV5aO)UzJ0tgwkXdNsej5+lSZd?N|1C6}K4>_zh;ff`
w83Yi=2(^<0w?t5{2&+U;8fq$pL)|K+IJU5c*95yxNz({58@vf@QWrt)F9ACIGXMYp

diff --git a/bin/com/ds/StackLinkedList.class b/bin/com/ds/StackLinkedList.class
deleted file mode 100644
index 9fb9c2019ae0021b20bfe8f94fa237980112f85b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1184
zcmZ`&+fEZv6kTUJWti!3D^PBt1r^$Y)C=Ay;l;$KQcc=4@o^{<7-*-H&J^W4eDeo<
zMFWy(;;V_@WQ^;~43V~)W=_uDXRp21zVzqsuipV|VoQS}kZH7A#eKh64Xnm-*>R8U
z{j%c+8dQPtBkRN}HZAv{_-gOSZUh2}pzR5alw(w-y>FKUhPEBo33m9L%hv_e7jzp)
zAZ0?sunr<jBrzl~Mhd&qZSC2enzh%o1=8hq!)n&8jw9{ZsRoCRFED$>)2EJ<nO@kb
zcLiPi4`#boEA0@ddR_leU^-XsudbA@YnTy8T`SH&26M8Cd4c7BK(5HbM&#={!*7^a
zl%=Y!{f-?=o><LpSmywrfacn7C6o;cOWd`*xC04KHhL<TACxJeSDgdb3c4Kvles)A
z)3J)YhFs6ks;7Qnw@ehU#?iF9R5Kl=bK1q%9mfr-LC3aQrD5FTXneT>S;x=XEw34z
z8Ytp{hWi4Oq4HjgiHCT^0z8?f>Gn00c^&tF4V4XfY~m(vQ2})d7}a*S)39GUa`;ny
zgWZr!0=ezl)?nQ`gDxy_w-Q`u!H)~ZGr>ETj;Btm0wsJi3YRbn;sWNUFlLnJXoyTg
zB~B-1j6O4p#yBQurF%S+v?v+VaqbU9O77Kf$h=t-mzdoxoWuNqRAHS&A2Gfz?F%e~
zwj@?b3e1N>br}3jAcZ-Mu#i!#kXDMwMrmUaB#`|hslmm{602Mjw#q0eY>A%^<rn5O
zWMmb~xXr*jbSt<U_ToKn3hk9h<;Z8Oq}RV-L!3#+IX26M=(0fdYiEqSE;r2%O;X+z
uCG$Ul8Rni1<z}L+v0Pb9Bv*Ft@0%1Ey*;5iDVLL)AoMA(3ZBJMpZ@{lo9D0q

diff --git a/bin/com/ds/StackLinkedListDemo.class b/bin/com/ds/StackLinkedListDemo.class
deleted file mode 100644
index c409d78efeb5454850e7db5ebb84e965274dc353..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 914
zcmZ`%U2hUW6g>l!U2wGs1!=7xty-aA*AIN6>5Ik~L#hb|V|*H5LZ@YS3A>o|kN7|I
zfhL+5pZ!tBGf=e~A)DNpd+(lm&pmU0{`&eIKm$)LBm_2kf#>!^w;jpeNlW`Ds^8LK
z^jvv?g_J<<Sbmi5Q2GP+b@y2HB7yY2_H}e1kgQZY0;y*~UuBU*#=#2G0;?>e4kun$
zjo-@dPzmH)K~D}la;%Mi9!y0?IuzJ!EoabVbx&$vpj7$L`p2XljkP~$Ry!81GPk%u
z7CB^$S#wZCiF8N7NMNl}y-;aBQ`1ISz<N0eL#2I#*>G?jn`}Rtghv9!%Kw;Z$Hq<m
z@k;qJgWK4)uocs*eHuo}b8rWD**us~y5hWy4%|1KAmSWKdQA&Eao}vcEGpQwP!%Z5
zCXa(0)KDkqk*PDJLNSVe1tLE=9#H1O0{sLMAxV{&ya3fN#UJi;^yl&FOECKvbUG(-
zz&hD>Fd6sM3vITcykOV%%!t?mh2nAo3EsF&v=%*=r{KA=dj|XSES;q_X%KLU)|vmn
z^D?~*u3(iB1OCKf37(B_$h|+~F4m?fysPD}O|f3f-=O`1TPF4c_olcXb4;%!Os{R&
yv=+ZKZ#KJRP+(@A9e3zGVMoKGH1CB6*rR8oPVx`Q<Pkl?aUOZhn;^yv+V~BxK+z`v

diff --git a/bin/com/ds/Student.class b/bin/com/ds/Student.class
deleted file mode 100644
index 570a0859ac4328a071f504bf57d0cffa54619813..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 401
zcmZWl!AiqG5Ph4(q>ZuFs8zv(-r5T0;!W`)2!*1DO2FeLUFw!Jfi&rVc_@MhKfsR?
z-^PN7hkeYOnKy4{Kfm5T09@h3gC)>Oi$yeDMw6<Zs=V^x2<*<~N=BK?XVGIaS7{~S
z<Z__|!trluQk6QNT?^Q9#*!EbxHmf2)vZ9U|G#lGh&ku3m?|GOb^^4~p}0SY+n{HF
zEx0BM19)f&bjLbZ5A`BZ<&#XZ#=S^o7Ryo_zDYXOi(XPc{(A`b@+U=Irs`fBZLm4;
z(j0(u`q=yhi;uQM7*iq-;bJ~<o9vk#rms7ELomEpGdNvi@0BSF`@|3q(ItA6wa_6R
aFmv`J!y$TP9MIT^CNf4A4UWhx9Df5hC`ix%

diff --git a/bin/com/ds/TwoDArray.class b/bin/com/ds/TwoDArray.class
deleted file mode 100644
index d5fa337795f039a0c26524f8752192d7c923a32b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1060
zcmZuwSx*yD7(KT$(`oAfrR>@YxL`}A)q-nT1PMt^r6wg!3{OKl;y|}drx;><k{_Z^
zJnI7(O?=W9|ABwSxScyC8kUFo?)|oN&$rCC-yc5%n85=bK7nw#QA<}^>9rS)<weIa
zcXg<=Zkan~x@y)p(}j&KtLzH+XYIP}&I>5<L`gt>*r-?`C<q$R;1}r0+jVQTUE8pn
zHFKkC2}JUZvRN&ejxF^gqv}4lThe#(-7GO{rd<~pjIZbazh876yS|xClyvm+@%8mw
z5PcZX(SM9)aku4KH3NefVpO9|#seJ`yODlE2$w*XS<C7e5g0m&ztpy?70U_X0%AI%
z$Dut21}<V$K;JQ|ZL9E%@bO&YG|v!*F)mwjNk*LZCrSZa5fDKcIAP!#;_R*2Y+Ch-
zz|>h8r$CO#W+lX=fh4XA1l&faQv&_*GkK+OLq}Sm&#V1-R}9>ggtew@Q~=W?7z!bU
zTLx}RhweG59FA%_o19<Y86%>zV!9@CZGJg^TLN80*DP;8Hk(KD4;342r);g*azncR
zZCy%|!Z<iPE+^pQjcY}zQ%my{JhjO~1m1b>5T$g33Fjz{P5{p?YC&|PhZZJ_IDu5!
z_Wb^@2>bF$C8MYXN>!6m3lx%SM)9N?_6{v<6p~s-QKVEosVN0zZXa{X{66B**c*(!
zN8}TRpC+T3Sn31LA7U(W`2bfBkT}59o+4uYw|~AfD3UqA%$`p~seh5&6-e%n5TW#w
zp-#pDu5=J1^o+8a305&h>olvl$2t}e#xi=5W6mlgw|Q@20555O%^i^SPj+g=9o(g+
t;}tV|*?~nY;Xbl#=n64sc~daQhzPV_Sk@61Kl#It`+j)+ny1Hyg}=?y*`fdd

diff --git a/bin/com/ds/hash/Entry.class b/bin/com/ds/hash/Entry.class
deleted file mode 100644
index 4f7dd25811a2e6fae1300a5c86436a0bd814469b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 685
zcmZvYOHaZ;6ot<~d6fdiR(#+CchDHSaVK$O)DVd-G~KslBE?b?C`A5~3r!>@F8l%h
zDC3=hm<XilyzV{UIWylspI-n@QOh8~Q1%CXyEC%8?x<^DM)7c(fx@8o+=*+4ZuDs1
zc|GpO49O=xWne9a)Wi+PoMEHA+;zsFMEse$jrIzdis@z$1@SpUrQTW<Hyn~*3_4sz
z5+x0J=ww@OI607+h7{6bWopPED^?W^Ij9V!b`bH~ao^*^2iFT_w1Mx2jynv*esQS8
z-C#r^u6cYT?m}p~O_sLK{6c2Ev6_lOy&sH+KEDbCS(T4;B5sZ&%8;bT6hDQd5h9wL
zDHzQPb>yMZSfHJUgzPn~4-~EH3}x$h2E$@AY`#%Ffh`&<#1b5ZNICk7L^6o7O{cZF
z9y^i_n9`R~#gxto>8CIJnnV;eRr>vRDN2$?E(Pf!=prX|FX#-rs4hr0&7zjF-cf#`
f#XM?S9_ljMT%7t7?_qz9*mzwM8*9Y}vg_~{xgTS-

diff --git a/bin/com/ds/hash/HashTableArray.class b/bin/com/ds/hash/HashTableArray.class
deleted file mode 100644
index 09c6b30ec446929ef57879f54f7c9cb96287e6ab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1483
zcmaJ<+fEZv6kTU#+G%m1w1sMEK?RYvR4RhEQmV#yX#{<MG%-F6WdZ}GkkX>~?1$(R
zG0{X5E{R58P5cDkef1N-b!JASLd;~&b?>#;TKjz8|MV5WIBx4u1bQl~E4lgg+@iU@
zn0v@!)|{(acj|R>Q->zdxnypbxvE)P$UT``vMLRMpeb)<tU%YZsiOe*YK{8lgn+hg
zzqABINx)yQYj&f^vs5Wv=5%*;-fDx2b^}3l2&k!aIS5uVpd+9oA`m`?DFeC;_~36t
z80`X~DZ6GpZm!H(b%(J)WNNiyR?BAHmI}N>t+8mY3nW`uw#p=3VGG1s(>K@tK%D<i
zZeezIqDX-DnTA<eo;KIKvibw7;Tj}W(*<?e+T^&_q<^tgY3g5BC(`9MO1xm84`-#s
zi_)F`AXg~^X=G?z&3eJ?XbYV`hWj?mYLkvfjw7>Sl1iyIZ@my`b6Q(=qxG8gywtE(
z$ZWwPb~nkM2ry$W)XYY+&I*3UP_^WE)xb4e=MmLDa`dIrC3$hvKpwOuzzeTbSL#G$
zl~5!#v)ZgztowGA1){C(8Ie{Aqzbe7<J5}Bk8qwos(j%Jf4&!vkPnNa#+x9d&!@P1
z%e{=tX7*rY5<3WG5?>JBK~$aGLNv3DX!0|{PxsJ0^GXrP#G8X(A03n!$39|$=o;rB
z(Zd{L#2(;0O#IWlJ?G-%4C36elEZ@vdD6oi1qq%S<RkCSAj!Fxe+bF}!BibW@Git7
zz6y`_G}ELsJwb+{wRc>q43=CZPP<b%=7t<r*2yKn`@i*cub!Y^{T}pts*!#TXA-*@
zC`t!<ujDmpLL$3|!Mrc-i)-5$+QCp<i~Bf9L)`K`PHHE|Fgg&S<S5PPLI&LqrJ@Uc
zNNL!k#B%(yB<#l^E|I3n{9cSOQzJ?QIj($1s1F}fzl>4lT_FbrV@^|laOLBEOiZ_m
z*g`U{?P5If8irilnBGFj5tG;A+P8zB*$+(9949mEBS>0dp#Uj#vRhFSNb>6^wLvx`
z%d=7LWS_^~l84g9JZTCeTxkK$uCz{?;!2afaQigo33B5Ltn0o4Z68q`s?ZS*`!ya<
LGDShrQ+(?;6a)Qm

diff --git a/bin/com/ds/hash/HashTableArrayDemo.class b/bin/com/ds/hash/HashTableArrayDemo.class
deleted file mode 100644
index 1c5d77618f0ef12e52fd6687a9515c10e0204280..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 950
zcmaJ=Yi|-k6g>l!h3(cN2vw}Lt*@nMx7K%Pniv~n6QU*<662?VPGHGC$g-I5FZ?U|
zfhL+5Kl`JMXTV1Z%9pwK&dfdM+<Rxf|M>hBz<oS1kPz5thrV+%aJq8PbzX3JBU_$&
z8bxw+r2No8N+8#h@1^6(pyRx1^;A0+NFTU?8y^ZJ?MhQ1^(;J5CX&cnSVCH0weAM$
z<<M`bXaXpZuZL~vHD%;#f?u1dxa$rCHtUO3)X3mVHxMY<@9KZmG~&n&I<-pEz<Gi4
z|3OUTP|(sY5XnBSG&3j(7~SDupxi*8UbJutW!BRlvb>Uge1>LPG-)zeXMRrwGJ_3z
zo*c<6HnDABYo<+&(I8g7g=@G@$WTKTr+{wgyr$@w(v|dUn);@NTd;Yrqx3z>o98yL
zGfOb3+{A6{8n`1+m^5V;+=7EWR@v8l9-CLR&jA1F9qW)$hf^s0qqPEwt}n2@U_cyB
zX?C`w{_pwjEyz2V7jsA~vk?xXwtDV*N?>jNMegcKu?6;v&lpJ1<CEiRFmh-G?b6OE
zG9M?$CRcq7CM<KcrWa^e7-ew|tK8AaA9y1{yZ;5bw>k5aZ?>9S&KJj6tLCiy<%wO%
zU!nbkt2`Rx#y3>PsA{GpG}Fce$slf;aRzyMWqRA>zDrK6pfqJ+ywAvljeGo$0uLBz
Qb<>@P^aLJpFM-ED0T`gy(EtDd

diff --git a/bin/com/graph/BFSGraph.class b/bin/com/graph/BFSGraph.class
deleted file mode 100644
index e79ca8cf5d2e27e738826f84bed2c1b26cf05955..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2008
zcmZWqTUQ%Z6#h;oVPKdvatVk~OVbt-1X7XKa%oj+FHs6@Q&RzNLvjj3!%RAvAo$=@
zA6%~0cP~%v3;JeV1zK6Ud~+?=@?ZD|eDtB>cP3Cm`@qTUbN2rB-rxSt;m`km`3=A@
zKGzWvXwJLK=>^X!Ev6?fW-qA^9bti&maG*kU9_Bq^z{6a%=-f2vi*e=5E+4p<$2bc
zK<nJ(e!Nv!nzYOQm_XgQ?b!Y~h9ono9DmNc1!+J-)I<Xg324bwt^v$qB7!;{%>qp?
z04ax76FTY*G$Go+rQO8K=pf*tv<eKb$v(vtOdXrF9XVB5o|oPYYre>On<w48Rm@qQ
zt?b>+u)k=R310)S*FHgnEfCH6R{r)CtF#-TSp{Z{Bs1(t$1#CJ`vt4q1`;@-+Up@~
zGE)N_RHph(AZa2M)bGeuGOCrmJew)VG7aGf7%bw#YN_aYQb(Gk>`!6Bb&Jw+3=HCR
z6GM1IKwq(n6*+xNpe;F@ntZ``Ovfn}6YN)fyO<_7w`D;M$)EtD2F_qq$H;*^8ON6k
z(o-qOL>mWK1H5}U)`+usO9v+$+eg1vkrip88*dB5lQmIQ0ga_*RoH}y^LUqCm)v4e
zQB{k->!}L6XyOts3)I_=pHqDXs>w9qJxuC&|A0cXYh_<9o4A50dbt&{8L#HI-SkzD
z2wC5g)-nmXD$u@96t`_>VWMIe3(~8{b&fqpc4VR3;Ydfj4NT*P8tMnnwNwopOXZZu
zO%oqthO)OxCFxKlT?bh^kY!9o%$fKIAG0~%tsXv4#4f&pPhsi!OrRww`d~XI=2c;O
zNp)Csl)wrmB<iTsKpILc3nmspJ)84Y0qt`cjN`V6qB_>?@`dG+&pX{n;d_2gdcIs$
z8neqb31NYAH6z_sqq-}1D4*&{ps_#&N;wCw-CAky>h(PDJYIvlC$MuImCO5(bt_(8
zUbNLkj_%#iLB$1*@_Eqsl7;xkM}#ZXTftT1NdpY7jkJD1IPe?k+k)BGxq(<;-y_6+
zMbidaw6p6tOtYnH8%;A?h-U+1NNk|(Zb)=>-rxEAVF39G*F*qs5U`O6Otd134je)c
zVmQg~Gkl^t>DOINh%Owa1&jm*k`p4l%2Go(!rd4`I}F!!2qC~P!9dlOs(OV<!u(Ba
zBQet@ws3rEK$X@x^ayPm=&gPauuN562&%m1AflC>$I;GYN4ctU`l?9J%1Lmij(Jo=
zuLb28d{+BaE!-X0V@^C^oZ|H%laa5%E84krMEehGk8v`4R}+f3*!`V<wlPfVPEQSV
zKE|6*Fdo9qbyNnP;2nYAab^=2PKSR+W*gHp&DXY&jfXdp+r;c9KIxB#!wOBc6A!E2
zMkDJO?(c{^LVjoyx4uL7KwvzBuAT)^>oC+=?`WhW^2g3!%(x`*?ao(<l5jxDb<Rjp
zTTd%WGFth2ghcdmGDDojDO%@A`z*<tCmjxs;SP@DOPs(x&h;C5evc#`aDSctKan0q
z>19fd#5|+)A(jJ5>+vHoTn<DHLCsnt!q+GfRb!?CX|7{!4mH95WYmR69Fw$Hy~^}b
n+USM;6j2?%XxL$?VWkmTIv-Fx<-@Eak*fQbKmrxIhp_TLkcF#Y

diff --git a/bin/com/graph/BFSGraphDemo.class b/bin/com/graph/BFSGraphDemo.class
deleted file mode 100644
index f71a5591e0d32e859b856ed5248629f36cf6417f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 647
zcmZvYOH0E*6ot<;uQpcO`l#<$SE+*8hzk`F9~Cj^qEZl7(>BDEHj!AxpQRfG1%H4)
zN<5Pa3U+hu+;i`p`R0Cpy?p@KM8!fzpxlakZji{^8~31AKT(GxzZYB31&ST{Al<Hv
z0{5cX@mqZXb2p5_{+@v5R2u^NVchm@XvpPZz!WHWVdS6R_nLlkDVtqiVBCvavfGeJ
zsPZ3E@85)X0yEz5*LQexPlgfkoNMowqTWx!DA=hsER=Zj|6v<NOemB|-r$^88_Fo>
zF^w4_%XVA9a87^xxjg1oqs@;WKi+oZgt)p)0+LM(c~(FK0+U0S$!pi+`=sU9LiOj;
z-&JlXeyoB3+&hrriMyg&%v?snXso>=`<#|-sw#s6Bh>t$fpL^s4r3_LQNvH{$S`{E
zC|(uKS1x;9GhQ&YuIWm3D^)X9O{tmsR;or;IY#Pd2U9PY{bkrn-?LyN%Pr<m=4pXM
r6_PltZIEP>EZeN^ql6m9afaEHxjf)v|04Np9AF8{q!w6Vp26xjPC#~Z

diff --git a/bin/com/graph/DFSGraph.class b/bin/com/graph/DFSGraph.class
deleted file mode 100644
index 86c286d636d85ac3462ba5ca74e1c643bef736c2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2115
zcmZuyO?MMj7=CWPCJ7T_KT@nMQUjE<G)*apr7f)%T8xGQ27+xtohCy&C7p?r3AV0W
zu+t6axIs3uDhoGy+LU9D9(NvfCx5{opgT8GpF2ru3M_Kxe!L&g`@GM+`TgmSKLa?0
z6$KuF=Df9>TCla!V(R=<_JW)!@Cm%Kq}|a{Ma^7DU7BCg^NxV8Y<#W@h_rxTvu$lv
zpmi>@>#r4-GDg`M5eSSLrs0gyC6VsQ@pH~9=wWyfQ4zv^0dJxw7Xq`W@FSq0S)l2K
zK+>R9g@RxhO^Adz98mEp+8J<B*9vrR$Ue;!OdZV_raoO+p4aWG+I*3Cn=@8kE9NxY
zkn8%U&sj9e4Brr7r+fwxhCn3iX!+Y0wNl-~s}-2hpGdPJ1&0Op?*f*&!-(UkEU%kk
z6X}M)E;3nf90?UYE`C#AA*0^1oo6uxz08F$1;PX|xl$@xwyq#WQg*vAVOd38GsEb|
z2^E7lDWKfZiWU9RErGVgY)|F|+YtqCk`Z^m;uyu0TT+<4kAyLVVFhRQq)3~NzM$JO
zI!S0_?;2v(4@ac?Srua#C-PFIyeQC}Xt1lPWu(!yz9l{1Q89sYth{8EBu_6j8^WZD
zDO?Z;8m5zzMY@tnOA6B}-a~+$aEq68WK>+lw17HaqiEM*HiXOgK*5zgdd{wv9er6v
z7FQY8s*w9wtpLMHUACDr>)5)sO!}zZ1G}_x+b|a<Dn_xO+d+Itk>n_Nz0hS+0K;8j
zT*IuCz#Jnsa#C{~>B&ipn<_rS$Gjw3sid3KROeoz_hcd6*PyAG2Za)JtlHu8%+=$E
zp<_V-_0Zyi-dm1}MF~tP$qI`U(kU#dxGkAejPm4i$>D|GM~T=@PPZL>MGDL)8?2A{
z<{DaDmm)Rdk-}}N9qlTN2LYpe-ZI&?mY4dq?Y)z$rJZ}({d}y^2LBxij<GZHvSh7_
zo!6%fdCMa^*SBAmjyL#rc=^nE_~Q%15%MA7=;cWWVUGK_dIX<qccym}YH!B|qP@NA
zi2j784YYXAuHhh;EuC9vn%P7w>n;Yx2HNg=L}$mt?Z3WvL%zl_?uHLCV8~6-$^`9D
z(TxZOI3Ge39klDJB}69<as`}m0rI{v!s~?U!6EKO;n}9USAh@$oC!M0swC<=Oyc7=
zzJ>Tqr`W`i>7<0#F}RMl4IHb@lY}YZc_866yB^J~yafl)%2+WMPH!#JGdOYd5(HBc
z&T$t`m~U>M#KPU=4s+sf`bj>YFd6ykzvvxXL!|GZ_b~>tcfCRq7k#+>&lXORy3^Ci
zj>mYbiqY$9c#y2(?O!ld#re~|WXxAT=!^L{9dJpG`D7`>ez`FmSi?|XyMG<;4p#C0
zH#m}X7dvk5!u6E7rFB$p9UJzy`+wd3tvx`e`{-^+s{DXUTevpUe0>u$F{O$dReVxK
zfhNZN?SdrD=aP1dWrK7DNkN43R(=oh<QS<NAY~`n!*O;k&D|?(&`r{sCvmrM7-by6
z7dVP9sepU*_?l1u1D<_LG9Qu1bv|8xFvg!a;Wpw1RYN+THR1`1ZX<%UT87CshS@Ty
z5HF*B2MZ<6#_<*71&H@1ZTRO%HRXBJKZVWRbz;x*s}K#SMN#*3=qXip9Krt(QBV<~
gZG!MgwQ;5JZNO6uavoREpA7i^r78q<C)M=X|4hZkTL1t6

diff --git a/bin/com/graph/DFSGraphDemo.class b/bin/com/graph/DFSGraphDemo.class
deleted file mode 100644
index 8b60f39fd65090df0277313070257c7db0ac6c7e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 647
zcmZvYOH0E*6ot<;uQpcO`l#<$SE+*8hzk`F9~Cj^qEZl7(>BDEHj!AxpQRfG1%H4)
zN<5Pa3U+hu+;i`p`R0Cpy?p@KM8!fzpxlakZji{^8~3PIKT(GxzZYB31&ST{Al<Hv
z0{5cX@mqZXb2p5_{+@v5R2u^NVchm@XvpPZz!WHWVdS6R_nLlkDVtqiVBCvavfGeJ
zsPZ3E@85)X0yEz5*LQexPlgfkoNMowqTWx!DA=hsER=Zj|6v<NOemB|-r$^88_Fo>
zF^w4_%XVA9a87^xxjg1oqs@;WKi+oZgt)p)0+LM(c~(FK0+U0S$!pi+`=sU9LiOj;
z-&JlXeyoB3+&hrriMyg&%v?snXso>=`<#|-sw#s6Bh>t$fpL^s4r3_LQNvH{$S`{E
zC|(uKS1x;9GhQ&YuIWm3D^)X9O{tmsR;or;IY#Pd2U9PY{bkrn-?LyN%Pr<m=4pXM
r6_PltZIEP>EZeN^ql6m9afaEHxjf)v|04Np9AF8{q!w6Vp26xjVg7c1

diff --git a/bin/com/graph/Node.class b/bin/com/graph/Node.class
deleted file mode 100644
index f4d896a76eced19ac6196cb30d5849226f408b8f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 377
zcmZ8c%}T>S7@RLno2JI5*7^fp^wt(J7jKFeK`4ZJPzoNmacQ@tiNvJ%S{{nv!3Xf6
z#M$aa4?BE+Gqdyg_5K0i9ETnpK|9Hp(X3EU^JttuY7efUvrsD)r7D|6x6_4AN<n?4
z(n<?tBycnR!ciywOT7>@E=^|2D?zV6`oA4a$h@XS3pH#9@X;33`h$rNY6YmHVXJNc
z4^2TBn@o?Z<y05<YMRoz8|R5iC#o>E{~fyJ+&l|fcX?GL`o`Ep-v&9e8E`_y8q+#_
zG$6vt6B&hHXc4#AJ@CTbg~K-l!=p8e(=~QpIdZT|?7}5Bh#qN8w23`Vj(=#_+lW$N
RV<X&z8zYAX`|KPXd;@9!K!yMS

diff --git a/bin/com/graph/adjList.class b/bin/com/graph/adjList.class
deleted file mode 100644
index 09aabfea572f6c545fd39d47dc7eaf3bedba2174..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 300
zcmYk1y>7x#426$Ln$QsbpP(Cb=v}%Mu^=%;FtlQKk}Gnfkf0FyUY#m2@Blnig_A~V
zhwE#9KGv~sKbI?jS4>=V2;-<YsC~)DL~)!3=2W?`38R!hS!JB>)iz9ZR1xe%b1a?U
zZ(>u#`i<Z$Om3<r!J5r?B3udfV4>&3MVBxPOs+TQL#WFS4l_-d1VzNzj!RS5Ewrn|
zoCwo@2JK4X;k_5<GSX{PkNYiuskg)v#92-vc@J=!jA~~gk5Vc5o8I#`ye|PA_!6B4
STIfse{|Yd`P%1gHQH}43V?8MV

diff --git a/bin/com/search/BinarySearch.class b/bin/com/search/BinarySearch.class
deleted file mode 100644
index f1f197f0b65479147ffd358d5d167e1a6ccdfc13..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1453
zcmZ`(U2_v<6n@@hlTG55CTX`H*kTaSq@|5k2x|Chz)B#rXfWD##_1;6ri;mL-E3gu
zos8pn;fxnL<8X%#GhE9+>d1^gz`x{-_`I7y!vHt$$Juk9^PK0LcmMhCufGADz^00T
zz+}y7W!t9V)^@T5%QoC@*}tez1mZW0n?|;2*p2L3^@dsV1j45++w#r|1k;&{fO5g9
zn=u3t)eu5hV6<e}=4z)^HQnn*wP^|@OHR#bRt(pY_kmIIcC5C*bm<l8^Mr00mMt)m
z-Yo6YD0{ADH}aW^iUgsDqAwbrQ8v9GMhoX-h+|w5(g~9;W-8KpE`})_R52}(*as{)
zPSZ4O4X<NHK)q=+JLcN9OuLa8$~$n&OXNcu-av}Z4bv-I->^h#QH<hE9941TIn~PD
zwr9399K&1mayk@H@1t5y_8Lp^SdeM7@)4w2j_vD~vf8%erM8`pU5{Z7$5qS=jQO0O
z57V%KMH1PSNKJ~Rr-wK{(<(~R?`U`zO9IhBZ``hcAn7<xXgG-+g{o6Qfxu=_#rqtL
zeU17+g^ty%n{EUjQk`c^`!rL=wr9Gj7*64|)O}H&&T2S^^Bfstch|J*0yAvI3;YJK
zRG>hKJhv-DFUru51QuRa&nqEh<i{E=p(qgXoIY)V@$`#X*~lqe(NMxw0j=5}f{JXu
z-^~rmVYm%W=-5l9kC4N2JD5C<Y`Fh+*pXs;MYfOeLu{W85mPjsTTHQIHFkJuS#%sJ
zdq(Z6tH!SXLR72?#L7;`t(hy9d`5}k*SRR0gTr7j-!c&3iO-L#%3GGZ;2xUWL*x(t
zbBwF}3<kW$RqH!&AK@*E0~n=+!QwU)ALO^kh_5G;d#oTiaVGdDCRc+wWxj`5rJf4~
zbK(2w>WUt^hXW6AIQe!DnftJ%MOW&f=2k8|zy1(eW$O{L^AGW!9$uWei=*^?j8p5$
z5B89!IordT<Z=%edRXxhjz9JN9Z@~3Y%%2^_?~ZI?u8yM-+A)AEG!6F*q4~(8s=GL
zIT0jTkj~pIOHHxFBec%3#3dGa5(zBR;|j)5!8oe){F=Lm3EbjL+{QG1z(M@XAHp5R
z-o+tbuuFYWu!=S2is4rxU87_p_ywO3IY7*x@F~jVq~k|ir%fS)@9-H<A@cZ^`IgA?
jbH>ji{Dibr6<?@`3l&pBusMl;u^f-fKCRO!fQ|nFP7^*a

diff --git a/bin/com/search/DataSet.class b/bin/com/search/DataSet.class
deleted file mode 100644
index 4ec9d47a639a6868e8b4c72d64564409666507c7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 543
zcmZWlIZne+6r5+9m?Q=V2x|g@h9w1|pkrx3NRa{*L20OdoUg=?1vv%@YEHlzkZ5R-
zh>#HC033${0OQ0Rh2J*w=FRul&-*8UZ7kU^1e0F3UF>NUc+KLW3ROjiHY`ErLfxoh
zOLZE>)7pjhLV;B$E-=nZg5=3{yQYJ);8q~)6T5!L5BEu0FKtwr4!U)nf{8H)NsJ53
z^^Iy0)O9d|L{v>WurVrd%YH}4a;nzSM9N)HwW=!cqyB6-w8Ey}6J*Q(4e#(?&%fiQ
z_=2%YsJzQ#brmn#4INenC_T_>s?xm<JbmOxr=0lBo6&QzLR%((j=_&E84-D8G>9aT
zVobApAS>dn72e<!av!NaTx;(MZs8Sf-m2$M?+wZ49)G_JW*-wTq?(vwT%sH(Y%!-P
zoT2DE^9rR`Imr@T9!g^xGwgT-vt;mHMCVu;+yGn{zg#zMhzPhUSU@iJx5dmM5|N+J
XXI94Gd}1(-gaBvAh|dV}1J>dnN26GO

diff --git a/bin/com/search/InterploationSearch.class b/bin/com/search/InterploationSearch.class
deleted file mode 100644
index c3a37906dbc55ac8eec57fae0e77f73a135ace77..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1506
zcmaJ>U2hvz5Ir|udu_9694DKk#VIZ=U?+_YP3r>g7fA^<xJkjq;N&G6dt+}|?^@2f
zDE$FQNJxmsA|9$LQXYzgTD4B05<h^yghV-a?KG|$c)1_5GiT16nY(}e^T(e6&SFi)
zkihY(+stm6M!VX`797uPw`|w&EY~UdHWi9M?3Quc$l8We&#r9TGOM0I=z`@~-X(!R
zDqR*(7TuZ|MF0^EL4*WGik4$8cbXe!`=+sBn*#BoTQ%&m(YEBhZ&bX7wIz@&{y&R6
zGc*m$5tvA=6%W{yytd`k^XamRQDztbxoUVu$@BskS-28K4C9iQPMB07U6$6%QB2{O
zilYLf2Y?H%Ynz6n;dLYg)Z2#LF;_Na+ST+x-o9I2A|KcA29k8Hn_kJf!%8VhA%Zt?
zO2x^S#4BxYd1h0?TX>sZZihPRJygrh-e4&n3o?ynK8zI0aeVob)|TUX$xXN8)S{Td
zX%({qV?O7X!!*nxLn1ASWK%3XHNg3WRuPhZSHpWaLpf^HNnmJ=gkw0X;T&=Tk$&Ua
z+XAAX;(dY11C4q>3mwa@ne8w>q&hE{_Gl)JO%75riu1T2b<fDtB@LHxg_C2nTBcJI
zNU#;J@aw};fdxwBwYO#HRT=uRz}#W={3nEr{6xbw6a>Pa+oLToo_aMa8##r~G!$`N
zK-=gIL0LB6@8&9nGTL<x>ewOEN65kP?N1&@Hq?7U>_}m2Nw$yi18nz)h$(FMTc&7O
z^#(6Zi;lx3&!~QL-Dvp_Ma7ChwB&Z$RddObuW9O#x0;bX!U+(A4;&cciI0)1%3GGZ
z;2xaWL-?WpIm%Uj1_NH>s`VVW5Aznm5sc8nU~!*766E)1h*je8Jr)w5xEOef$>l&!
zneAd)spW!!Txb_R>53lQ!I4Ke5r3zP^e(=W7G0^$K1Nm#X8cXb)a=Cmsj;35%~l>`
zURi&FdEXk!B<|r9F`nUkCH}!4@-)wPaWVc;7mHmi`N*gDeeWZphm>_vkvSN=;~U6n
zu8U9aK6hln0my<kag=L_XO(4!5oe(~Z_|_@$<j~KI>XY>u=sNr#Uee*+$$JE72|N|
zeFqcxp8F4&#E-=L8OLys|BMGn;2|-d@|Pe5z19;A%UIzpir@I^Zcx%;{EE+!V~66{
z#TO`%n~ojaq)j1{U+^VQLGroF+&QxSit*D3JtsX?#n&ogLdBF2Y~JYKsKjEjj}<x%
GVf9}x)K8)S

diff --git a/bin/com/search/LinearSearch.class b/bin/com/search/LinearSearch.class
deleted file mode 100644
index e581859b62f205e2dca1b97f2101ce8ad5f9c5c9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1336
zcmZ`(*>V#{6g@4CJn}Hc_857KO$6B_6k7otHnDlZpjci&juP9IN?KCe43TDBqY+ik
zbG{-^$rH~>flP%|K7dc+A>_0quqg1$wEFg4&OP^Bz5MU*e*w&4%S1$Atm4<R4JCuh
z!)(Fz_@mgqm@ou}9?8ctTa(^icD?*aRYHNj>#pa9HwB`pbV<Ni^sCB36#X`0=o1*!
zN!FV6vI;h3xuyi1f?tufk_=pZ?;4Hpq1zCcC>&Eh$JBM{dIF=Vox%}}Vi>sIUM^iS
zG0fCG(MvLvMHNOdxNzIT5Kd`838qQq(<N=aWnmnXCME=ij}k8UeoaZw#z&YEFdxfW
zQ?2jnvfJsNx?Q(iKQo`U@iCGD{oOW$0|AlOFK2Chf=^kqN-zSE9a=v}%ETA%a9KQP
zgsN^MjdSGDZ<5wTr<UtyH`rjvHkGXBOnk`+9f9q1ztD7RRTacB%f~x4Raah^bQ{TC
zzv)$zayL{#(n1DbX$H<ScdDn6w*+dBi#B!eHHRwq_mx)_m?By4Id|*j;<zjjOD4nM
zKnGvd!Pf+4K9v60Bs%iCjT@kZ;-TMxBXBD9e%+jf+gLC$FEG;P;9YiXEb8veeN9-+
z(=)$gV;Og8+f!lD{e|MAO7nW|c^ltgMZhk1=3UZrZa;6wu}UR*ZOM{G&ks9Ha*Q(A
zqew?SAV4DSm2OvjRBc~peTX67Sk?n!d=D9KbVS9t0t3ZRR(@WU`|YhTu`Xa0{bo>6
z%dTFX;ogm$)g0gqh?@HgMEHv<$FIp-mZ#tuJ9miqpY3OhU;PXQoZ#2)IPe_ctsf^b
zNDG6-1PrDE{1+J7a-2g#c1CYRpJQw-ddYZ#`OMZ+OdCHv!*u2;&LoW4so#<Q3!l9}
zX3Lp5M3(017A`oKTDa0eu7z8Mj(&o{Uk#BkGA%6q@%o>c7ViCq6AW|;bkQ)Q&@gWj
ziUw;D&H&<Y2ydLXvjjdvz*lL#$8&|CH|SgB`;YY6#Rxo%w%eQQw173NGnWO$UEE-U
z11RG@lH|+54|u@XC=yh|CT#}3rSBwSuURf;f`2PR!o)a9yB2wc_({fpM~?`;{~x$7
BDU1LB

diff --git a/bin/com/sort/BubbleSorting.class b/bin/com/sort/BubbleSorting.class
deleted file mode 100644
index 2c47ba44951e13af234ff0206984bc9ead035440..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1344
zcmb7DO-~b16g{sq?UZ5E0v1tP75tzr+VKNF`B1B(nCh6+U>X)?Xa^i@JIydPapi`E
z{tOZm*1ABWhOLQv6L<a(qvCl}m7v|Yn0xQLz3<#}&wc&)<Lw53G2GM;5$LaYb#vMC
z1GCVYpRYM3hHhg~gDQ|%vLD-K&2B83*8GxF2?SyjZo>_x1e8p6RzSV#RUI7)x(q}S
z6WCRB8_u0pecti!*@P45EqWEZHf#H?JpW3n!9#ahV4&E!`?!F<MMof-nVXUA6x;U&
zB6BkWqQQ?|4V-$Dq04VcU`HviE01p5&EJjcw#&-?%v^D6m{Q<##PRHG7Y32mklHqC
z>B%xN4eZAOcJx}DI@!MLdgfi;40zwM>*H|@33L~n1<!X5O5JoE!VwLJ1^U8f+v^P+
z#fX5`ln^zNN@hB7(vTI{^EcT-%dJ%%U&knpYdE%@a5#>EJWRqrwrefNT9EKF*?$}8
z$l#=0)<_(usacmyoH1|~=eS+F*>oCJf#aR1{R8%k)VPGWVBjLSw|L;S<rUbS>Dd1e
zCJjtUDWahiIs`5o*oj?n6ey^EWg&3<P*ASd_80k3`Z}ynLl2)x$!qx)XW9*)+SZ%l
ze)Cd83=v)7dj~B$B1Wt6WYP=zXzn%QFBwFj)5@P^X*aFWE}-ARQ(Q7+Mqd65l~BNq
z+{T15sZ6cmqIy<cLpGOG)oPwL{{nm4hsn^%ltq)WR#cHx2h-Kn%}*<eNDr=Vevs{z
zuzfyk9OFr2gE(_tNHCWsiNmCkCyCR{P4TyB^n}%8Z7Qtm330BW7kwleMFG1RMTm6?
zNk$40PNJWYiao6DLG%Z7A;dRC#c<?n*lqxO+f#~eLP+VJCt~mQvZ7jLHF3%+M-%(4
zax9@+Wi2sbmE(!KR`C_~^&VWuurj%ZAs*f#Qyxv_-+=0#=smTLv2~nZ$HYoRq((PZ
zH@}R&!6kX=%Ku#YTc;$3IZckUm>9q<`Vz_C$38sZAG?Yap3*;~dUBmPPR(I(71!v8
ju^1{Qa10}%IuY1^BB_o6^*c-r*G0NNO-ZJii{Qpjt^^SW

diff --git a/bin/com/sort/HeapSort.class b/bin/com/sort/HeapSort.class
deleted file mode 100644
index c99455ecdc773e1df8ae3c726bba29fc4b42b7be..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2008
zcmb7ET~ixX7=BK6lg-Cc(zKy1Nhp-Il0}G(fFI$*g2hHtzy?ult6jn-1oJh^(oXOD
z3%o6k<9N|a$2vn%M}C0+!SUK(;Efiavk6U5xNtH#=RN1VAJ6lg_w27Pe%c2xhWi>k
z0;dc0YHF))JE@zN*~rt-pbCUH%?D<xV%AEj#kEbV;0Sn~x?@%ZL{`8zS+13xX#r&@
zxgwy>)z_^c6ohnW@C$V3$~9|YySirC%jR0e5{TsL1+%hZ+GV+JZK}>jc}w6-?mr+h
zOuF^ZYzV}M?&R8F=IYgkY0DIuY*v<5OxqSXcY+Vmn*6UZn`2d(t>^e$0@?=Ymy3@C
zVkZ_%t^~ky9bWiCNZ_J|K7q5xq0`Zi0f7LC5wEpe7l;mZ)NYEJNoIr0IH)6x)6%-4
z<2)`9ahc32MXIjYB{`OCj$L`jEPQdxY#hob?@gfhB*5;~RLydYypQ<g9lKmBWs)lz
zUSkWi31n-IRkG|LQb_A~9b**cfmzwM7K<`RHrYX;<(mm$0&i+~<4DuwA8k=^9dF@n
zqOWfgX0#bwuBVn*-600ctY-X}6bQ{)#ky_v%k~Rm8t-VBVOzMkj{57kj#+|g$P^V4
zJECd_uXouLZC=fT+3j*=U9y`)NDlAmxCz<KW}{)%)&)k6yP^)tN74}b2fV3(%ydg;
zTKHFjLo_EQkdaF|KE!PSzf*7ev!RAMWo~7WvMlTPNV503>}9`vtYa9j`mst4gV&3W
zWxE=(-A%hBUsmV4Xk}u7&fUXn)NofIn6Gc!1#7-6pKRCR7hzNii2>GA_~js0`2c8n
zY4f>r3~-g=Eaa~79Kr8tc%XCixtj{QXzNV}oI*EOe%bZhk--J1`~lrYEWKdFjCeY4
z#7FY&G!ggM$5BI&p{E!oQyR@ML~w>HCcxQN$!<hxd3YW|56%(0Up}r@!QZ&{(mx;b
zZcOp7-k*+5sPSj${T5M{H==6#N5nmN0$+SWO|%XYM-CDbYE+GVjj$1ms(ZM^pgmlc
zpcR+<C`*HXm8&4(b`ka<Azmf(Nphbd>>C80Bk0=%DG7}=VZ9`jr?=El#UfsD2?deG
z5G|?cJd(6j$^ceSUf`+_;(UZu*%vLU-_g^<^J!yWUH<{Sq~fhiK1Ilg5$$7f5ZgKU
zlbhVSU?|+X#D(i=C@qJt4*qDfGFS-|QbR9!#3*ww;`|NrlbA#wuHhm-32{uZWhA41
z)@St=qb`@fWYkapCO3&b0QE0~g%*s`9KmQ4yyzo28NL(t{esl0LV>U4SJiOZoxR~c
zclL#Y?yQ9;-Ps>rl5_4E#v_?sOes@OF~G&om|K008^iJRF6JZe?;^L0#a-kddqjMA
z|C@u~hxf1|gFg8`L2YT87e0t_TqgZ1m?gn`oQu4=O<tN!fgbX*zU2IbSJdv{9ej#A
n<T;KKg}O`jGmMe)c;LLWq)<B4zcH)fo=Eg0==T}-Jox+{cqo}Q

diff --git a/bin/com/sort/MergeSort.class b/bin/com/sort/MergeSort.class
deleted file mode 100644
index cdbfab82fb76468823a131a89af9d088ddf13f21..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1894
zcmb7FZBrXn6n<{9*}SmOG$EiQsR4@33nVR8Y=u^#ill}H8%)hG<FJqg7V<VrsP>~X
zjQU0NFK9c%XB`WU?eGKq6MlBapJ2u3Zqgva7bmm#<=lJDdCqg5-Te0VuSWo`qvVD|
zAh24mX142AGc#{k>qdbqHxvQ?rv6aRRP@?<Ccm<2tTqK)x@GB)1RP6Q0q>$wZA`Ze
z>XcbCo3{m=@kCKTxl=D2J~*Li@W3l@A!pW%dpp$?!&=l=Dh9LW>Z^LCs9UDow~b13
z!`v3=&7Flb$*5J`tO@kRmvSf23QfzbtxqP3Ui6~RjnFCJg-6>>qpG1FuMk^(hc$#+
z&SpKcK+h)q4ZS+)!GJ)|jIma?jF=>YL4Anek{eNhpq=lui-y+_6L2?VlnQZ$;^)C~
zV@RO?zj$YM%u3m?e7KC)-55EI*{(>#6~r0-p<dZB@@q1DHgPtA4}(Zbl4Bl>3J9+>
zq%~x4RY27n4Wm{T7&{NznP6>DlQP7(hBt6sz|*X^7-m=E=jM-KLc?2<3YSfV4+5GT
z-qtXQDYCj?84cYsX6u&J7VpKEvWcPxluM6qdaY?#FBxZ#b!(jp2%ghoHjwgTjV2%J
zue;FHSGVT%hAkd9R4<c$puyEzWi`+yfqbYThk1dna=oK)i6ToB@;t9$0UuG&_UVEy
zF{(V}v4AgE|IDzmwX*R!Bg~oW8=ak6HOpnGWwFU;i+2n49c$H?HKnnqlPfK|Pfl3?
zUpogMLgWYu(B6?}Nc2ALGMt69CJ)i|BNq;Ib5w1k6FppOtqZsSKX+bSM1U4LivUB*
zB;Wbf=f09t$(I!Wc)sNFU&@zMzb{{M`=|0HkAESb`w79os|N@>Z|!4{n`am-r6TEH
zFnowaAa#JT16(`6o4XDXNgaKE{QEPA(jji}<fin!^?!V29ZtKBG`hI<V2HSr#GK*&
zF6RPIKV@}mtZIvOeaZP-RwnCBLXkD$9lXnV2sKRGe2nrPnZX@0w9#3;#~T`y7s$Br
zzKBMn+*5`ve(->iWCQw>si&AtrjDNbo?<TPOdToZ1Kd5KJ7A~mC7mGx>*KHAhSJw^
zZ&S}eZ77fuYbW`dz7p_oIPwEx;Yhgbsx045hNH}oj4I0!IftX1?w#;5U`rv)gb^l;
zB8W=}^Aj_K;eT;3+(|r)`>b3FWtiMa4!Q|-kt-)82Tq6~P84=q8U``BY1s=;DEsJ5
z{*1Yh!f`gFr1QIq2r1Dg$A9uLqAX9i!V~H~rdpTM_T)-GCT;S*+BQqCR-~6U7bCgE
zuF7DM$B2bo40*JF#!VG=zQ~i~KTZfJ5<b{Q6>)yauaJTSVr=~gQnZY69Ag{P6ibFo
zUu9+2D422R{39##ynzX9^F#CnZeSNT@fG*qu=P?v_bE75-XU+VL*AZEnUutyO{0^<
w4cMYmn7!6sjljgmq}D|wYbbK1+9Y3u=P#(j{{lfFF8dulL6ZG|!5sMHAJTYcD*ylh

diff --git a/bin/com/sort/QuickSorting.class b/bin/com/sort/QuickSorting.class
deleted file mode 100644
index 39d93c658713c8a1eb76e12354df7de5a0360f2c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1507
zcmb7E-*XdH6#j0qKa%Z2w+&0hBnTB~e%M4&gPKyLAR3GYiFVA?QMbu9-I8Q8+oTRW
z_f`J~q%(cShr+1S7vKCR{4;pc_}vXtrji#klY7rO_k8Dk_d7TF^PgW20lb4xbwmX0
zrr#}Y`@x|2#n5ZstJCs&Z5@h$wdL$M#g5Z!7i;TVZgU`@EqOg}uq+VGWLE{08-B|*
z5JlXC3Qb_T>h;{uhuw8I_|jSLxB|0Pzv*;Voxqd+^Pn==^tJ`&suP=+1>#3!1oX^W
zrBcbR8W5N<aT3#P?*xHBWUWH8<NqKaXepasdy|2#*Ah_s-i}Yk!sB;~hXc3U7dTNL
zIL&*XIsK4{js#D-j@J`7oms2CxNv<CP=<1LHIDOmUB~<}IqLVfS<b`-Tx36g$UgQM
z?D@qzL=K2|oo+dX1%as*cf$|db5dIaS>$!(1QKDh<M}4uz#?zlmnAwRWoIUF(ov*%
z|0TOJ^g1m!Fz^=M)^Yhb;qW>pr~WR>?>L>ITicN3E7_MD7%1S19Oz;U?^C_F43teQ
z;VNH%)9<@I3cNUp+DpZrlPb#+*Gznf>jJTXKbBYERAyrTEN+;%DWy<DDPp)q8I9{3
z12+g|<kXy?%_o$YFf;+9?hk{ed&`qAaOUVOaiRsO8b`{p@kaoz>;a9dPOr#aa949r
z5PM7`0)wkOmZ?)*&2a+v6ZB&8IWj`9aG=l!9wbwHP#z~!$(GvremR#el$2yiO_j8L
zT-#Me&Q=Sy@^JKQAKI=q%Gny-N26!9YHN>>md7QXt30T2vGp2J%#;axqd$_i_A`te
zx2LdDwz@~hR#S8&<7mkETg=hc$y_pwBf;ot@;^h~DMnr+`wW@qVR10ixPlohW0smH
zP{k?Sg^jO>_?r3O;Z?XuqC;eWH0~2EmAE^;El~-2yf<-nsLlf-ZEAOtm^oTeX0-7N
zErlm7val)o891zLljBVyleBbp0OK)jBt0Ez5q>y_sYo_q@*-#1d@Q%c5^{z=S=#SL
zBdXLIigmfxP_47IhGrSHhHfp@8Zqlmt@;bj&0ab{CVF)r=jr^0LL;9lJjI(&P?~-3
z03RG+`2Z`s5s}ItJ{<j(kLC}R78RAqkNywx#Rv+aNEa}Vi^$;;-_`<dbFWkQZ}>0J
zV$|aRcDet^-@TMHM}c@Fe2h=H&r?1ruHflHC|U#?N0yYzgz`6vQm1q>&AbX@5#0V4
D?Z_)g

diff --git a/bin/com/sort/SelectionSorting.class b/bin/com/sort/SelectionSorting.class
deleted file mode 100644
index 7941054d913e82e4480b68060c980b6a3e8e2e9a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1358
zcmb7DO>@&$6g^LpEk_aHd^iDY0|}HkGDsy2w2;IlfzpO?5i{<j<H@2`Y$a7{TOLJb
zV8tej@+&&9$(k-wrtM_i;RmqgCv@GJQaDe6GKO@)c>L~t@7;UPx#vDT{r9&$0JHc?
zhazyS5w@MJFp8a;-|`!A5O!+Z1)U8Ynm~5byW=@6ue0H}Yn!|mNY4kIAg&0grRfy`
z?ONFM4X79}kwRMFNHysAw|eb0Kl;X7Yxx4h)v)2UR=g;X``3qB{6nxMkgxtPfjNOg
zeWV0ZrPXB#s(Mi*psX$nh=70ERM2Vqcj<4EQ|!09GCTGfKYs0X-$1s#pd&C=TCKiq
zs}@IWc5ZrQ0C^O36#AO3-P>X<6DM$zs9}%&=k}9>(7DabnEAffp37iDU~tJ_4<rAS
zRM5a_e5B)yz(@ktA8+C;rUdk^EYTvVT<IWAI;I82-zB@$3tCM-GEl~O9q0N9C+(Q9
z;jsK2uhsM2by<FS`h5TcC0vkWo66u5N;e=6E}FQ6PdR6=+x0t5f%6AZd#~7QQggDz
zWfNDx@nzz0UtWRH(t-G=v0$PirAQ@G7!bH>;xLY6utY(P#r4>a5<xjuFWTUf8988l
zI)(&{TG)#k{*6FBx?JDW;fQT1BPIx-^8JG=L6PRFbLY?s+LZMxGLPvfFu2NV89K<-
z+z+5V#9c;`<cUmv28};pQJvqxrTju(`@XV+A**Ox1^W?F#f5EE6s^67FaIj!f96HO
zu2=;tZ@X5$=xz&<xAwH=!<T<bU^M}rAq?3h40VDWCg3;*aE$&W=}hsyOd=O}bCFS3
zF_e&;rB5Qraxa^xU>G9_O&g>16h@6BM^9zGfw9CJXY3Ht{~#q^AR~mK{Eedu;f@k8
z=}`=_uoUh=HvNZDS2ee;WoO)aDtp4Mr?ZAz*R%6(J(IodR)4|q;ZwVqR2OzI!Oia|
z)yoC@38?MI!!x^>-Nk3SnBP`Jp-fSpm!IHsnY8#JNpH2Xlg>w}OAZ!0a@gTb+8XJ9
z%Lcx~aWwgL->3Zvg(TWa2KE5gaGgy}Vk1#Z;2f2eiYf5^^Q1Z^v=?x6d?AWsMM`pm
IX9~W21#09N%>V!Z

diff --git a/bin/com/tree/BST.class b/bin/com/tree/BST.class
deleted file mode 100644
index 71d7d67bd0fe2441d5bc3cc8df6c8e330e5178b5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1245
zcmZuwZBNr+6g|(_)@^h!-Uf=W0Ry)&HboQ^6eh-m1g6Qz5<ix$KyhnH*J1oOhVTP?
zK}a<5n<4Q>8PC%dkm-lE_x+x8@9nSO-+lmCz?uS|fLgU01;^I)!t?UB0>41)Ks(Y3
zb<Nx>yxKX?tB!!*wk&>nH?M+AR!v_P2(B2W;XD)QN@psJTc<gKE_AC<5DG&esv>}(
z%r#8C)N1VL_O`ZD*9H1Ft*Tb9Xtp7B&**pdjix})btl4Nqlj#{ZtI#OGt(QH>i`#u
zf+6<00WX3<3`-m%0+Z>Dj)V?Xq7NKt^%l#E4f4@yHGzqAM_7lNsf5{NT*WQimQqs1
zgd`iVjlF#*Li$rGMsY{_rd7;HpTDl}a+ZOnquKl_rv6ScAo{YSRo`xDhu$cHWnHtY
z`vL?1fR}yeP*9M+v99v_rlU7h+{1k`uv#oXwCQfsunMnj!*t5rwANS-;Q<p(woMvM
z({hr#R?DnK@DPg%9<k$pl2k0=G4USCI(3t!)9u>srLeGJ?k#63A#ht!uk>YIfu}06
znB^YJR?DvHFAaGCA?`LWTXAXx%&Qc9crJYVDf5K*4pUo!&-F#J=ZIv*SE!$8^`VFF
z9yc?<j38qb^wOrbqY*<NHC_w`yh^LA@1w2zI|kp33UQA3N2={oK`%{~h_}PM5=@Xw
zreDZ~dc}USwS-;Do<hAqIGdBma;F%Z<#U1&ei9c5&C;I8N+oxO$xHvS>rZ+9l=P>h
zUsCIGsm+rJ5GAP|O1+f&FhVj3(n;~A=7@3$!&s&D1@UbWo5Y@Mqq@Rg!d(tW4!49f
zB_A@B6$GO3P+ZQKyYVP}@hBB@7f?SV*FS%T1((w3hqmE~G>l3TCs4CeNStBCH5_|}
z6b;ub@|+!r*-u>Z2Z>?|Lzu=Ge~5A7nIW120W2biHRS(dP`qML^rjCKT`p|~LHMJw
NSd7r0v4an*e*n^C;FACV

diff --git a/bin/com/tree/BSTDemo.class b/bin/com/tree/BSTDemo.class
deleted file mode 100644
index 5225b707e91cfbcbe6eac2368dabfdced36fe66e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 725
zcmZvZT}vB56o%i4F(2z_)<)A-+gh#KT>~yi?@~&sA_yU+M1tbgWHZE-WEaNO|Kz10
z5fuCZ{wVRC8c36Rb7tN%=i`}k9-r<W0DOa=M@GO6lYWpIt%G09!#&+k^2pMArY=>`
zQ*k%=-9FP{Dv<jg#Zmf0V9N7b0@>Z9qa944C^3zkK&c+Zx^dBOYjddDJuUF2o`kB`
zQYNx`=**_4(Ybw_>|0~azKUXjig!{U^>3yoin}$xmB+k*{5Q>ki(-*xL1GaV7BERd
z)Y7PUgOoKJ_fFzHmINH@*)>|Fme4!!Uy1!7@e!Z+Q`PARta=k66Vh+l`ky6MvBohq
zwKCzUK-oL^FOY=Fbou@AD?b#-v<W{q%Hl>i6{ne8m{9LWcBXQ;rENPPb|fU131oQV
z8ff!W0Z+kmdg~U2>%Y$qt$hX)W@zP00MA*fBIZz{$0lDP%W}Z+J>274ZmL?nLAmNW
z1H2tzd8p)=ni*5GV=6aPZer^UurdN#LxGKQv;|ZMu?`12#QRCC2EmSqWnn8XK={H4
QF!m2Nut{8juhbcM&+^)lkN^Mx

diff --git a/bin/com/tree/Node.class b/bin/com/tree/Node.class
deleted file mode 100644
index 34101324d765de151faff2861731e2e38fa2233c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 434
zcmZ9I%TB^T6o&t43#C{tLd6R!T|uLE<4)to#Ds+4Lc@NjBMd1tDTViPK}=lu06vuQ
zpUOrSJ-0dk`OfM0&*v9_8+2V*0<}0@M0uuEG)iBU3rC<imm3)+aygBjCUX_%0;P>i
z)=EGO1e`>@vD6s;Q{J*E)6*GW%6EFH^Lv4d-e9k3FYS*x?t$DYY}9>J(GakE{jmpu
zLmwrSP1N?`qGF;WA08?Ou9s@GUQAT>A}0wqYYo#_CS#dtlkbX7KGQ3K>T|lzV)dv^
zqi62CHYeho6K(zr^ASZ011dZ*^t_l$9nkvB5?FBPgYW~ju)9SwyxgJ{UTqP)vu>e7
q+u<xT$Kk3T)phFI)E~1N{^@bDqXY$4@Fgh7RuLJtP39>x3unJaRY>Om


From ab14a3cb5874bb84dfa13b2ffbe4f19572d7beda Mon Sep 17 00:00:00 2001
From: hussien alrubaye <hussien89aa@yahoo.com>
Date: Sat, 13 Mar 2021 20:39:35 -0500
Subject: [PATCH 2/2] clean projects

---
 .classpath                           |  6 ------
 .project                             | 17 -----------------
 .settings/org.eclipse.jdt.core.prefs | 11 -----------
 3 files changed, 34 deletions(-)
 delete mode 100644 .classpath
 delete mode 100644 .project
 delete mode 100644 .settings/org.eclipse.jdt.core.prefs

diff --git a/.classpath b/.classpath
deleted file mode 100644
index fceb480..0000000
--- a/.classpath
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/.project b/.project
deleted file mode 100644
index 88a026b..0000000
--- a/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>DSAUdemy</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 3a21537..0000000
--- a/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,11 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.8
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.8