Implemented Dijkstra Algorithm in Java

Author: sanghaisubham

.gitignore

@@ -1,2 +1,3 @@
 GraphTheory&Trees/BST_JS_implementation/node_modules/
 
+*.o

Algorithms/Graph Algorithms/Shortest Path Algorithm/Dijkstra's Algorithm/Java/Dijkstra.java

@@ -106,7 +106,7 @@ public static void main (String[] args)
                                     {6, 8, 0, 0, 9},
                                     {0, 5, 7, 9, 0},
 				    };
-        ShortestPath t = new ShortestPath();
+        Dijkstra t = new Dijkstra();
         t.dijkstra(graph, 0);
     }
 

Algorithms/Searching Algorithms/Linear Search/JavaScript/LinearSearch.js

@@ -0,0 +1,15 @@
+/**
+ * @author Patryk Jóźwiak
+ */
+function linearSearch(haystack, needle) {
+    var len = haystack.length;
+    // Go through all values
+    for (var i = 0; i < len; i++) {
+        // Check if current value is equel to search value
+        if (haystack[i] === needle) return i;
+    }
+    return -1;
+}
+
+var haystack = [1, 2, 3, 4, 9, 51, 54, 65, 45, 77];
+console.log( linearSearch(haystack, 65) );

Algorithms/Searching Algorithms/Linear Search/Python/LinearSearch.py

@@ -0,0 +1,15 @@
+class LinearSearch():
+    def search(self, haystack, needle):
+        length = len(haystack)
+        # go through all values
+        for i in range(length-1):
+            # check if current value is search value
+            if haystack[i] == needle:
+                return i
+        return -1 
+
+ls = LinearSearch()
+haystack = [2, 3, 5, 7, 11, 13, 17, 19]
+
+print( ls.search(haystack, 7) )
+

Algorithms/Sorting Algorithms/Bubble Sort/C/bubbleSort.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+#include "bubbleSort.h"
+
+static void swap(int *p, int *q)
+{
+        int t = *p;
+        *p = *q;
+        *q = t;
+}
+
+void bubbleSort(int * arr, const size_t sz)
+{
+        int swapped = 1;
+        while(swapped) {
+                swapped = 0;
+                for(int i = 0; i < sz - 1; ++i) {
+                        if(arr[i] > arr[i+1]) {
+                                swap(arr + i, arr + i + 1);
+                                swapped = 1;
+                        }
+                }
+        }
+}

Algorithms/Sorting Algorithms/Bubble Sort/C/bubbleSort.h

@@ -0,0 +1,8 @@
+#ifndef _BUBBLE_SORT_H_
+#define _BUBBLE_SORT_H_
+
+#include <stddef.h>
+
+void bubbleSort(int * array, const size_t size);
+
+#endif

Algorithms/Sorting Algorithms/Bubble Sort/C/tests.c

@@ -0,0 +1,67 @@
+#include <stdio.h>
+
+#include "bubbleSort.h"
+
+#define MAX_ELEMENTS    100     // Maximum Elements that the user test function can handle
+
+static void printArray(int * array, const size_t size);
+void test_1();
+void user_test();
+
+int main(void)
+{
+        test_1();
+        user_test();
+        return 0;
+}
+
+// A function to print elements of an array separated by a tab
+static void printArray(int * array, const size_t size)
+{
+        for(int i = 0; i < size; ++i) {
+                printf("%d\t", array[i]);
+        }
+}
+
+/*
+ * Some Test cases to make sure the sorting algorithm is working
+ * properly.
+ */
+
+void test_1()
+{
+        int tst[] = {12, 0, 90, 31498, 1243, -1435, -1};
+
+        printf("Initial Array : ");
+        printArray(tst, 7);
+        printf("\n");
+
+        bubbleSort(tst, 7);
+        
+        printf("Sorted Array : ");
+        printArray(tst, 7);
+        printf("\n");
+}
+
+void user_test()
+{
+        int tst[MAX_ELEMENTS];
+
+        printf("Enter number of elements you would like to enter : ");
+        int n;
+        scanf("%d", &n);
+        printf("Enter elements of array :\n");
+        for(int i = 0; i < n; ++i) {
+                scanf("%d", &tst[i]);
+        }
+
+        printf("Initial Array : ");
+        printArray(tst, n);
+        printf("\n");
+
+        bubbleSort(tst, n);
+        
+        printf("Sorted Array : ");
+        printArray(tst, n);
+        printf("\n");
+}

Algorithms/Sorting Algorithms/Bubble Sort/README.md

@@ -0,0 +1,7 @@
+#Bubble Sort Algorithm
+----------------------
+
+Bubble Sort Algorithm is a sorting algorithm with O(n^2) complexity. In Bubble Sort algorithm, the elements are sorted by iterating through the whole array and swapping two consecutive elements if they are not in order untill the swap during the iteration becomes zero. At this point, the array becomes sorted. The worst case for bubble sort algorithm to complete is to go through n^2 iterations.
+
+To find more about Bubble Sort Algorithm :
+        https://en.wikipedia.org/wiki/Bubble_sort

Algorithms/Sorting Algorithms/Bubble Sort/Ruby/BubbleSort.rb

@@ -0,0 +1,18 @@
+def bubble_sort(array)
+  swapped = true # This keeps track of when the algo has swapped
+  n = array.length - 1 # This is for a later loop
+
+  # The sort
+  while swapped do
+    swapped = false # Reset the var
+    n.times do [i] 
+      if array[i] > array[i+1] # Checks if items need swapping
+        array[i], array[i+1] = array[i+1], array[i] # Does the swap
+        # We have to do the swap on one line so no entry gets overwritten
+        # Otherwise we need a third variable to store data temporarily
+        swapped = true # Marks the swap
+      end
+    end
+  end
+  array # Return the sorted array
+end

Algorithms/Sorting Algorithms/Insertion Sort/Haskell/InsertionSort.hs

@@ -0,0 +1,8 @@
+module InsertionSort where
+
+sort :: Ord a => [a] -> [a]
+sort [] = []
+sort (x:xs) = sortedInsert x $ sort xs where
+  sortedInsert :: Ord a => a -> [a] -> [a]
+  sortedInsert z [] = [z]
+  sortedInsert z (y:ys) = if z <= y then z:y:ys else y:(sortedInsert z ys)