TOP1

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function ReverseList(pHead)
// 本题主要是利用递归的思想，我们首先要判断临界条件
// 然后把这个递归调用的函数当成一个可以实现功能的黑盒
// 只要临界条件设对了，那么递归就能实现我们想要的功能
{
//     临界条件
//     首先判断单链表要是为空或者只有一个节点 那么就直接返回
    if(!pHead || !pHead.next) return pHead;
//     创建新的反转链表，newHead指向反转后的新链表的头结点
    let newhead = ReverseList(pHead.next);
    pHead.next.next = pHead;
    pHead.next = null;
    return newhead;
}

module.exports = {
    ReverseList : ReverseList
};

TOP2

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 将给定数组排序
 * @param arr int整型一维数组 待排序的数组
 * @return int整型一维数组
 */
function MySort( arr ) {
    // write code here
//     这里用快速排序实现，因为这个面试考的比较多
//     我们首先要知道快排的基本思想  B站上直接搜就有可视化的动画演示
    function qsort(arr,begin,end){
//        三个参数分别指 数组本体、左边界、右边界
//         临界条件 如果左边界大于右边界直接返回
        if(begin>end) return ;
//         这个值是随便选的用来做哨兵的 比它大的放它右边 比它小的放他左边
//         一般选第一个值比较方便
        let temp=arr[begin];
        let i=begin;
        let j=end;
//         i和j分别是左右指针 当左边的指针等于右边的指针时说明已经检测完了
        while(i!=j){
          while(arr[j]>=temp&&j>i){
//               如果右边的这个指针指向的值大于等于哨兵的值且右指针比左指针大
//               那就让右指针往左走一步
              j--;
          }
//             从while出来意味着 右指针指向的这个值小于哨兵的值 或者左右指针重合
          while(arr[i]<=temp&&j>i){
//               如果左边的这个指针指向的值小于等于哨兵的值且右指针比左指针大
//               那就让左指针往右走一步
              i++;
          }
//             从while出来意味着 左指针指向的这个值大于哨兵的值 或者左右指针重合
//             如果做右指针没重合
            if(j>i){
//                 让左右指针指向的值交换位置
                let t = arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
        }
//         把哨兵放在左右指针相交的位置
        arr[begin]=arr[i];
        arr[i]=temp;
//         哨兵值这会儿就跑中间来了
//         对哨兵左边的快排
        qsort(arr,begin,i-1)
//         对哨兵右边的快排
        qsort(arr,i+1,end)
    }
    qsort(arr,0,arr.length-1)
    return arr
}
module.exports = {
    MySort : MySort
};

TOP3

这道题还没写出来，先放在这以后有时间了写一下

TOP4

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
 * 
 * @param root TreeNode类 the root of binary tree
 * @return int整型二维数组
 */

//这道题太基础了 没啥好说的
    let preArr = []
    let headArr = []
    let proArr = []
function preOrders( root ) {
    if(!root){return null}
    preArr.push(root.val)
   preOrders(root.left)
   preOrders(root.right)
}
function headOrders( root ) {
    if(!root){return null}
    headOrders(root.left)
   headArr.push(root.val)
   headOrders(root.right)
}
function proOrders( root ) {
    if(!root){return null}
    proOrders(root.left)
    proOrders(root.right)
   proArr.push(root.val)
     
}
function threeOrders( root ) {
    // write code here
    preOrders(root)
    headOrders(root)
    proOrders(root)
   let res = []
   res.push(preArr,headArr,proArr)
    return res
}
module.exports = {
    threeOrders : threeOrders
};

TOP5

function GetLeastNumbers_Solution(input, k)
{
    // write code here
   if(k>input.length) return input.length=0;
//     升序排列
    input.sort((a,b)=>(a-b))
//     让这个数组的长度为k 意味只保留前的k个数
    input.length=k;
    return input;
}
module.exports = {
    GetLeastNumbers_Solution : GetLeastNumbers_Solution
};

TOP6

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @return int整型二维数组
  */
function levelOrder( root ) {
   let arr=[];
//     BFS算法
    function traversal(root,arr,level){
        if(!root) return;
        if(!arr[level]) arr[level]=[]
//         把每一层的节点都放在一个数组里
        arr[level].push(root.val)
//        只需要考虑一个二叉树 剩下的递归就完事了
        traversal(root.left,arr,level+1)
        traversal(root.right,arr,level+1)
    }
    traversal(root,arr,0)
    return arr
}
module.exports = {
    levelOrder : levelOrder
};

TOP7

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

TOP8

/**
  * 
  * @param numbers int整型一维数组 
  * @param target int整型 
  * @return int整型一维数组
  */
function twoSum( numbers ,  target ) {
   const ans=new Array(2)
   let map=new Map();
    let n=numbers.length;
    for(let i=0;i<n;i++){
//         遍历一波 
//         看看map里面有没有与该值相加等于target的值 如果没有就把该值放到map里
        if(map.has(target-numbers[i])){
            ans[0]=map.get(target-numbers[i])+1;
            ans[1]=i+1;
            break
        }else{
            map.set(numbers[i],i)
        }
    }
    return ans
}
module.exports = {
    twoSum : twoSum
};

TOP9

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function Merge(pHead1, pHead2)
{
    // write code here
//     临界条件
    if (!pHead1  ) return pHead2;
    if (!pHead2  ) return pHead1;
    if(pHead1.val<=pHead2.val){
        pHead1.next=Merge(pHead1.next,pHead2)
        return pHead1;
    }else{
        pHead2.next=Merge(pHead2.next,pHead1)
        return pHead2
    }
}
module.exports = {
    Merge : Merge
};

TOP10

let a1=[]
let a2=[]
function push(node)
{
    // write code here
    a1.push(node);
}
function pop()
{
    // write code here
    if(!a2.length){
        while(a1.length){
            a2.push(a1.pop())
        }
    }
     return a2.pop()
}
module.exports = {
    push : push,
    pop : pop
};