Feature- Adding merge sort

app/build.gradle

@@ -43,4 +43,7 @@ dependencies {
     }
 
 
+    testCompile 'junit:junit:4.12'
+    testCompile 'org.mockito:mockito-core:1.10.19'
+
 }

app/src/main/assets/desc.json

@@ -94,6 +94,16 @@
       "<a href='https://github.com/naman14/AlgorithmVisualizer-Android/blob/master/app/src/main/java/com/naman14/algovisualizer/visualizer/SortingVisualizer.java'>SortingVisualizer</a>"
     ]
   },
+  "merge_sort": {
+    "Merge Sort": "Merge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for the two halves and then merges the two sorted halves",
+    "Complexity": {
+      "Time": "worst O(n log(n)), best O(n log(n)), average O(n log(n))",
+      "Space": "worst O(n) auxiliary"
+    },
+    "References": [
+      "<a href='https://en.wikipedia.org/wiki/Merge_sort'>Wikipedia<a/><br>"
+    ]
+  },
   "linked_list": {
     "Singly linked list": "A Linked List is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represent a sequence. Under the simplest form, each node is composed of data and a reference (in other words, a link) to the next node in the sequence. ",
     "Complexity": {

app/src/main/java/com/naman14/algovisualizer/AlgorithmCode.java

@@ -65,6 +65,42 @@ public class AlgorithmCode {
             " addLog(\"Array has been sorted\");\n" +
             " completed();";
 
+    public static final String CODE_MERGE_SORT = "" +
+            "public void mergeSort(int start, int end){\n" +
+            "   if (start >= end){\n" +
+            "       return;\n" +
+            "   }\n" +
+            "   int middle = (start + end)/2;\n" +
+            "   mergeSort(start,middle);\n" +
+            "   mergeSort(middle+1,end);\n" +
+            "   merge(start,middle,middle+1,end);\n" +
+            "}\n" +
+            "public void merge(int start1, int end1, int start2, int end2){\n" +
+            "   List<Integer> sortedList = new ArrayList<Integer>();\n" +
+            "   List<Integer> indexes = new ArrayList<Integer>();\n" +
+            "   int s0 = start1;\n" +
+            "   while(start1 <= end1){\n" +
+            "       if (start2 > end2){\n" +
+            "           sortedList.add(array[start1]);\n" +
+            "               start1+=1;\n" +
+            "               continue;\n" +
+            "       }\n" +
+            "       if (array[start1] <= array[start2]){\n" +
+            "           sortedList.add(array[start1]);\n" +
+            "           start1+=1;\n" +
+            "       }\n" +
+            "       else{\n" +
+            "           sortedList.add(array[start2]);\n" +
+            "           start2+=1;\n" +
+            "       }\n" +
+            "   }\n" +
+            "   int i = 0;\n" +
+            "   for (int number:sortedList) {\n" +
+            "       array[s0+i]=number;\n" +
+            "       i+=1;\n" +
+            "   }\n" +
+            "}";
+
     public static final String CODE_BST_SEARCH = " int id = DataUtils.getRandomKeyFromBST();\n" +
             " addLog(\"Searching for \" + String.valueOf(id));\n" +
             " BinarySearchTree.Node current = b.getRoot();\n" +

app/src/main/java/com/naman14/algovisualizer/CodeFragment.java

@@ -67,6 +67,9 @@ public void setCode(String key) {
                 case Algorithm.SELECTION_SORT:
                     addCodeItem(AlgorithmCode.CODE_SELECTION_SORT,"Selection sort");
                     break;
+                case Algorithm.MERGE_SORT:
+                    addCodeItem(AlgorithmCode.CODE_MERGE_SORT, "Merge sort");
+                    break;
                 case Algorithm.BST_SEARCH:
                     addCodeItem(AlgorithmCode.CODE_BST_SEARCH, "BST Search");
                     break;

app/src/main/java/com/naman14/algovisualizer/MainActivity.java

@@ -93,6 +93,10 @@ public boolean onChildClick(ExpandableListView expandableListView, View view, in
                                 break;
                             case 2:
                                 algoFragment.setupFragment(Algorithm.SELECTION_SORT);
+                                break;
+                            case 3:
+                                algoFragment.setupFragment(Algorithm.MERGE_SORT);
+                                break;
                         }
                         break;
                     case 2:
@@ -208,6 +212,7 @@ private void prepareListData() {
         heading2.add("Bubble Sort");
         heading2.add("Insertion Sort");
         heading2.add("Selection Sort");
+        heading2.add("Merge Sort");
         List<String> heading3 = new ArrayList<String>();
         heading3.add("BST Search");
         heading3.add("BST Insert");

app/src/main/java/com/naman14/algovisualizer/VisualAlgoFragment.java

@@ -41,6 +41,7 @@
 import com.naman14.algovisualizer.algorithm.search.LinearSearch;
 import com.naman14.algovisualizer.algorithm.sorting.BubbleSort;
 import com.naman14.algovisualizer.algorithm.sorting.InsertionSort;
+import com.naman14.algovisualizer.algorithm.sorting.MergeSort;
 import com.naman14.algovisualizer.algorithm.sorting.SelectionSort;
 import com.naman14.algovisualizer.algorithm.tree.bst.BSTAlgorithm;
 import com.naman14.algovisualizer.visualizer.AlgorithmVisualizer;
@@ -190,6 +191,12 @@ public void setupFragment(String algorithmKey) {
                 algorithm = new SelectionSort((SortingVisualizer) visualizer, getActivity(), logFragment);
                 ((SelectionSort) algorithm).setData(DataUtils.createRandomArray(15));
                 break;
+            case Algorithm.MERGE_SORT:
+                visualizer = new SortingVisualizer(getActivity());
+                appBarLayout.addView(visualizer);
+                algorithm = new MergeSort((SortingVisualizer)visualizer, getActivity(), logFragment);
+                ((MergeSort)algorithm).setData(DataUtils.createRandomArray(15));
+                break;
             case Algorithm.BST_SEARCH:
                 visualizer = new BSTVisualizer(getActivity());
                 appBarLayout.addView(visualizer);

app/src/main/java/com/naman14/algovisualizer/algorithm/Algorithm.java

@@ -42,6 +42,7 @@ public class Algorithm extends HandlerThread {
     public static final String DFS = "dfs";
     public static final String DIJKSTRA = "dijkstra";
     public static final String BELLMAN_FORD = "bellman_ford";
+    public static final String MERGE_SORT = "merge_sort";
 
 
     public LogFragment logFragment;

app/src/main/java/com/naman14/algovisualizer/algorithm/sorting/MergeSort.java

@@ -0,0 +1,99 @@
+package com.naman14.algovisualizer.algorithm.sorting;
+
+import android.app.Activity;
+
+import com.naman14.algovisualizer.LogFragment;
+import com.naman14.algovisualizer.algorithm.Algorithm;
+import com.naman14.algovisualizer.algorithm.DataHandler;
+import com.naman14.algovisualizer.visualizer.SortingVisualizer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by sergio on 02/01/17.
+ */
+
+public class MergeSort extends SortAlgorithm implements DataHandler {
+
+    private int[] array;
+
+    public MergeSort(SortingVisualizer visualizer, Activity activity, LogFragment logFragment) {
+        this.visualizer = visualizer;
+        this.activity = activity;
+        this.logFragment = logFragment;
+    }
+
+    private void sort(){
+        logArray("Original array - " ,array);
+        mergeSort(0,array.length-1);
+        completed();
+    }
+
+    public void mergeSort(int start, int end){
+        addLog("Sorting array between " + start + " and " + end);
+        if (start >= end){
+            return;
+        }
+        int middle = (start + end)/2;
+        highlightInterval(start,middle);
+        sleep();
+        mergeSort(start,middle);
+        highlightInterval(middle+1,end);
+        sleep();
+        mergeSort(middle+1,end);
+        highlightInterval(start,end);
+        sleep();
+        merge(start,middle,middle+1,end);
+    }
+
+    public void merge(int start1, int end1, int start2, int end2){
+        addLog("merging sub-array " + start1 + " to " + end1 + " and subarray " + start2 + " to " +
+        end2);
+        List<Integer> sortedList = new ArrayList<Integer>();
+        int s0 = start1;
+        while(start1 <= end1){
+            if (start2 > end2){
+                sortedList.add(array[start1]);
+                start1+=1;
+                continue;
+            }
+            if (array[start1] <= array[start2]){
+                sortedList.add(array[start1]);
+                start1+=1;
+            }
+            else{
+                sortedList.add(array[start2]);
+                start2+=1;
+            }
+        }
+        int i = 0;
+        for (int number:sortedList) {
+            array[s0+i]=number;
+            i+=1;
+        }
+        sleep();
+    }
+
+    @Override
+    public void run() {
+        super.run();
+    }
+
+    @Override
+    public void onDataRecieved(Object data) {
+        super.onDataRecieved(data);
+        this.array = (int[])data;
+
+    }
+
+    @Override
+    public void onMessageReceived(String message) {
+        super.onMessageReceived(message);
+        if(message.equals(Algorithm.COMMAND_START_ALGORITHM)){
+            startExecution();
+            sort();
+        }
+
+    }
+}

app/src/main/java/com/naman14/algovisualizer/algorithm/sorting/SortAlgorithm.java

@@ -52,6 +52,24 @@ public void run() {
         });
     }
 
+    public void highlightInterval(final int start, final int end){
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                visualizer.highlightInterval(start,end);
+            }
+        });
+    }
+
+    public void resetInterval(){
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                visualizer.highlightInterval(-1,-1);
+            }
+        });
+    }
+
     @Override
     public void onDataRecieved(Object data) {
 

app/src/main/java/com/naman14/algovisualizer/visualizer/SortingVisualizer.java

@@ -32,6 +32,8 @@ public class SortingVisualizer extends AlgorithmVisualizer {
     int highlightPositionOne = -1, highlightPositionTwo = -1;
     int highlightPosition = -1;
     int lineStrokeWidth = getDimensionInPixel(10);
+    int startInterval, endInterval = -1;
+
 
     public SortingVisualizer(Context context) {
         super(context);
@@ -72,14 +74,23 @@ protected void onDraw(Canvas canvas) {
             for (int i = 0; i < array.length; i++) {
 
                 if (i == highlightPositionOne || i == highlightPositionTwo) {
-                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()), xPos, getHeight(), highlightPaintSwap);
+                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()),
+                            xPos, getHeight(), highlightPaintSwap);
                 } else if (i == highlightPosition)
-                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()), xPos, getHeight(), highlightPaintTrace);
+                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()),
+                            xPos, getHeight(), highlightPaintTrace);
+                else if (startInterval >= 0 && endInterval >= startInterval &&
+                        i >= startInterval && i <= endInterval) {
+                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()),
+                            xPos, getHeight(), highlightPaintTrace);
+                }
                 else {
-                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()), xPos, getHeight(), paint);
+                    canvas.drawLine(xPos, getHeight() - (float) ((array[i] / 10.0) * getHeight()),
+                            xPos, getHeight(), paint);
                 }
 
-                canvas.drawText(String.valueOf(array[i]), xPos - lineStrokeWidth / 3, getHeight() - (float) ((array[i] / 10.0) * getHeight()) - 30, textPaint);
+                canvas.drawText(String.valueOf(array[i]), xPos - lineStrokeWidth / 3,
+                        getHeight() - (float) ((array[i] / 10.0) * getHeight()) - 30, textPaint);
 
                 xPos += margin + 30;
             }
@@ -111,11 +122,23 @@ public void highlightTrace(int position) {
         invalidate();
     }
 
+    public void highlightInterval(int start, int end){
+        this.startInterval = start;
+        this.endInterval = end;
+        invalidate();
+    }
+
+    public void resetHighlightInterval(){
+        highlightInterval(-1,-1);
+    }
+
     @Override
     public void onCompleted() {
         this.highlightPosition = -1;
         this.highlightPositionTwo = -1;
         this.highlightPositionOne = -1;
+        this.startInterval = -1;
+        this.endInterval = -1;
         invalidate();
     }
 }

app/src/main/res/values/strings.xml

@@ -2,4 +2,6 @@
     <string name="app_name">AlgorithmVisualizer</string>
     <string name="action_settings">Settings</string>
     <string name="report_bugs">Report any bugs <u> here </u></string>
+    <string name="fabric_api_key">key</string>
+    <string name="play_billing_license_key">key</string>
 </resources>