Rewrite all

Author: paveda

__tests__/binarySearch.spec.ts

@@ -1,13 +1,22 @@
-import { SortedArray } from '../src/SortedArray';
-import { defaultComparator } from "../src/helpers";
+import { insert, numberCmp } from '../src';
 
-describe('Insertion in sorted array', () => {
-    const sortedArray = new SortedArray([1, 3, 4], defaultComparator);
+describe('Insertion', () => {
+    it('should insert new element', () => {
+        const array = [0, 1, 3, 4];
+        const EXPECTED = [0, 1, 2, 3, 4];
 
-    it('', () => {
-        const EXPECTED_INDEX = 1;
-        const index = sortedArray.insert(2);
+        insert(array, 2, numberCmp);
 
-        expect(index).toBe(EXPECTED_INDEX);
+        expect(array).toEqual(EXPECTED);
     })
-})
+
+    it('correct insert in first and last position', () => {
+        const array = [1, 2, 3];
+        const EXPECTED = [0, 1, 2, 3, 4];
+
+        insert(array, 0, numberCmp);
+        insert(array, 4, numberCmp);
+
+        expect(array).toEqual(EXPECTED);
+    })
+})

__tests__/insertion.spec.ts

@@ -0,0 +1,21 @@
+import { search, numberCmp } from '../src';
+
+describe('Searching', () => {
+    it('should return index of element', () => {
+        const array = [0, 1, 2, 3, 4, 5];
+        const EXPECTED = 3;
+
+        const index = search(array, 3, numberCmp);
+
+        expect(index).toBe(EXPECTED);
+    })
+
+    it('should return -1 if element is not found', () => {
+        const array = [0, 1, 2, 3, 4, 5];
+        const EXPECTED = -1;
+
+        const index = search(array, 10, numberCmp);
+
+        expect(index).toBe(EXPECTED);
+    })
+})

__tests__/searching.spec.ts

@@ -0,0 +1,12 @@
+import { sort, numberCmp } from '../src';
+
+describe('Sorting', () => {
+    it('should sort array of numbers', () => {
+        const array = [ 2, 5, 1, 0, 4, 3, 6 ];
+        const EXPECTED = [ 0, 1, 2, 3, 4, 5, 6 ];
+
+        const sortedArray = sort(array, numberCmp);
+
+        expect(sortedArray).toEqual(EXPECTED);
+    })
+})

__tests__/sorting.spec.ts

@@ -0,0 +1,9 @@
+import type { Comparator } from './types';
+
+export const numberCmp: Comparator<number> = (a, b) => {
+    if (a === b) {
+        return 0;
+    }
+
+    return a < b ? -1 : 1;
+}

src/SortedArray.ts

@@ -0,0 +1,5 @@
+export { sort } from './sort';
+export { insert } from './insert';
+export { search } from './search';
+export { numberCmp } from './cmp';
+export type { Comparator } from './types';

src/cmp.ts

@@ -0,0 +1,17 @@
+import type { Comparator } from './types';
+import { internalSearch } from './search';
+
+export function insert<T>(array: T[], element: T, cmp: Comparator<T>): number {
+    const { index } = internalSearch(array, element, cmp);
+
+    let top = array.push(element) - 1;
+
+    while (top > index) {
+        array[top] = array[top - 1];
+        array[top - 1] = element; 
+
+        top--
+    }
+
+    return index;
+}

src/helpers/binarySearch.ts

@@ -0,0 +1,42 @@
+import type { Comparator } from './types';
+
+type InternalSearchResult = {
+    index: number;
+    found: boolean;
+}
+
+export function search<T>(array: T[], element: T, cmp: Comparator<T>): number {
+    const { index, found } = internalSearch(array, element, cmp);
+
+    return found ? index : -1;
+}
+
+export function internalSearch<T>(array: T[], element: T, cmp: Comparator<T>): InternalSearchResult {
+    let right = array.length - 1;
+    let left = 0;
+    let mid = 0;
+    let ord = 0;
+
+    while (right >= left) {
+        mid = (left + right) / 2 >>> 0;
+        ord = cmp(element, array[mid]);
+
+        if (ord === 0) {
+            return {
+                index: mid,
+                found: true,
+            }
+        }
+
+        if (ord === 1) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+
+    return {
+        index: left,
+        found: false,
+    }
+}