Code has been reformatted.

Author: phyex0

src/com/company/Algorithms/BinarySearch.java

@@ -1,28 +1,28 @@
 package com.company.Algorithms;
 
 /*
-*   Binary Search:
-*   Best case           = o(1)
-*   Average case        = o(log(n))
-*   Worst case          = o(log(n))
-*
-*
-*   Making a search on sorted array.
-* */
+ *   Binary Search:
+ *   Best case           = o(1)
+ *   Average case        = o(log(n))
+ *   Worst case          = o(log(n))
+ *
+ *
+ *   Making a search on sorted array.
+ * */
 
 
 public class BinarySearch {
 
-    public static int binarySearch(int[] arr,int val){
-        int index=-1, left = 0, right=arr.length, mid;
+    public static int binarySearch(int[] arr, int val) {
+        int index = -1, left = 0, right = arr.length, mid;
 
-        while(right>1){
-            mid = 1+(left-right)/2;
+        while (right > 1) {
+            mid = 1 + (left - right) / 2;
 
-            if(arr[mid]== val)
-                index= mid;
+            if (arr[mid] == val)
+                index = mid;
 
-            else if(arr[mid] > val)
+            else if (arr[mid] > val)
                 left--;
 
             else

src/com/company/Algorithms/BubbleSort.java

@@ -1,30 +1,30 @@
 package com.company.Algorithms;
 
 /*
-*   Bubble Sort:
-*   Best case       = O(n)
-*   Average case    = O(n^2)
-*   Worst case      = O(n^2)
-*
-*   This algorithm sorts the array min to max. If current item is greater than the next it swaps.
-*/
+ *   Bubble Sort:
+ *   Best case       = O(n)
+ *   Average case    = O(n^2)
+ *   Worst case      = O(n^2)
+ *
+ *   This algorithm sorts the array min to max. If current item is greater than the next it swaps.
+ */
 
 public class BubbleSort {
 
-    public static void bubbleSort(int[] arr){
+    public static void bubbleSort(int[] arr) {
         int len = arr.length;
 
-        for(int i=0;i<len-1;i++){
-            for(int j=0;j<len-i-1;j++){
-                if(arr[j]>arr[j+1])
-                    swap(arr,j,j+1);
+        for (int i = 0; i < len - 1; i++) {
+            for (int j = 0; j < len - i - 1; j++) {
+                if (arr[j] > arr[j + 1])
+                    swap(arr, j, j + 1);
             }
         }
 
     }
 
     //swaps the elements.
-    private static void swap(int[] arr, int i,int j){
+    private static void swap(int[] arr, int i, int j) {
         int temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;

src/com/company/Algorithms/LinearSearch.java

@@ -1,20 +1,20 @@
 package com.company.Algorithms;
 
 /*
-*   Linear Search Algorithm:
-*   Best case       = O(1)
-*   Worst case      = O(n)
-*   Average case    = O(n)
-*
-* If the given item is not in your list it returns -1 otherwise it returns the index that was first found.
-*/
+ *   Linear Search Algorithm:
+ *   Best case       = O(1)
+ *   Worst case      = O(n)
+ *   Average case    = O(n)
+ *
+ * If the given item is not in your list it returns -1 otherwise it returns the index that was first found.
+ */
 public class LinearSearch {
 
-    public static int linearSearch(int[] arr, int val){
-        int index=-1;
-        for(int i=0;i<arr.length;i++)
-            if(arr[i]==val){
-                index=i;
+    public static int linearSearch(int[] arr, int val) {
+        int index = -1;
+        for (int i = 0; i < arr.length; i++)
+            if (arr[i] == val) {
+                index = i;
                 break;
             }
 

src/com/company/DataStructures/LinkedList.java

@@ -1,181 +1,170 @@
 package com.company.DataStructures;
 
 /*
-*   Linked List:
-*   Random access is not simple like the arrays
-*   Linked List has unlimited size. It depending your memory.
-*
-*   Inserting to head           = o(1)
-*   Inserting to end            = o(1)
-*   Inserting to given index    = o(n)
-*   Deleting given item         = o(n)
-*   Reversing the list          = o(n)
-*   Searching an item           = o(n)
-*
-*/
+ *   Linked List:
+ *   Random access is not simple like the arrays
+ *   Linked List has unlimited size. It depending your memory.
+ *
+ *   Inserting to head           = o(1)
+ *   Inserting to end            = o(1)
+ *   Inserting to given index    = o(n)
+ *   Deleting given item         = o(n)
+ *   Reversing the list          = o(n)
+ *   Searching an item           = o(n)
+ *
+ */
 
 public class LinkedList {
 
-    class Node{
-        int val;
-        Node next;
-
-
-        public Node(int val) {
-            this.val = val;
-            next=null;
-        }
-
-    }
-
-     Node root;
-     Node tail;
-
+    Node root;
+    Node tail;
     public LinkedList() {
-        this.root =null;
+        this.root = null;
         this.tail = null;
     }
 
     //inserting data to end of list.
-    public void insertToEnd(int val){
-        if(root ==null){
+    public void insertToEnd(int val) {
+        if (root == null) {
             root = new Node(val);
-            tail =root;
-            tail.next=null;
-        }
-
-        else {
-            tail.next= new Node(val);
-            tail =tail.next;
-            tail.next=null;
+            tail = root;
+            tail.next = null;
+        } else {
+            tail.next = new Node(val);
+            tail = tail.next;
+            tail.next = null;
 
         }
     }
 
     //inserting data to head of list.
-    public void insertToHead(int val){
+    public void insertToHead(int val) {
         Node temp = new Node(val);
-        if(root==null){
-            root=temp;
-            tail=root;
-            tail.next=null;
-        }
-
-        else{
-            temp.next=root;
-            root=temp;
+        if (root == null) {
+            root = temp;
+            tail = root;
+            tail.next = null;
+        } else {
+            temp.next = root;
+            root = temp;
         }
 
     }
 
     //inserting data to given index;
-    public void insertToIndex(int index, int val){
+    public void insertToIndex(int index, int val) {
         Node temp = new Node(val);
         Node iter = root;
         int len = lenOfList();
 
-        if(index<0 || index>len)
-            System.out.println("You cannot insert to given position: "+index);
+        if (index < 0 || index > len)
+            System.out.println("You cannot insert to given position: " + index);
 
-        else if(index==0)
+        else if (index == 0)
             insertToHead(val);
 
-        else if(index<=len) {
-            for (int i = 0; i < index-1; i++)
+        else if (index <= len) {
+            for (int i = 0; i < index - 1; i++)
                 iter = iter.next;
             temp.next = iter.next;
             iter.next = temp;
         }
     }
 
     //returns length of the list.
-    public int lenOfList(){
+    public int lenOfList() {
         Node iter = root;
-        int count =0;
-        while(iter!=null){
+        int count = 0;
+        while (iter != null) {
             count++;
-            iter=iter.next;
+            iter = iter.next;
         }
         return count;
     }
 
     //printing list
-    public void print(){
+    public void print() {
 
-       Node iter = root;
+        Node iter = root;
 
-        while(iter!=null){
+        while (iter != null) {
             System.out.println(iter.val);
-            iter=iter.next;
+            iter = iter.next;
         }
 
     }
 
     //deleting item
-    public void deleteItem(int val){
-        boolean isHere =false;
+    public void deleteItem(int val) {
+        boolean isHere = false;
         Node iter = root;
         Node temp = null;
-        if(root.val ==val){
-            temp=root;
-            root=root.next;
-            temp=null;
+        if (root.val == val) {
+            temp = root;
+            root = root.next;
+            temp = null;
             isHere = true;
             return;
         }
 
-        while(iter.next != null){
-            if(iter.next!= null && iter.next.val == val){
+        while (iter.next != null) {
+            if (iter.next != null && iter.next.val == val) {
                 temp = iter.next;
-                iter.next=temp.next;
-                temp=null;
-                isHere =true;
+                iter.next = temp.next;
+                temp = null;
+                isHere = true;
                 break;
             }
-            iter=iter.next;
+            iter = iter.next;
         }
-        if(!isHere)
-           System.out.println("Given item is not element of the list.");
-
+        if (!isHere)
+            System.out.println("Given item is not element of the list.");
 
 
     }
 
     //reverse the list
-    public void reverseList(){
-        LinkedList reverseList =new LinkedList();
-        Node iter= root;
+    public void reverseList() {
+        LinkedList reverseList = new LinkedList();
+        Node iter = root;
 
-       while(iter!=null){
-           reverseList.insertToHead(iter.val);
-           iter=iter.next;
-       }
+        while (iter != null) {
+            reverseList.insertToHead(iter.val);
+            iter = iter.next;
+        }
 
-       root= reverseList.root;
-       tail = reverseList.tail;
+        root = reverseList.root;
+        tail = reverseList.tail;
     }
 
     //if the given value exists in the list it returns true else it's false
-    public boolean isExists(int val){
-        Node iter =root;
-        boolean result =false;
+    public boolean isExists(int val) {
+        Node iter = root;
+        boolean result = false;
 
-        while(iter!= null){
-            if(iter.val == val){
+        while (iter != null) {
+            if (iter.val == val) {
                 result = true;
                 break;
             }
-            iter=iter.next;
+            iter = iter.next;
 
         }
 
         return result;
     }
 
+    class Node {
+        int val;
+        Node next;
 
 
+        public Node(int val) {
+            this.val = val;
+            next = null;
+        }
 
-
+    }
 
 
 }