用JS刷剑指offer

1.二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

//DFS，递归
function TreeDepth(pRoot)
{
    if (pRoot==null){
        return 0;
    }
    let leftheight=TreeDepth(pRoot.left);
    let rightheight=TreeDepth(pRoot.right);
    return Math.max(leftheight,rightheight)+1;
}

//BFS
function TreeDepth(pRoot)
{
    let level=0;
    if (pRoot==null){
        return 0;
    }
    let queue=[pRoot];
    while(queue.length!=0){
        let len=queue.length;
        while(len--){//遍历每一层
            let cur=queue.shift();
            if(cur.left!=null){
                queue.push(cur.left);
            }
            if(cur.right!=null){
                queue.push(cur.right);
            } 
        }
        level++;
      
    }
    return level;
}

2.数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

function duplicate(numbers, duplication)
{
    if(numbers==null){
        return false;
    }
    let count=new Array(1000).fill(0);
    for(let i=0;i<numbers.length;i++){
        if(count[numbers[i]]==1){
            duplication[0]=numbers[i];
            return true;
        }
        else{
            count[numbers[i]]=1;
        }
    }
    return false;
}

3.求1+2+3+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

function Sum_Solution(n)
{
   let sum=Math.pow(n,2)+n;
    return sum>>1;//右移相当于除以2
}

4.剪绳子
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1，m<=n），每段绳子的长度记为k[1],…,k[m]。请问k[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

/**
 * 题目分析：
 * 先举几个例子，可以看出规律来。
 * 4 ： 2*2
 * 5 ： 2*3
 * 6 ： 3*3
 * 7 ： 2*2*3 或者4*3
 * 8 ： 2*3*3
 * 9 ： 3*3*3
 * 10：2*2*3*3 或者4*3*3
 * 11：2*3*3*3
 * 12：3*3*3*3
 * 13：2*2*3*3*3 或者4*3*3*3
 *
 * 下面是分析：
 * 首先判断k[0]到k[m]可能有哪些数字，实际上只可能是2或者3。
 * 当然也可能有4，但是4=2*2，我们就简单些不考虑了。
 * 5<2*3,6<3*3,比6更大的数字我们就更不用考虑了，肯定要继续分。
 * 其次看2和3的数量，2的数量肯定小于3个，为什么呢？因为2*2*2<3*3，那么题目就简单了。
 * 直接用n除以3，根据得到的余数判断是一个2还是两个2还是没有2就行了。
 * 由于题目规定m>1，所以2只能是1*1，3只能是2*1，这两个特殊情况直接返回就行了。
function cutRope(number)
{
    if(number===2) return 1;
    if(number===3) return 2;
    let a=Math.floor(number/3),b=number%3;
    switch(b){
        case 0:return Math.pow(3,a);
        case 1:return Math.pow(3,a-1)*4;
        case 2:return Math.pow(3,a)*2;   
    }
}

5.把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Print(pRoot)
{
    if(pRoot==null){
        return [];
    }
    let queue=[pRoot];
    let que=[];
    while(queue.length){
        let len=queue.length;
        var temp=[];
        while(len--){           
            let cur=queue.shift();
            temp.push(cur.val);
            if(cur.left!=null){
                queue.push(cur.left);
            }
            if(cur.right!=null){
                queue.push(cur.right);
            }
        }
        que.push(temp);
    }
    return que;
}

6.二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Mirror(root)
{
    if(root===null){
        return null;
    }
    let temp = root.left;
    root.left = root.right;
    root.right =temp;
    Mirror(root.left);
    Mirror(root.right);
}

7.变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

function jumpFloorII(number)
{
    if(number==1){
        return 1;
    }else{
        return jumpFloorII(number-1)*2;
    }
}

8.两个栈来实现一个队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

var stack1=[],stack2=[];
function push(node)
{
    stack1.push(node);
}
function pop()
{
    if(stack2.length==0){
        if(stack1.length==0){
            return null;            
        }else{
            while(stack1.length!=0){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }else{
        return stack2.pop();
    }
}

9.整数中1出现的次数
求出1_{13的整数中1出现的次数,并算出100}1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

function NumberOf1Between1AndN_Solution(n)
{
    let num=0;
    for(let i=1;i<=n;i++){
        i.toString().split('').forEach( item=>{
            if(item=='1'){
                num++;
            }
        })
    }
    return num;
}

10.旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

function minNumberInRotateArray(rotateArray)
{
    if(rotateArray.length==0){
        return 0;
    }
    for(let i=0;i<rotateArray.length-1;i++){
        if(rotateArray[i+1]<rotateArray[i]){
            return rotateArray[i+1];
        }
    }
    
}

11.数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

var arr=[];
function Insert(num)
{
    arr.push(num);
    for(let i=arr.length-2;arr[i]>num;i--){
        [arr[i],arr[i+1]]=[arr[i+1],arr[i]];
    }
}
function GetMedian(){
    if(arr.length%2===1){
        return arr[(arr.length-1)/2];
    }else{
        return (arr[arr.length/2]+arr[arr.length/2-1])/2;
    }
}

12.矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

比如n=3时，2*3的矩形块有3种覆盖方法：

function rectCover(number)
{
    if(number==0||number==1||number==2){
        return number;
    }else{
        return rectCover(number-1)+rectCover(number-2);
    }
}

13.跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

function jumpFloor(number)
{
    if(number<=2){
        return number;
        
    }else{
        return jumpFloor(number-1)+jumpFloor(number-2);
    }
}

14.和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

function FindContinuousSequence(sum)
{
    if(sum==0){
        return 0;
    }
    let arr=[];
    for(let i=1;i<=Math.ceil(sum/2);i++){
        let total=0;
        let count=0;
        for(let j=i;j<sum;j++){
            total+=j;
            count++;
            if(total==sum){
                let curr=[];
                for(let k=0;k<count;k++){
                    curr.push(i+k);
                }
                arr.push(curr);
                break;
            }
            else if(total>sum){
                break;
            }
        }
    }
    return arr;
}

15.数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0

function Power(base, exponent)
{
    let cal=1;
    if(exponent==0){
        return 1;
    }
    else if(exponent>0){
        for(let i=0;i<exponent;i++){
           cal*=base;
        }
    }else{
        exponent=-exponent;
        for(let i=0;i<exponent;i++){
           cal*=base;
        }
        cal=1/cal;
        
    }
    return cal;
}

16.二进制中1的个数
输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。

function NumberOf1(n)
{
    let flag=1,count=0;
    while(flag){
        if(flag&n){
            count++;
        }
        flag=flag<<1;
    }
    return count;
}

17.和为S的两个数

function FindNumbersWithSum(array, sum)
{
    let left=0;
    let right=array.length-1;
    let arr=[];
    let min=[];
    while(left<right){
        let cursum=array[left]+array[right];
        if(cursum==sum){
            arr.push([array[left],array[right]]);
            left++;
            right--;
        }
        else if(cursum<sum){
            left++;
        }
        else{
            right--;
        }
    }
    min = arr.length && arr[0];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i][0] * arr[i][1] < min[0] * min[1]) {
            min = arr[i];
        }
    }
    return min;
}

18.数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

function FindNumsAppearOnce(array)
{
    let n=array.length;
    let list=[];
    let acount=new Array(1000).fill(0);
    for(let i=0;i<n;i++){
        acount[array[i]]++;
    }
    for(let i=0;i<acount.length;i++){
        if(acount[i]==1){
            list.push(i);
        }
    }
    return list;
}

19.数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。

function GetNumberOfK(data, k)
{
    let count=0;
    let i=data.indexOf(k);
    while(data[i]==k){
        count++;
        i++;
    }
    return count;
}

20.连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

function FindGreatestSumOfSubArray(array)
{
    let mem=[array[0]];
    let max=array[0];
    for(let i=1;i<array.length;i++){
        mem[i]=Math.max(mem[i-1]+array[i],array[i]);
    }
    for(let i=0;i<mem.length;i++){
        max=Math.max(mem[i],max);
    }
    return max;
}

21.数组中有一个数字出现的次数超过数组长度的一半
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

function MoreThanHalfNum_Solution(numbers)
{
    let n=Math.floor(numbers.length/2);
    let list=new Set(numbers);
    let lists = Array.from(list);
    for(var i=0;i<lists.length;i++){
        let count=0;        
        for(var j=0;j<numbers.length;j++){
            if(numbers[j]==lists[i]){
                count++;
            }
        }
        if(count>n){
            return lists[i];
            break;
        }
        
    }
    return 0;
    
}

22.字符流中第一个只出现一次的字符
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。

//Init module if you need
let map={};
function Init()
{
    map={};
}
//Insert one char from stringstream
function Insert(ch)
{
    map[ch]=map[ch]?map[ch]+1:1;
}
//return the first appearence once char in current stringstream
function FirstAppearingOnce()
{
    for(let i in map){
        if(map[i]===1){
            return i;
            break;
        }
    }
    return '#';
}

23.表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。

//s字符串
function isNumeric(s)
{
    return !isNaN(s);
}

24.扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

function IsContinuous(numbers)
{
    if(numbers.length!=5){
        return false;
    }
    let count=0;
    let dis=0;
    numbers.sort((a,b)=>a-b);
    for(let i=0;i<numbers.length;i++){
        if(numbers[i]==0){
            count++;
        }
    }
    for(let i=4;i>count;i--){
        dis+=numbers[i]-numbers[i-1]-1;
        if(numbers.indexOf(numbers[i])!=i){
            return false;
        }
    }
    
    if(count<dis){
        return false;
    }else{
        return true;
    }
    
}

25.左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

function LeftRotateString(str, n)
{
    if(!str||str.length==0){
        return '';
    }
    n=n%str.length;
    return str.slice(n)+str.slice(0,n);
}

26.链表中环的入口结点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function EntryNodeOfLoop(pHead)
{
    if(!pHead){
        return null;
    }
    let arr=[];
    let temp=pHead;
    while(temp){
        if(arr.indexOf(temp)!=-1){
            return temp;
        }else{
            arr.push(temp);
            temp=temp.next;
        }
    }
    return null;
}

27.孩子们的游戏(圆圈中最后剩下的数)
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

如果没有小朋友，请返回-1

function LastRemaining_Solution(n, m)
{
    if(n<=0||m<1){
        return -1;
    }
    let children=[];
    for(let i=0;i<n;i++){
        children[i]=i;
    }
    let del=0;
    while(children.length>1){
        del=(del+m-1)%children.length;
        children.splice(del,1);
    }
    return children[0];
}

28.两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function FindFirstCommonNode(pHead1, pHead2)
{
    if(pHead1==null||pHead2==null){
        return null;
    }
    let node1=pHead1;
    let node2=pHead2;
    let arr=[];
    while(node1){
        arr.push(node1);
        node1=node1.next;
    }
    while(node2){
        if(arr.indexOf(node2)!=-1){
            return node2;
        }
        node2=node2.next;
    }
    return null;
}

29.合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function Merge(pHead1, pHead2)
{
    if(pHead1 === null) return pHead2;
    else if(pHead2 === null) return pHead1;
    let node1=pHead1;
    let node2=pHead2;
    if(node1.val<=node2.val){
        var merge=node1;
        var root=merge;
        node1=node1.next;
    }
    else{
        var merge=node2;
        var root=merge;
        node2=node2.next;
    }
    while(node1!=null&&node2!=null){
        if(node1.val<=node2.val){
            merge.next=node1;
            merge=merge.next;
            node1=node1.next;
        }else{
            merge.next=node2;
            merge=merge.next;
            node2=node2.next;
        }
    }
    if(node1==null){
        while(node2!=null){
            merge.next=node2;
            merge=merge.next;
            node2=node2.next;
        }
    }
    else{
        while(node1!=null){
            merge.next=node1;
            merge=merge.next;
            node1=node1.next;
        }
    }
    return root;
}

30.反转链表
输入一个链表，反转链表后，输出新链表的表头。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function ReverseList(pHead)
{
    let arr=[];
    let node1=pHead;
    let cur=pHead;
    let res=cur;
    while(node1!=null){
        arr.push(node1.val);
        node1=node1.next;
    }
    arr.reverse();
    for(let i=0;i<arr.length;i++){
        cur.val=arr[i];
        cur=cur.next;
    }
    return res;
    
}

31.二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Convert(pRootOfTree)
{
    if(!pRootOfTree){
        return null;
    }
    let stack=[];
    let p=pRootOfTree;
    let isFirst=true;
    var pre,first,last;
    while(p!=null||stack.length>0){
        while(p){
            stack.push(p);
            p=p.left;
        }
        p=stack.pop();
        if(isFirst){
            first=p;
            pre=p;
            isFirst=false;          
        }
        else{
            p.left=pre;
            pre.right=p;
            pre=p;
        }
        p=p.right;
    }
    return first;
}

32.二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*function TreeLinkNode(x){
    this.val = x;
    this.left = null;
    this.right = null;
    this.next = null;
}*/
//1、有右子树的，那么下个结点就是右子树最左边的点；（eg：D，B，E，A，C，G） ，那么父节点就是下一个节点 ； 
// 2、没有右子树的，也可以分成两类，
//a)是父节点左孩子（eg：N，I，L）
//b)是父节点的右孩子（eg：H，J，K，M）找他的父节点的父节点的父节点...直到当前结点是其父节点的左孩子位置(数拐弯的位置)_。如果没有eg：M，那么他就是尾节点。
function GetNext(pNode)
{
    if(pNode==null){//空树
        return null;
    }
    let p=pNode;
    if(p.right){//有右子树
        p=p.right;
        while(p.left){
            p=p.left;
        }
        return p;
    }
    else{//没有右子树
        if(p.next&&p.next.left==pNode){//是父节点左孩子
            return p.next;
        }
        while(p.next){//是父节点右孩子
            p=p.next;
            if(p.next&&p.next.left==p){
            return p.next;
        }
        }
    }
    return null;//树最后一个节点
}

33.平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function IsBalanced_Solution(pRoot)
{
    if(pRoot==null){
        return true;
    }
    let l1=treeDepth(pRoot.left);
    let l2=treeDepth(pRoot.right);
    let cal=Math.abs(l1-l2);
    if(cal<=1){
        return true;
    }
    return false;
    
}
function treeDepth(pRoot){
    if(pRoot==null){
        return 0;
    }
    let leftDepth=treeDepth(pRoot.left);
    let rightDepth=treeDepth(pRoot.right);
    return Math.max(leftDepth,rightDepth)+1;
}

34.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function reConstructBinaryTree(pre, vin)
{
    let res={};
    if(pre.length==0){
        return null;
    }
    if(pre.length==1){
        res.val=pre[0];
        res.left=null;
        res.right=null;
    }else{
        let root=pre[0];
        let index=vin.indexOf(root);
        let vin1=vin.slice(0,index);
        let vin2=vin.slice(index+1,vin.length);
        pre.shift();
        let pre1=pre.slice(0,vin1.length);
        let pre2=pre.slice(vin1.length,pre.length);
        res.val=root;
        res.left=reConstructBinaryTree(pre1, vin1);
        res.right=reConstructBinaryTree(pre2, vin2);
    }
    return res;
}

35.第一个只出现一次的字符
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

function FirstNotRepeatingChar(str)
{

    let map=new Map();
    for(let i=0;i<str.length;i++){
        if(!map[str[i]]){
            map[str[i]]=1;
        }else {
            map[str[i]]++;
        }
    }
    for(let key in map){
        if(map[key]==1){
            return str.indexOf(key);
        }
    }
    return -1;
}

36.二维数组中的查找

function Find(target, array) {
    for(let i=0;i<array.length;i++){
        if(array[i][0]>target || array[i][array[i].length-1]<target) continue;
        let low = 0, high = array[i].length - 1, mid;
        while (low <= high){
            mid = Math.floor((low+high)/2);
            if(array[i][mid] > target) high = mid-1;
            if(array[i][mid] < target) low = mid+1;
            if(array[i][mid] === target) return true;
        }
    }
    return false;
}
module.exports = {
    Find : Find
};