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

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

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

* 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘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 反转结束位置

* 反转链表 * * @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

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

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

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

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

* 给定一个包含 n 个整数的数组 arr 和一个目标值 target， * 判断 arr 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。 * @param {number[]} arr * @par

* 给定一个包含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}

* 泰波那契数列 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[][]} M * @param {boolean[]} visited * @param {number} i

* 深度遍历，将一个同学的所有朋友圈遍历为已访问 * @param {number[][]} M * @param {boolean[]} visited * @param {number} i

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

* 在指定位置插入节点 * * @param {any} value * @param {number} index

* 处理剩余的字符并递归转化字符串。 * @param {string} remain * @param {string[]} temp * @param {string[]} result

* 处理剩余的字符并递归转化字符串。 * @param {string} remain * @param {string[]} temp * @param {string[]} result

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

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

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

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

* 给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。 * 请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。 * @param

* 买卖股票的最佳时机II 可以买多次 * @param {number[]} prices * @return {number}

* 买卖股票的最佳时机 含手续费 * @param {number[]} prices * @param {number} fee

* 在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。 * @param {string[][]} matrix * @return {number}

* 在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。 * @param {string[][]} matrix * @return {number}

* 归并操作 * @param {number[]} front * @param {number[]} end

* 归并操作 * @param {number[]} front * @param {number[]} end

* 给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。 * @param {number[][]} triangle * @return {number}

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

* 在已经实现加法的情况下，乘法直接为我们被乘数 加上乘数倍的自己即可，但要考虑负数的情况。 * 我们可以先通过计算绝对值的乘数结果，之后根据符号位结果确定最终符号即可。 * @param {number} num1 * @param {number} num2 * @return {num

* 沿着顺时针方向打印一圈。 * @param {number[][]} arr * @param {number} start * @param {number} columns * @param {number} rows * @param {number[]} result

* 沿着顺时针方向打印一圈。 * @param {number[][]} arr * @param {number} start * @param {number} columns * @param {number} rows * @param {number[]} result

* 输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。 * 要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。 * @param {number} num * @return {string}

* 对链表进行排序。 * @param {ListNode} head * @return {ListNode}

* @return {T}

* 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 * @param {number[]} height * @return {number}

* 给定一个二叉树，返回其节点值的锯齿形层次遍历。 *（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 * @param {TreeNode} root * @return {number[][]}

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

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

* 冒泡排序，使用循环数组的方法，比较当前元素和下一个元素，如果当前元素大，向上冒泡 * 同时确定下次遍历的终点，避免不需要的的遍历 * * @param {number[]} array * @return {number[]}

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

* 假设你正在爬楼梯。需要 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 {number[]} children 孩子们的胃口值 * @param {number[]} biscuits 饼干的大小

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

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

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

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