* 给定一个排序好的数组，两个整数 k 和 x， * 从数组中找到最靠近 x（两数之差最小）的 k 个数。 * 返回的结果必须要是按升序排好的。 * 如果有两个数与 x 的差值一样，优先选择数值较小的那个数。 * * @param {number[]} arr * @param {num

* 输入一个正数sum，打印出所有和为sum的连续正数序列。 * @param {number} sum * @return {number[]}

* 输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。 * 求所有子数组的和的最大值，若不存在，返回0 * * @param {number[]} array * @return {number}

* 假设按照升序排序的数组在预先未知的某个点上进行了旋转。 * 找出其中最小的元素 * @param {number[]} nums * @return {number}

* 在一个有序数组中查找和为sum的两个数字，如果有多个，则输出乘积最小的。 * @param {number[]} array * @param {number} sum * @return {number[]}

* 找到一个数组中只出现一次的数字。若不存在则返回-1 * @param {number[]} numbers * @return {number}

* 寻找数组中的峰值，峰值即是其值大于左右相邻值的元素 * 数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可 * @param {number[]} nums * @return {number}

* 得到两个链表的第一个公共结点。 * @param {ListNode} phead1 * @param {ListNode} phead2 * @return {ListNode}

* 假设按照升序排序的数组在预先未知的某个点上进行了旋转。 * ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 * 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。 * @param {number[]} arr

* 统计一个数字在排序数组中出现的次数。 * @param {number[]} numbers * @param {number} k * @return {number}

* 输入两个二叉树，判断tree2是否为tree1的子结构。 * @param {TreeNode} tree1 * @param {TreeNode} tree2 * @return {boolean}

* 根据传入堆的类型来返回排序数组 * 大顶堆对应从大到小 * 小顶堆对应从小到大 * * @param {number[]} array * @param {string} type

* 将左侧序列看为一个有序的序列，每次都将要插入的数字插入到合适的位置 * 插入时，从有序序列的最右侧开始比较，若比较的数较大，比较的数后移一位，要插入的数继续向前比较知道找到要插入的位置 * * @param {number[]} array * @return {number[]}

* 判断传入的一组扑克牌是否为一个顺子,2-10为数字本身，A为1，J为11，Q为12，K为13，大小王可为任意数字。 * @param {number[]} numbers * @return {boolean}

* @param {number} capacity

* 给定一个字符串，超出其中不含有重复字符的最长子串长度。 * @param {string} s * @return {number}

* 寻找链表的中点，如果是偶数链表返回中间节点中的后一个中间节点。 * @param {ListNode} head * @return {ListNode}

* * @param {*} val * @param {ListNode} next

* 编写一个函数来查找字符串数组中的最长公共前缀。 * 如果不存在公共前缀，返回空字符串。 * @param {string[]} strs * @return {string}

* 合并 k 个排序链表，返回合并后的排序链表。 * @param {ListNode} lists * @return {ListNode}

* 合并两个有序链表 * * @param {ListNode} pHead * @param {ListNode} qHead * @return {List}

* 归并排序，将数组分割成前后两个数组，之后递归分割直到数组长度小于2，进行归并 * @param {number[]} array * @return {number[]}

* 使一个二叉树变化为他的镜像 * 即交换左右节点位置 * * @param {TreeNode} root

* 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 * 如果找到了就输出这个数字，如果不存在输出0。 * @param {number[]} numbers * @return {number}

* 优化空间利用率，不额外开辟空间，时间复杂度依然为O(n) * 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 * 如果找到了就输出这个数字，如果不存在输出0。 * @param {number[]} numbers * @return {number}

* 将0移动到数组后部，同时内部不为0的元素相对位置不变。 * @param {number[]} nums * @return {number[]}

* 给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。 * 数组里字母的顺序是循环的 * * @param {string[]} letters * @param {string} target * @return {st

* 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数。 * @param {number} num * @return {number}

* 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数。 * @param {number} num * @return {number}

* 实现求幂的功能 * @param {number} x * @param {number} n

* 给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素 * @param {number[][]} matrix * @return {number[]}

* 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 * @param {number[][]} arr * @return {number[]}

* 快速排序，单独开辟两个存储空间，左边存放比中介值小的，右边存放比中介值大的 * 递归排序 * * @param {number[]} array * @return {number[]}

* 快速排序，使用索引记录的方法，不需要额外空间 * 递归排序 * * @param {number[]} array * @param {number} start * @param {number} end * @return {number[] | null}

* 重排链表 * 给定一个单链表 L：L0→L1→…→Ln-1→Ln ， * 将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→… * * @param {ListNode} head * @return {ListNode}

* 分离一个数组中的奇数和偶数，使奇数在前，偶数在后。 * @param {number[]} arr * @return {number[]}

* 给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。 * @param {string} s * @return {string[]}

* 反转从位置 m 到 n 的链表 * @param {ListNode} head * @param {number} m 反转开始位置 * @param {number} n 反转结束位置 * @return {ListNode}

* 反转链表 * * @param {ListNode} head * @return {ListNode}

* 将输入的字符串反转过来,不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间。 * @param {string[]} s * @return {string[]}

* 打家劫舍 II * @param {number[]} houses 每家能得到多少钱 * @return {number}

* 给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。 * * @param {ListNode} head * @param {number} k * @return {ListNode}

* 计算是否有一条路径上的总和等于目标和 * @param {TreeNode} root * @param {number} sum * @return {boolean}

* 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。 * * @param {TreeNode} root * @param {number} sum * @return {number[][]}

* 在排序数组中查找元素的第一个和最后一个位置 返回一个数组[FirstIndex, LastIndex] * 若不存在该值，则返回[-1, -1] * * @param {number[]} nums * @param {number} target

* 选择排序，每次循环找到一个最小的数放在前面的有序队列中 * @param {number[]} array * @return {number[]}

* 给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 * * @param {ListNode} head * @param {number} x

* 计算并返回 x 的平方根（整数)，其中 x 是非负整数。 * @param {number} x * @return {number}

* 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。 * * @param {Array} pushOrder * @param {Array} popOrder * @return {Boolean}

* 在不使用数学运算的前提下计算加法。 * @param {number} num1 * @param {number} num2

* 给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。 * @param {string} num1 * @param {string} num2 * @return {string}

* 给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。 * @param {String} num1 * @param {String} num2 * @return {string}

* 给定两个二进制字符串，返回他们的和（用二进制表示。 * 输入为非空字符串且只包含数字 1 和 0。 * @param {string} a * @param {string} b * @return {string}

* 给定一个包含n个整数的数组，找出其中和为0的不重复的三元组 * @param {number[]} arr * @return {number[]}

* 给定一个整数数组 arr 和一个目标值 target，在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 * * @param {number[]} arr * @param {number} target * @return {number[]}

* 编写一个程序，找出第 n 个丑数。 * 丑数就是只包含质因数 2, 3, 5 的正整数。 * @param {number} n * @return {number}

* 给定一个二叉树，原地将它展开为链表。 * @param {TreeNode} root

* 给定一个二叉树，原地将它展开为链表。 * @param {TreeNode} root

* 泰波那契数列 Tn+3 = Tn + Tn+1 + Tn+2 * @param {number} n * @return {number}

* 动态规划实现杨辉三角 * @param {number} n 杨辉三角的高 * @return {number}

* * @param {number[]} postOrder * @param {number[]} inOrder * * @return {TreeNode}

* 根据前序遍历与中序遍历序列构造二叉树 * * @param {number[]} preorder 先序遍历序列 * @param {number[]} inorder 中序遍历序列 * @return {TreeNode}

* @param {number} capacity

* * @param {*} val * @param {ListNode} next

* 除法运算即可以看做被除数一直减去除数直到被除数小于除数为止，此时进行减法的次数就是商，而剩余的被除数就是余数。 * 同样，除法也要注意符号问题，我们和乘法对于符号的解决方法相同。 * @param {number} num1 * @param {number} num2 * @ret

* 班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。 * 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1

* 判断是否为对称二叉树 * 对称二叉树条件为： * - 两个根节点相等 * - 左子树的右节点和右子树的左节点相同 * - 右子树的左节点和左子树的右节点相同 * * @param {Tree} tree

* 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 * 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 * @param {ListNode} pHead * @param {ListN