Merge sort

Data-Structures/LinkList/__tests__/linked-list.test.js

@@ -0,0 +1,8 @@
+const LinkList = require('../linked-list.js');
+
+xdescribe('Test', () => {
+  // How might we repeat this to check on types?
+  it('true', ()=>{
+    expect(LinkList).toBeTruthy();
+  });
+});

Data-Structures/LinkList/readme.md

@@ -0,0 +1,22 @@
+# Singly Linked List
+
+<!-- Short summary or background information -->
+
+## Challenge
+Write tests to prove the following functionality:
+
+* Can successfully instantiate an empty linked list
+* Can properly insert into the linked list
+* The head property will properly point to the first node in the linked list
+* Can properly insert multiple nodes into the linked list
+* Will return true when finding a value within the linked list that exists
+* Will return false when searching for a value in the linked list that does not exist
+* Can properly return a collection of all the values that exist in the linked list
+
+## Approach & Efficiency
+
+<!-- What approach did you take? Why? What is the Big O space/time for this approach? -->
+
+## API
+
+<!-- Description of each method publicly available to your Linked List -->

Data-Structures/Sorting/InsertionSort/README.md

@@ -0,0 +1,22 @@
+# Insertion Sort
+
+## Links
+
+-   [Link to Pull Request](https://github.com/morgan-401-advanced-javascript/data-structures-and-algorithms/pull/15)
+-   [Link to Travis](https://travis-ci.com/morgan-401-advanced-javascript/data-structures-and-algorithms)
+
+## Whiteboard / Drawing
+
+<!-- Photo of your whiteboard or drawing -->
+
+## Challenge
+
+Write a function called `insertionSort`, which takes an array of numbers and returns a sorted array after using the Insertion Sort algorithm. Do not mutate (change) the array given to you as a parameter.
+
+## Approach & Efficiency
+
+O(n) since we do not mutate the array in place and create a duplicate array that we manipulate
+
+## API
+
+`InsertionSort(array)` function that takes in an array as a parameter

Data-Structures/Sorting/InsertionSort/__tests__/insertion-sort.test.js

@@ -0,0 +1,54 @@
+'use strict';
+const InsertionSort = require('../insertion-sort');
+
+describe('Test', () => {
+  it('true', ()=>{
+    expect(true).toBeTruthy();
+  });
+});
+
+// Sort array of length 1
+xdescribe('Insertion Sort Tests', () => {
+  it('Sort array of length 1', ()=>{
+    let array = [ 13 ];
+    let sortedArray = InsertionSort(array);
+    console.log(sortedArray);
+    expect(sortedArray).toEqual([13]);
+  });
+  // Sort array of length 2
+  it('Sort array of length 2', ()=>{
+    let array = [13, 5];
+    let sortedArray = InsertionSort(array);
+    expect(sortedArray).toEqual([5, 13]);
+  });
+  // Sort array of length 10
+  it('Sort array of length 10', ()=>{
+    let array = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+    let sortedArray = InsertionSort(array);
+    expect(sortedArray).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+  // Incorrect parameter error handling
+  xit('Incorrect parameter error handling', ()=>{
+    let sortedArray = InsertionSort();
+    expect(sortedArray).toBe('Incorrect parameter');
+  });
+  // Not an array
+  it('Not an array', ()=>{
+    let array = 'animal';
+    let sortedArray = InsertionSort(array);
+    expect(sortedArray).toBe('Not an array');
+  });
+  // Empty array
+  it('Empty array', ()=>{
+    let array = [];
+    console.log(array[0]);
+    let sortedArray = InsertionSort(array);
+    expect(sortedArray).toBe('Empty array');
+  });
+  // Array with non-numerical values
+  it('Array with non-numerical values', ()=>{
+    let array = ['blue'];
+    let sortedArray = InsertionSort(array);
+    expect(sortedArray).toBe('Array with non-numerical values');
+  });
+});

Data-Structures/Sorting/InsertionSort/insertion-sort.js

@@ -0,0 +1,33 @@
+'use strict';
+
+function insertionSort(array) {
+  let answer =[...array];
+  if(Array.isArray(array) != true){
+    return('Not an array');
+  }
+  if(array.length === 0){
+    return('Empty array');
+  }
+  if(typeof array[0] != 'number'){
+    return('Array with non-numerical values');
+  }
+  else{
+    let i = 0;
+    while(i <= answer.length){
+      let j =1;
+      while(j > 0){
+        if(answer[j-1] > answer[j]){
+          let temp = answer[j];
+          answer[j] = answer[j-1];
+          answer[j-1] = temp;
+        }
+        j = j-1;
+      }
+      i++;
+    }
+    return answer;
+  }
+
+}
+
+module.exports = insertionSort;

Data-Structures/Sorting/MergeSort/README.md

@@ -0,0 +1,24 @@
+## Links
+
+-   [Link to Pull Request](https://github.com/morgan-401-advanced-javascript/data-structures-and-algorithms/pull/16)
+-   [Link to Travis](https://travis-ci.com/morgan-401-advanced-javascript/data-structures-and-algorithms)
+
+
+## Whiteboard / Drawing
+
+<!-- Photo of your whiteboard or drawing -->
+
+## Challenge
+
+Write a function called mergeSort, which takes an array of numbers and returns a sorted array after using the Merge Sort algorithm. Do not mutate (change) the array given to you as a parameter.
+
+## Approach & Efficiency
+
+ Best case scenario is Big O(nlog(n)) 
+ space is Big O(n)
+
+## API
+
+`mergeSort(arr)` takes in an unsorted array and will return a sorted array
+`sort(temp, sIndx, eIndx)`
+`merge(arr, sIndx, mid, eIndx)`

Data-Structures/Sorting/MergeSort/__tests__/merge-sort.test.js

@@ -0,0 +1,45 @@
+const mergeSort = require('../merge-sort');
+
+
+describe('Test', () => {
+  it('true', ()=>{
+    expect(true).toBeTruthy();
+  });
+});
+
+
+// Incorrect parameter error handling
+describe('Incorrect parameter error handling', () => {
+  // Not an array
+  it('Not an array', ()=>{
+    let testArray = {};
+    expect( mergeSort(testArray)).toBe('Not an array');
+  });
+  // Empty array
+  it('Empty array', ()=>{
+    let testArray = [];
+    expect( mergeSort(testArray)).toBe('Empty array');
+  });
+  // Array with non-numerical values
+  it('Array with non-numerical values', ()=>{
+    let testArray = ['a', 'c'];
+    expect( mergeSort(testArray)).toBe('Not an array of only numerical values');
+  });
+});
+describe('Sorting tests', () => {
+  // Sort array of length 1
+  it('Sort array of length 1', ()=>{
+    let testOne = [42];
+    expect(mergeSort(testOne)).toEqual([42]);
+  });
+  // Sort array of length 2
+  it('Sort array of length 2', ()=>{
+    let testOne = [4, 2];
+    expect(mergeSort(testOne)).toEqual([2, 4]);
+  });
+  // Sort array of length 10
+  it('Sort array of length 10', ()=>{
+    let testOne = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+    expect(mergeSort(testOne)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+});

Data-Structures/Sorting/MergeSort/merge-sort.js

@@ -0,0 +1,47 @@
+'use strict';
+
+function mergeSort(arr) {
+  if(Array.isArray(arr) === false) {
+    return 'Not an array';
+  }
+  if(!arr.every(el => typeof el === 'number')) {
+    return 'Not an array of only numerical values';
+  }
+  if(!arr.length) {
+    return 'Empty array';
+  }
+  if(arr.length === 1) {
+    return arr;
+  }
+  let temp = [...arr];
+
+  function sort(temp, sIndx, eIndx) {
+    if(sIndx >= eIndx) {
+      return;
+    }
+    let mid = Math.floor((sIndx + eIndx)/2);
+    sort(temp, sIndx, mid);
+    sort(temp, mid + 1, eIndx);
+    merge(temp, sIndx, mid, eIndx);
+  }
+  sort(temp, 0, temp.length - 1);
+  return temp;
+}
+
+function merge(arr, sIndx, mid, eIndx) {
+  let merged = [];
+  let j = mid +1;
+  for(let i = sIndx; i <= mid; i++){
+    while(arr[i] > arr[j] && j <= eIndx) { 
+      merged.push(arr[j]);
+      j++;
+    }
+
+    merged.push(arr[i]);
+  }
+  for(let i = 0; i < merged.length; i++) {
+    arr[sIndx + i] = merged[i];
+  }
+}
+
+module.exports = mergeSort;