Java loves typescript

In this article I will compare Java with Typescript and Javascript with a simple algorithm, the binary search tree.

More info about this algorithm see here.

Here is the implementation in JAVA.


// Java implementation of recursive Binary Search
class BinarySearch
{
// Returns index of x if it is present in arr[l..
// r], else return -1
int binarySearch(int arr[], int l, int r, int x)
{
if (r>=l)
{
int mid = l + (r - l)/2;

// If the element is present at the
// middle itself
if (arr[mid] == x)
return mid;

// If element is smaller than mid, then
// it can only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l, mid-1, x);

// Else the element can only be present
// in right subarray
return binarySearch(arr, mid+1, r, x);
}

// We reach here when element is not present
// in array
return -1;
}

// Driver method to test above
public static void main(String args[])
{
BinarySearch ob = new BinarySearch();
int arr[] = {2,3,4,10,40};
int n = arr.length;
int x = 10;
int result = ob.binarySearch(arr,0,n-1,x);
if (result == -1)
System.out.println("Element not present");
else
System.out.println("Element found at index " +
result);
}
}

Typescript


class BinarySearch {
binarySearch(arr : number[], l : number, r : number, x : number) : number {
if(r >= l) {
let mid : number = l + ((r - l) / 2|0);
if(arr[mid] === x) return mid;
if(arr[mid] > x) return this.binarySearch(arr, l, mid - 1, x);
return this.binarySearch(arr, mid + 1, r, x);
}
return -1;
}

public static main(args : string[]) {
let ob : BinarySearch = new BinarySearch();
let arr : number[] = [2, 3, 4, 10, 40];
let n : number = arr.length;
let x : number = 10;
let result : number = ob.binarySearch(arr, 0, n - 1, x);
if(result === -1) console.info("Element not present"); else console.info("Element found at index " + result);
}
}
BinarySearch["__class"] = "BinarySearch";

BinarySearch.main(null);


Javascript

var BinarySearch = (function () {
function BinarySearch() {
}
BinarySearch.prototype.binarySearch = function (arr, l, r, x) {
if (r >= l) {
var mid = l + ((r - l) / 2 | 0);
if (arr[mid] === x)
return mid;
if (arr[mid] > x)
return this.binarySearch(arr, l, mid - 1, x);
return this.binarySearch(arr, mid + 1, r, x);
}
return -1;
};
BinarySearch.main = function (args) {
var ob = new BinarySearch();
var arr = [2, 3, 4, 10, 40];
var n = arr.length;
var x = 10;
var result = ob.binarySearch(arr, 0, n - 1, x);
if (result === -1)
console.info("Element not present");
else
console.info("Element found at index " + result);
};
return BinarySearch;
}());
BinarySearch["__class"] = "BinarySearch";
BinarySearch.main(null);