牛客高频Top200(2)

NC88寻找第K大

从大到小快排 直接输出第k个元素

/**
 * 
 * @param a int整型一维数组 
 * @param n int整型 
 * @param K int整型 
 * @return int整型
 */
function findKth( a ,  n ,  K ) {
    quickSort(a , 0  ,a.length - 1);
    return a[K - 1];
}
function quickSort(a , l  ,r){
    if( l > r) return;
    let i = l;
    let j = r;
    let flag = a[l];
    while( i < j){
        
        while( a[j] <= flag && i < j){
            j--;
        }
        
        while( a[i] >= flag && i < j){
            i++;
        }
        let temp;
        if( i < j){
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
    a[l] = a[i];
    a[i] = flag;
    quickSort(a , l  ,i - 1);
    quickSort(a , i + 1  ,r);
}
module.exports = {
    findKth : findKth
};

NC61俩数之和

比较普遍就是俩层for循环，太过于耗时。这里用了map，时间复杂度O(n),每次遍历，判断 target - 当前元素是否在map中，若在的话返回当前元素下标与value，若不在map中，就往map里加入(target - 当前元素，下标+1)，注意返回时较小的下标在前。

/**
  * 
  * @param numbers int整型一维数组 
  * @param target int整型 
  * @return int整型一维数组
  */
function twoSum( numbers ,  target ) {
    let map = new Map();
    let index1 , index2 ;
    for(let i = 0 ; i < numbers.length ; i++){
        if(map.get(target - numbers[i]) != undefined && map.get(target - numbers[i]) != i + 1){
            index1 = i + 1;
            index2 = map.get(target - numbers[i]);
            break;
        }
        map.set(numbers[i] , i + 1);
    }
    return [Math.min(index1,index2) , Math.max(index1,index2)]
}
module.exports = {
    twoSum : twoSum
};

NC合并俩个有序链表

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function Merge(pHead1, pHead2)
{
    let newHead = null;
    let p;
    while(pHead1 != null && pHead2!= null){
        if(pHead1.val <= pHead2.val){
            if(newHead == null){
                newHead = pHead1;
                p = newHead;
            }else{
                p.next = pHead1;
                p = pHead1;
            }
            pHead1 = pHead1.next;
        }else{
            if(newHead == null){
                newHead = pHead2;
                p = newHead;
            }else{
                p.next = pHead2;
                p = pHead2;
            }
            pHead2 = pHead2.next;
        }
    }
    if(pHead1 != null){
        while(pHead1 != null){
            if(newHead == null){
                newHead = pHead1;
                p = newHead;
            }else{
                p.next = pHead1;
                p = pHead1;
            }
            pHead1 = pHead1.next;
        }
    }
    if(pHead2 != null){
        while(pHead2 != null){
            if(newHead == null){
                newHead = pHead2;
                p = newHead;
            }else{
                p.next = pHead2;
                p = pHead2;
            }
            pHead2 = pHead2.next;
        }
    }
    return newHead;
}
module.exports = {
    Merge : Merge
};

NC76用俩个栈实现队列

let stack_push = [];
let stack_pop = [];
function push(node)
{
    stack_push.push(node);
}
function pop()
{
    // 用于pop的stack为空
    if(stack_pop.length == 0){
        //用于push的stack为空 返回null
        if(stack_push.length == 0) return null;
        else{
            //否则  按stack_push pop的顺序 push进stack_pop 这样就是逆序的
            while(stack_push.length != 0){
                stack_pop.push(stack_push.pop());
            }
        }
    }
    // 直接pop即可
    return stack_pop.pop();
}
module.exports = {
    push : push,
    pop : pop
};

NC68跳台阶

斐波那契

function jumpFloor(number)
{
    let arr = [0 , 1 , 2 ];
    for(let i = 3 ; i <= 40 ; i++){
        arr[i] = arr[i -1] + arr[i - 2];
    }
    return arr[number];
}
module.exports = {
    jumpFloor : jumpFloor
};