* 正序遍历链表,返回一个数组 * * @return {any[]} *

* 位运算实现加法。异或之后通过与运算获取进位进位一位后递归求和，直到无进位。 * @param {number} num1 * @param {number} num2 * @return {number}

* 位运算实现加法。异或之后通过与运算获取进位进位一位后递归求和，直到无进位。 * @param {number} num1 * @param {number} num2 * @return {number}

* 从 0 开始计算，找到包括head 头节点 在哪的位于 index 位置的节点 * @param { Number } index * @return {ListNode}

* @param {number} key * @return {number}

* @return {T}

* 删除指定位置的节点 * * @param {number} index

* @param {number} key * @param {number} value * @return {void}

* 分发饼干，尽可能多的满足孩子 * @param {number[]} children 孩子们的胃口值 * @param {number[]} biscuits 饼干的大小

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

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

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

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

* 计算机内，减法被转化为加上该数的负数，即我们也以加法实现。 * @param {number} num1 * @param {number} num2 * @return {number}

* 给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。 * @param {string} s1 * @param {string} s2 * @return {boolean}

* 得到一个链表的长度。 * @param {ListNode} phead * @return {number}

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

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

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

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

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

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

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

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

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

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

* 堆属于优先队列，只能从末尾添加 * 添加后有可能破坏堆的结构，需要从下到上进行调整 * 如果元素小于父元素，向上置换 *

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

* 给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。 * 找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。) * @param {number[]

* 买卖股票的最佳时机 只能买一次 * @param {number[]} prices * @return {number}

* 给出一个区间的集合，合并所有重叠的区间。 * @param {number[][]} intervals * @return {number[][]}

* 合并两个有序链表 * @param {ListNode} list1 * @param {ListNode} list2 * @return {ListNode}

* 合并两个有序链表 * @param {ListNode} list1 * @param {ListNode} list2 * @return {ListNode}

* 判断是否符合ip规则。 * @param {string} s * @return {boolean}

* 判断是否符合ip规则。 * @param {string} s * @return {boolean}

* 判断输入序列是否为一颗二叉搜索树的后序遍历序列。 * @param {number} sequence * @return {boolean}

* 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target * 写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 * @param {number[]} nums 要查询的数组 * @param {number} target 查

* 冒泡排序，使用循环数组的方法，比较当前元素和下一个元素，如果当前元素大，向上冒泡 * * @param {number[]} array * @return {number[]}

* 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 * 每次你可以爬 1 或 2 个台阶，求有多少种方法到达楼顶 * 递归实现爬楼梯问题 * @param {number} n * @return {number}

* 使用记忆化存储避免重复计算 * @param {number} n * @param {number[]} memory * @return {number}

* 给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。 * 重复出现的子串要计算它们出现的次数。 * @param {string} str * @return {number}

* 删除排序链表中的重复元素

* 删除链表的倒数第N个节点 * * @param {ListNode} head * @param {number} n * @return {ListNode}

* 两两交换相邻的节点 * * @param {ListNode} head * @return {ListNode}

* 使用非递归的动态规划实现斐波那契数列 * @param {number} n * @return {number}

* 使用递归实现斐波那契数列 * @param {number} n * @return {number}

* 在递归中添加一个缓存来缓存计算过的值，避免重复计算 * @param {number} n * @param {number[]} memory 用来添加一个缓存 * @return {number}

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

* 输入一个正数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}

* 统计一个数字在排序数组中的第一个位置的索引，若不存在，则返回-1。 * @param {number[]} numbers * @param {number} k * @return {number}

* 统计一个数字在排序数组中的第一个位置的索引，若不存在，则返回-1。 * @param {number[]} numbers * @param {number} k * @return {number}

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

* 统计一个数字在排序数组中的最后一个位置，若不存在则返回-1。 * @param {number[]} numbers * @param {number} k * @return {number}

* 统计一个数字在排序数组中的最后一个位置，若不存在则返回-1。 * @param {number[]} numbers * @param {number} k * @return {number}

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

* 找到相同的根结点后 开始遍历查看两个树结构是否相同。 * @param {TreeNode} tree1 * @param {TreeNode} tree2 * @return {boolean}

* 找到相同的根结点后 开始遍历查看两个树结构是否相同。 * @param {TreeNode} tree1 * @param {TreeNode} tree2 * @return {boolean}

* 传入一个数组，对这个数组寻找最大连续增大序列的长度。 * @param {number[]} height * @return {number}

* 传入一个数组，对这个数组寻找最大连续增大序列的长度。 * @param {number[]} height * @return {number}

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

* 合并 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}