倪春恩的博客
开始阅读 Github
lc-101
//Given the root of a binary tree, check whether it is a mirror of itself (i.e., // symmetric around its center). // //
阅读更多
lc-102
Given the root of a binary tree, return the level order traversal of its nodes’ values. (i.e., from left to right, level
阅读更多
How to setup debugging environment for Kylin5 locally
1. Check Software Requirement Software Comment Version Download Link Git Fetch branch name and hash of latest commi
阅读更多
lc-104
Given the root of a binary tree, return its maximum depth. A binary tree’s maximum depth is the number of nodes along th
阅读更多
lc-124
/** A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connec
阅读更多
lc-121
/** You are given an array prices where prices[i] is the price of a given stock on the iᵗʰ day. You want to maximize
阅读更多
lc-128
/** Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence. You mu
阅读更多
lc-114
/** Given the root of a binary tree, flatten the tree into a "linked list": The "linked list" should use the same T
阅读更多
lc-105
/** Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder
阅读更多
lc-139
/** Given a string s and a dictionary of strings wordDict, return true if s can be segmented into a space-separated sequ
阅读更多
lc-140
/** Given a string s and a dictionary of strings wordDict, add spaces in s to construct a sentence where each word is a
阅读更多
lc-136
/** Given a non-empty array of integers nums, every element appears twice except for one. Find that single one. You
阅读更多
lc-146
/** Design a data structure that follows the constraints of a Least Recently Used ( LRU) cache. Implement the LRUCache
阅读更多
lc-141
/** Given head, the head of a linked list, determine if the linked list has a cycle in it. There is a cycle in a lin
阅读更多
lc-142
/** Given the head of a linked list, return the node where the cycle begins. If there is no cycle, return null. Ther
阅读更多
lc-149
/** * Given an array of points where points[i] = [xi, yi] represents a point on the X- * Y plane, return the maximum n
阅读更多
lc-155
/** Design a stack that supports push, pop, top, and retrieving the minimum element in constant time. Implement the
阅读更多
lc-148
/** Given the head of a linked list, return the list after sorting it in ascending order. Example 1: Input: he
阅读更多
lc-152
/** Given an integer array nums, find a contiguous non-empty subarray within the array that has the largest product, an
阅读更多
lc-169
/** Given an array nums of size n, return the majority element. The majority element is the element that appears more
阅读更多
lc-198
/** You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stash
阅读更多
lc-200
/** Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0 's (water), return the number of isl
阅读更多
lc-202
/** Write an algorithm to determine if a number n is happy. A happy number is a number defined by the following proce
阅读更多
lc-204
/** Given an integer n, return the number of prime numbers that are strictly less than n. Example 1: Input: n
阅读更多
lc-206
/** Given the head of a singly linked list, reverse the list, and return the reversed list. Example 1: Input:
阅读更多
lc-207
/** * There are a total of numCourses courses you have to take, labeled from 0 to * numCourses - 1. You are given an a
阅读更多
lc-208
/** A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in
阅读更多
lc-160
/** Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. If th
阅读更多
lc-217
/** Given an integer array nums, return true if any value appears at least twice in the array, and return false if ever
阅读更多
lc-221
/** Given an m x n binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its are
阅读更多
lc-226
/** Given the root of a binary tree, invert the tree, and return its root. Example 1: Input: root = [4,2,7,1,3,
阅读更多
lc-234
/** Given the head of a singly linked list, return true if it is a palindrome or false otherwise. Example 1: I
阅读更多
lc-236
/** Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the defi
阅读更多
lc-238
/** Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements
阅读更多
lc-239
import java.util.Comparator; import java.util.PriorityQueue; /** You are given an array of integers nums, there is a sl
阅读更多
lc-240
/** * Write an efficient algorithm that searches for a value target in an m x n * integer matrix matrix. This matrix h
阅读更多
lc-279
/** Given an integer n, return the least number of perfect square numbers that sum to n. A perfect square is an inte
阅读更多
lc-283
/** Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero ele
阅读更多
lc-215
/** Given an integer array nums and an integer k, return the kᵗʰ largest element in the array. Note that it is the k
阅读更多
lc-287
/** Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive. T
阅读更多
lc-297
/** * Serialization is the process of converting a data structure or object into a * sequence of bits so that it can b
阅读更多
lc-301
/** Given a string s that contains parentheses and letters, remove the minimum number of invalid parentheses to make th
阅读更多
lc-38
//The count-and-say sequence is a sequence of digit strings defined by the recur //sive formula: // // // countAndSay(
阅读更多
lc-416
/** Given a non-empty array nums containing only positive integers, find if the array can be partitioned into two subse
阅读更多
lc-44
//Given an input string (s) and a pattern (p), implement wildcard pattern matchi //ng with support for '?' and '*' where
阅读更多
lc-448
/** Given an array nums of n integers where nums[i] is in the range [1, n], return an array of all the integers in the
阅读更多
lc-46
//Given an array nums of distinct integers, return all the possible permutations //. You can return the answer in any or
阅读更多
lc-48
//You are given an n x n 2D matrix representing an image, rotate the image by 90 // degrees (clockwise). // // You have
阅读更多
lc-49
//Given an array of strings strs, group the anagrams together. You can return th //e answer in any order. // // An Anag
阅读更多
lc-53
//Given an integer array nums, find the contiguous subarray (containing at least // one number) which has the largest su
阅读更多
lc-538
/** Given the root of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST
阅读更多
lc-50
//Implement pow(x, n), which calculates x raised to the power n (i.e., xn). // // // Example 1: // // //Input: x = 2
阅读更多
lc-54
//Given an m x n matrix, return all elements of the matrix in spiral order. // // // Example 1: // // //Input: matrix =
阅读更多
lc-42
//Given n non-negative integers representing an elevation map where the width of // each bar is 1, compute how much wate
阅读更多
lc-55
//You are given an integer array nums. You are initially positioned at the array //'s first index, and each element in t
阅读更多
lc-543
/** Given the root of a binary tree, return the length of the diameter of the tree. The diameter of a binary tree is
阅读更多
lc-56
//Given an array of intervals where intervals[i] = [starti, endi], merge all ove //rlapping intervals, and return an arr
阅读更多
lc-62
//There is a robot on an m x n grid. The robot is initially located at the top-l //eft corner (i.e., grid[0][0]). The ro
阅读更多
lc-617
/** You are given two binary trees root1 and root2. Imagine that when you put one of them to cover the other, some no
阅读更多
lc-560
/** Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k. A
阅读更多
lc-581
/** Given an integer array nums, you need to find one continuous subarray that if you only sort this subarray in ascendi
阅读更多
lc-621
/** Given a characters array tasks, representing the tasks a CPU needs to do, where each letter represents a different t
阅读更多
lc-70
//You are climbing a staircase. It takes n steps to reach the top. // // Each time you can either climb 1 or 2 steps. I
阅读更多
lc-73
//Given an m x n integer matrix matrix, if an element is 0, set its entire row a //nd column to 0's. // // You must do
阅读更多
lc-69
//Given a non-negative integer x, compute and return the square root of x. // // Since the return type is an integer, t
阅读更多
lc-739
/** Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[
阅读更多
lc-647
/** Given a string s, return the number of palindromic substrings in it. A string is a palindrome when it reads the s
阅读更多
lc-76
//Given two strings s and t of lengths m and n respectively, return the minimum //window substring of s such that every
阅读更多
lc-79
//Given an m x n grid of characters board and a string word, return true if word // exists in the grid. // // The word
阅读更多
lc-75
//Given an array nums with n objects colored red, white, or blue, sort them in-p //lace so that objects of the same colo
阅读更多
lc-84
//Given an array of integers heights representing the histogram's bar height whe //re the width of each bar is 1, return
阅读更多
lc-66
//You are given a large integer represented as an integer array digits, where ea //ch digits[i] is the ith digit of the
阅读更多
lc-88
//You are given two integer arrays nums1 and nums2, sorted in non-decreasing ord //er, and two integers m and n, represe
阅读更多
lc-78
//Given an integer array nums of unique elements, return all possible subsets (t //he power set). // // The solution se
阅读更多
lc-91
//A message containing letters from A-Z can be encoded into numbers using the fo //llowing mapping: // // //'A' ->
阅读更多
lc-94
//Given the root of a binary tree, return the inorder traversal of its nodes' va //lues. // // // Example 1: // // /
阅读更多
lc-98
//Given the root of a binary tree, determine if it is a valid binary search tree // (BST). // // A valid BST is defined
阅读更多
offer-06
/** 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制： 0 <= 链表长度 <= 10000
阅读更多
offer-04
/** 在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。请完成一个高效的函数，输入这样的一个二维数 组和一个整数，判断数组中是否含有该整数。 示例: 现
阅读更多
offer-03
/** 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出 数组中任意一个重复的数字。 示例
阅读更多
offer-05
/** 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。 示例 1： 输入：s = "We are happy." 输出："We%20are%20happy." 限制： 0 <= s 的
阅读更多
offer-07
/** 输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 示例 1: Input: preorder = [3,9,20,15,7], inord
阅读更多
offer-09
/** 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能 。(若队列中没有元素，deleteHead 操作返回 -1 )
阅读更多
offer-11
/** 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4
阅读更多
offer-10-1
/** 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N
阅读更多
offer-10-2
/** 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。 示例 1：
阅读更多
offer-14
给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例
阅读更多
offer-12
/** 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是
阅读更多
offer-16
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。 示例 1： 输入：x = 2.00000, n = 10 输出：1024.00000 示例 2： 输入：x = 2.10000
阅读更多
offer-17
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。 示例 1: 输入: n = 1 输出: [1,2,3,4,5,6,7,8,9] 说明： 用返回一个整数
阅读更多
offer-18
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中
阅读更多
offer-19
请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*a
阅读更多
offer-22
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4
阅读更多
offer-21
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。 示例： 输入：nums = [1,2,3,4] 输出：[1,3,2,4] 注：[3,1,2,4] 也是正确的答案之一。
阅读更多
offer-25
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 限制： 0 <
阅读更多
offer-27
请完成一个函数，输入一个二叉树，该函数输出它的镜像。 例如输入： 4 / \ 2 7 / \ / \ 1 3 6 9镜像输出： 4 / \ 7 2 / \ / \ 9
阅读更多
offer-20
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。 数值（按顺序）可以分成以下几个部分： 若干空格 一个 小数 或者 整数 （可选）一个 'e' 或 'E' ，后面跟着一个 整数 若干空格 小数（按顺序）可以分成以下几个部分：
阅读更多
offer-28
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3但是下面
阅读更多
offer-26
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构， 即 A中有出现和B相同的结构和节点值。 例如:给定的树 A: 3 / \ 4 5 / \ 1 2给定的
阅读更多
offer-30
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。 示例: MinStack minStack = new MinStack(); minSt
阅读更多
offer-24
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
阅读更多
offer-32-2
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。 例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [
阅读更多
offer-29
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 示例 1： 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5] 示例 2： 输入：matrix = [[
阅读更多
offer-33
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。 参考以下这颗二叉搜索树： 5 / \ 2 6 / \ 1 3
阅读更多
offer-34
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。 叶子节点 是指没有子节点的节点。 示例 1： 输入：root = [5,4,8,11,null,13,4,
阅读更多
offer-35
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。 示例 1： 输入：head = [[7,nul
阅读更多
offer-36
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。 为了让您更好地理解问题，以下面的二叉搜索树为例： 我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个
阅读更多
offer-37
请实现两个函数，分别用来序列化和反序列化二叉树。 你需要设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 提示：
阅读更多
offer-39
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 示例 1: 输入: [1, 2, 3, 2, 2, 2, 5, 4, 2] 输出: 2 限制： 1 <=
阅读更多
offer-40
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 示例 1： 输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例
阅读更多
offer-41
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。 例如， [2,3,4] 的中位数是 3 [2,3]
阅读更多
offer-42
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。 示例1: 输入: nums = [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,
阅读更多
offer-32-3
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \
阅读更多
offer-32
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回： [3,9,20,15,7]
阅读更多
offer-43
输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。 例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。 示例 1： 输入：n = 12 输出：5 示例 2： 输入：n = 13 输出
阅读更多
offer-31
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,
阅读更多
offer-44
数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。 请写一个函数，求任意第n位对应的数字。 示例 1： 输入：n = 3 输出：
阅读更多
offer-46
给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。 示例 1
阅读更多
offer-47
在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼
阅读更多
offer-48
请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。 示例 1: 输入: "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。 示例 2: 输入: "bbbbb"
阅读更多
offer-49
我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。 示例: 输入: n = 10 输出: 12 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10
阅读更多
offer-50
在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。 示例 1: 输入：s = "abaccdeff" 输出：'b' 示例 2: 输入：s = "" 输出：' ' 限制： 0 <= s
阅读更多
offer-51
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。 示例 1: 输入: [7,5,6,4] 输出: 5 限制： 0 <= 数组长度 <= 50000
阅读更多
offer-53
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。 示例 1: 输入: [0,1,3] 输出: 2 示例 2: 输入: [
阅读更多
offer-54
给定一棵二叉搜索树，请找出其中第 k 大的节点的值。 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / \ 1 4 \ 2 输出: 4 示例 2: 输入: root = [5,
阅读更多
offer-55-1
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 例如： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 /
阅读更多
offer-55-2
输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 /
阅读更多
offer-56-1
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 示例 1： 输入：nums = [4,1,4,6] 输出：[1,6] 或 [6,1] 示
阅读更多
offer-56-2
在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。 示例 1： 输入：nums = [3,4,3,3] 输出：4 示例 2： 输入：nums = [9,1,7,9,7,9,7] 输出：1
阅读更多
offer-57
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2]
阅读更多
offer-57-2
输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。 序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。 示例 1： 输入：target = 9 输出：[[2,3,4],[4,5]]
阅读更多
offer-58-1
输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串”I am a student. “，则输出”student. a am I”。 示例 1： 输入: "the sky i
阅读更多
offer-58-2
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串”abcdefg”和数字2，该函数将返回左旋转两位得到的结果”cdefgab”。 示例 1： 输入: s = "abc
阅读更多
offer-59-1
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。 示例: 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3 输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置
阅读更多
offer-60
把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。 你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。 示例 1: 输入: 1 输出:
阅读更多
offer-62
0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。 例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则
阅读更多
offer-63
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的
阅读更多
offer-64
求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 示例 1： 输入: n = 3 输出: 6 示例 2： 输入: n = 9 输出: 45
阅读更多
offer-65
写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。 示例: 输入: a = 1, b = 1 输出: 2 提示： a, b 均可能是负数或 0 结果不会溢出 32 位整数 预备知识
阅读更多
offer-66
给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用
阅读更多
offer-68-1
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的
阅读更多
offer-68-2
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先
阅读更多
offer2-1
给定两个整数 a 和 b ，求它们的除法的商 a/b ，要求不得使用乘号 '*'、除号 '/' 以及求余符号 '%' 。 注意： 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 t
阅读更多
offer2-2
给定两个 01 字符串 a 和 b ，请计算它们的和，并以二进制字符串的形式输出。 输入为 非空 字符串且只包含数字 1 和 0。 示例 1: 输入: a = "11", b = "10" 输出: "101" 示例 2: 输入: a =
阅读更多
offer2-3
给定一个非负整数 n ，请计算 0 到 n 之间的每个数字的二进制表示中 1 的个数，并输出一个数组。 示例 1: 输入: n = 2 输出: [0,1,1] 解释: 0 --> 0 1 --> 1 2 --> 10
阅读更多
offer2-4
给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。 示例 1： 输入：nums = [2,2,3,2] 输出：3 示例 2： 输入：nums = [0,1,0,1
阅读更多
offer2-5
给定一个字符串数组 words，请计算当两个字符串 words[i] 和 words[j] 不包含相同字符时，它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串，返回 0。 示例 1: 输入: wo
阅读更多
offer2-6
给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。 函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 0 开始计数 ，所以答案数组应当
阅读更多
offer2-7
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。
阅读更多
offer2-8
给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件
阅读更多
offer2-9
给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。 示例 1: 输入: nums = [10,5,2,6], k = 100 输出: 8 解释: 8 个乘积小于 100 的子数组分别为: [10],
阅读更多
offer2-10
给定一个整数数组和一个整数 k ，请找到该数组中和为 k 的连续子数组的个数。 示例 1： 输入:nums = [1,1,1], k = 2 输出: 2 解释: 此题 [1,1] 与 [1,1] 为两种不同的情况 示例 2： 输入:num
阅读更多
offer2-11
给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。 示例 1： 输入: nums = [0,1] 输出: 2 说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。 示
阅读更多
offer2-12
给你一个整数数组 nums ，请计算数组的 中心下标 。 数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。 如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下
阅读更多
offer2-13
给定一个二维矩阵 matrix，以下类型的多个请求： 计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。 实现 NumMatrix 类： NumMatrix(int[]
阅读更多
offer2-15
给定两个字符串 s 和 p，找到 s 中所有 p 的 变位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。 变位词 指字母相同，但排列不同的字符串。 示例 1： 输入: s = "cbaebabacd", p = "abc" 输出
阅读更多
【转载】设计模式：观察者模式-以微信公众服务为例
观察者模式定义定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。 好了，对于定义的理解总是需要实例来解析的，如今的微信服务号相当火啊，下面就以微信服务号为背景，给大家介绍观察者模式。 看一张图
阅读更多
offer2-16
给定一个字符串 s ，请你找出其中不含有重复字符的 最长连续子字符串 的长度。 示例 1: 输入: s = "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子字符串是 "abc"，所以其长度为 3。 示例 2: 输入: s
阅读更多
【转载】设计模式：工厂模式-从卖肉夹馍说起
今天继续设计模式之旅，给大家带来工厂模式，简单列一下这个模式的家族： 1、静态工厂模式 2、简单工厂模式 3、工厂方法模式 4、抽象工厂模式 是不是觉得，我勒个去，这工厂还能列出这么多分类，哈哈，下面开始各个击破。 1、静态工厂模式 这个最
阅读更多
offer2-17
给定两个字符串 s 和 t 。返回 s 中包含 t 的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 "" 。 如果 s 中存在多个符合条件的子字符串，返回任意一个。 注意： 对于 t 中重复字符，我们寻找的子
阅读更多
【转载】设计模式：单例设计模式(Singleton Pattern)完全解析
什么会有单例设计模式？ 我们都知道单例模式是在开发中用的最多的一种设计模式，那么究竟为什么会有单例设计模式呢？对于这个问题相信有很多会写单例的人都会有个这个疑问。在这里先说一下单例的用途，然后举一个例子大家就会明白为什么会有单例了。单例模式
阅读更多
offer2-18
给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。 本题中，将空字符串定义为有效的 回文串 。 示例 1: 输入: s = "A man, a plan, a canal: Panama" 输出:
阅读更多
offer2-19
给定一个非空字符串 s，请判断如果 最多 从字符串中删除一个字符能否得到一个回文字符串。 示例 1: 输入: s = "aba" 输出: true 示例 2: 输入: s = "abca" 输出: true 解释: 可以删除 "c" 字符
阅读更多
【转载】设计模式：策略模式-以角色游戏为背景
先来看看策略模式的定义： 策略模式（Strategy Pattern）：定义了算法族，分别封装起来，让它们之间可相互替换，此模式让算法的变化独立于使用算法的客户。 好了，对于定义，肯定不是一眼就能看明白的，不然这篇文章就收尾了，对于定于大家
阅读更多
offer2-20
给定一个字符串 s ，请计算这个字符串中有多少个回文子字符串。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。 示例 1： 输入：s = "abc" 输出：3 解释：三个回文子串: "a", "b", "c
阅读更多
【转载】设计模式：适配器模式-以手机充电器为例
老样子，定义：将一个类的接口转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以相互合作。这个定义还好，说适配器的功能就是把一个接口转成另一个接口。 发现两张图片可以很好的解释适配器模式： 这两张图很好的说明了适配器的作用哈，话说
阅读更多
offer2-21
给定一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例
阅读更多
【转载】设计模式：命令模式-管理智能家电
定义：将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。 这尼玛定义，看得人蛋疼，看不明白要淡定，我稍微简化一下：将请求封装成对象，将动作请求者和动作执行者解耦。好了，直接用例子来说明。 需
阅读更多
offer2-22
给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0
阅读更多
【转载】设计模式：装饰者模式-带你重回传奇世界
装饰者模式：若要扩展功能，装饰者提供了比集成更有弹性的替代方案，动态地将责任附加到对象上。 先简单描述下装饰者模式发挥作用的地方，当我们设计好了一个类，我们需要给这个类添加一些辅助的功能，并且不希望改变这个类的代码，这时候就是装饰者模式大展
阅读更多
offer2-23
给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链
阅读更多
【转载】
这个模式比较简单，嘿嘿，简单写一下。 老样子，先看 外观模式（Facade Pattern）定义：提供一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层的接口，让子系统更容易使用。其实就是为了方便客户的使用，把一群操作，封装成一
阅读更多
offer2-24
给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3：
阅读更多
【转载】设计模式：模版方法模式-展现程序员的一天
老套路，先看下定义：定义了一个算法的骨架，而将一些步骤延迟到子类中，模版方法使得子类可以在不改变算法结构的情况下，重新定义算法的步骤。 简单看下定义，模版方法定义了一个算法的步骤，并且允许子类为一个或多个步骤提供实现。定义还算清晰，下面来个
阅读更多
offer2-25
给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 可以假设除了数字 0 之外，这两个数字都不会以零开头。 示例1： 输入：l1 = [7,2,
阅读更多
offer2-26
给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln-1 → Ln请将其重新排列后变为： L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … 不能只是单纯的改变节点内部的值，
阅读更多
【转载】设计模式：状态模式-以自动售货机为例
先看定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。定义又开始模糊了，理一下，当对象的内部状态改变时，它的行为跟随状态的改变而改变了，看起来好像重新初始化了一个类似的。 下面使用个例子来说明状态模式的用法，现在有个自
阅读更多
offer2-27
给定一个链表的 头节点 head ，请判断其是否为回文链表。 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 示例 1： 输入: head = [1,2,3,3,2,1] 输出: true 示例 2： 输入: h
阅读更多
【转载】设计模式：建造者模式(Builder Pattern)-以造汽车买汽车为例
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 类型：创建类模式 类图： 四个要素 产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的
阅读更多
offer2-28
多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。 给定位于列表第一级的头节点，请扁平化列表，即将这
阅读更多
【转载】设计模式：原型模式
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比
阅读更多
offer2-29
给定循环单调非递减列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选
阅读更多
offer2-30
设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构： insert(val)：当元素 val 不存在时返回 true ，并向集合中插入该项，否则返回 false 。 remove(val)：当元素 val 存在时返回 t
阅读更多
offer2-31
运用所掌握的数据结构，设计和实现一个 LRU (Least Recently Used，最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量 capacity 初始化
阅读更多
offer-13
地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为
阅读更多
offer-45
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。 示例 1: 输入: [10,2] 输出: "102" 示例 2: 输入: [3,30,34,5,9] 输出: "3033459" 提示:
阅读更多
offer-67
写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。 当我们寻找到的第一个非空字符为正或者负号时，则将该符
阅读更多
offer-59-2
请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。 若队列为空，pop_front 和 max_value 需要返回 -1
阅读更多
offer-61
从若干副扑克牌中随机抽 5 张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。 示例 1: 输入: [1,2,3,4,5]
阅读更多
【转载】设计模式：享元模式
享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。 享元模式尝试重用现有的同类对象，如果未找到匹配的对
阅读更多
offer2-32
给定两个字符串 s 和 t ，编写一个函数来判断它们是不是一组变位词（字母异位词）。 注意：若 *s* 和 *t* 中每个字符出现的次数都相同且字符顺序不完全相同，则称 *s* 和 *t* 互为变位词（字母异位词）。 示例 1: 输入: s
阅读更多
offer2-33
给定一个字符串数组 strs ，将 变位词 组合在一起。 可以按任意顺序返回结果列表。 注意：若两个字符串中每个字符出现的次数都相同，则称它们互为变位词。 示例 1: 输入: strs = ["eat", "tea", "tan", "at
阅读更多
【转载】设计模式：代理模式
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。 意图：为其他对象提供一种代理以控制对这个对象的访问。 主要解决：在
阅读更多
offer2-34
某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。 给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 tru
阅读更多
offer2-35
给定一个 24 小时制（小时:分钟 **”HH:MM”**）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。 示例 1： 输入：timePoints = ["23:59","00:00"] 输出：1 示例 2： 输入：tim
阅读更多
【转载】设计模式：桥接模式
桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。 这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类
阅读更多
offer2-36
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 输入：tok
阅读更多
【转载】设计模式：组合模式
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。 这种模式创建
阅读更多
offer2-37
给定一个整数数组 asteroids，表示在同一行的小行星。 对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。 找出碰撞后剩下的所有小行星。碰撞规则
阅读更多
【转载】设计模式：迭代器模式
迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。 迭代器模式属于行为型模式。 意图：提供一种方法顺序访问一个聚合对象中
阅读更多
offer2-38
请根据每日 气温 列表 temperatures ，重新生成一个列表，要求其对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。 示例 1: 输入: temperatures =
阅读更多
【转载】设计模式：中介者模式
中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。 意图：用一个中介对象来封装一系列的对象交
阅读更多
offer2-39
给定非负整数数组 heights ，数组中的数字用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。 求在该柱状图中，能够勾勒出来的矩形的最大面积。 示例 1: 输入：heights = [2,1,5,6,2,3] 输出：1
阅读更多
offer2-40
给定一个由 0 和 1 组成的矩阵 matrix ，找出只包含 1 的最大矩形，并返回其面积。 注意：此题 matrix 输入格式为一维 01 字符串数组。 示例 1： 输入：matrix = ["10100","10111","1111
阅读更多
offer2-41
给定一个整数数据流和一个窗口大小，根据该滑动窗口的大小，计算滑动窗口里所有数字的平均值。 实现 MovingAverage 类： MovingAverage(int size) 用窗口大小 size 初始化对象。 double next(
阅读更多
offer2-42
写一个 RecentCounter 类来计算特定时间范围内最近的请求。 请实现 RecentCounter 类： RecentCounter() 初始化计数器，请求数为 0 。 int ping(int t) 在时间 t 添加一个新请求，
阅读更多
offer2-43
完全二叉树是每一层（除最后一层外）都是完全填充（即，节点数达到最大，第 n 层有 2n-1 个节点）的，并且所有的节点都尽可能地集中在左侧。 设计一个用完全二叉树初始化的数据结构 CBTInserter，它支持以下几种操作： CBTIns
阅读更多
offer2-44
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。 示例1： 输入: root = [1,3,2,5,3,null,9] 输出: [1,3,9] 解释: 1 / \ 3
阅读更多
offer2-45
给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。 假设二叉树中至少有一个节点。 示例 1: 输入: root = [2,1,3] 输出: 1 示例 2: 输入: [1,2,3,4,null,5,6,nu
阅读更多
offer2-46
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例 1: 输入: [1,2,3,null,5,null,4] 输出: [1,3,4] 示例 2: 输入: [1,null,
阅读更多
offer2-47
给定一个二叉树 根节点 root ，树的每个节点的值要么是 0，要么是 1。请剪除该二叉树中所有节点的值为 0 的子树。 节点 node 的子树为 node 本身，以及所有 node 的后代。 示例 1: 输入: [1,null,0,0,1
阅读更多
offer2-48
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列
阅读更多
offer2-49
给定一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。 每条从根节点到叶节点的路径都代表一个数字： 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。 计算从根节点到叶
阅读更多
offer2-50
给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。 路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
阅读更多
offer2-51
路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。 路径和 是路径中各节点值的总和。 给定一个二叉树的根节点 root
阅读更多
offer2-52
给你一棵二叉搜索树，请 按中序遍历 将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。 示例 1： 输入：root = [5,3,6,2,4,null,8,1,null,nul
阅读更多
offer2-53
给定一棵二叉搜索树和其中的一个节点 p ，找到该节点在树中的中序后继。如果节点没有中序后继，请返回 null 。 节点 p 的后继是值比 p.val 大的节点中键值最小的节点，即按中序遍历的顺序节点 p 的下一个节点。 示例 1： 输入：
阅读更多
offer2-54
给定一个二叉搜索树，请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。 提醒一下，二叉搜索树满足下列约束条件： 节点的左子树仅包含键 小于 节点键的节点。 节点的右子树仅包含键 大于 节点键的节点。 左右子树也必须是二叉
阅读更多
offer2-55
实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器： BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构
阅读更多
offer2-56
给定一个二叉搜索树的 根节点 root 和一个整数 k , 请判断该二叉搜索树中是否存在两个节点它们的值之和等于 k 。假设二叉搜索树中节点的值均唯一。 示例 1： 输入: root = [8,6,10,5,7,9,11], k = 12
阅读更多
offer2-57
给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。 如果存在则返回 t
阅读更多
offer2-58
请实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排，则可以存储这个新的日程安排。 MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时
阅读更多
offer2-59
设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。 请实现 KthLargest 类： KthLargest(int k, int[] nums) 使用整数 k 和整数流 num
阅读更多
offer2-60
给定一个整数数组 nums 和一个整数 k ，请返回其中出现频率前 k 高的元素。可以按 任意顺序 返回答案。 示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2] 示例 2: 输入: nums
阅读更多
offer2-61
给定两个以升序排列的整数数组 nums1 和 nums2 , 以及一个整数 k 。 定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。 请找到和最小的 k 个数对 (u1,v1), (u2,v2) …
阅读更多
offer2-62
**Trie**（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie() 初始化前缀树对象。 vo
阅读更多
offer2-63
在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。 现在，给
阅读更多
offer2-64
设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。 实现 MagicDictionary 类： Magi
阅读更多
offer2-65
单词数组 words 的 有效编码 由任意助记字符串 s 和下标数组 indices 组成，且满足： words.length == indices.length 助记字符串 s 以 '#' 字符结尾 对于每个下标 indices[i]
阅读更多
【转载】设计模式：备忘录模式
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。 意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 主要解决：所谓备忘录模式就是在不破
阅读更多
offer2-66
实现一个 MapSum 类，支持两个方法，insert 和 sum： MapSum() 初始化 MapSum 对象 void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整
阅读更多
offer2-67
给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。 示例 1： 输入：nums = [3,10,5,25,2,8] 输出：28 解释：最大运算结果是 5 X
阅读更多
offer2-68
给定一个排序的整数数组 nums 和一个整数目标值 target ，请在数组中找到 target ，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。 示例 1: 输入
阅读更多
offer2-69
符合下列属性的数组 arr 称为 山峰数组（山脉数组） ： arr.length >= 3存在 i（0 < i < arr.length - 1）使得：arr[0] < arr[1] < … arr[i-1]
阅读更多
offer2-70
给定一个只包含整数的有序数组 nums ，每个元素都会出现两次，唯有一个数只会出现一次，请找出这个唯一的数字。 你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。 示例 1: 输入: nums = [1,1,2
阅读更多
offer2-71
给定一个正整数数组 w ，其中 w[i] 代表下标 i 的权重（下标从 0 开始），请写一个函数 pickIndex ，它可以随机地获取下标 i，选取下标 i 的概率与 w[i] 成正比。 例如，对于 w = [1, 3]，挑选下标 0 的
阅读更多
【转载】设计模式：解释器模式
解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。 意图：给定一个语言，定义它的
阅读更多
offer2-72
给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。 正数的平方根有两个，只输出其中的正数平方根。 如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。 示例 1: 输入: x = 4 输
阅读更多
offer2-73
狒狒喜欢吃香蕉。这里有 n 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 h 小时后回来。 狒狒可以决定她吃香蕉的速度 k （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 k 根。如果这堆香蕉少于 k
阅读更多
offer2-74
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。 示例 1： 输入：int
阅读更多
【转载】设计模式：访问者模式
在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就
阅读更多
offer2-75
给定两个数组，arr1 和 arr2， arr2 中的元素各不相同 arr2 中的每个元素都出现在 arr1 中 对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素
阅读更多
offer2-76
给定整数数组 nums 和整数 k，请返回数组中第 **k** 个最大的元素。 请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。 示例 1: 输入: [3,2,1,5,6,4] 和 k = 2 输出: 5
阅读更多
汽车保养项目、周期、价格
保养周期 保养项目 大致价格 5000-10000公里|半年 换机油、机滤 500 10000-20000公里 换空调滤清、空气滤清 100-200 20000-30000公里 清洗节气门喷油嘴 100 30000-
阅读更多
offer2-77
给定链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 示例 1： 输入：head = [4,2,1,3] 输出：[1,2,3,4] 示例 2： 输入：head = [-1,5,3,4,0] 输出：[-1,0,3,
阅读更多
offer2-78
给定一个链表数组，每个链表都已经按升序排列。 请将所有链表合并到一个升序链表中，返回合并后的链表。 示例 1： 输入：lists = [[1,4,5],[1,3,4],[2,6]] 输出：[1,1,2,3,4,4,5,6] 解释：链表数组如
阅读更多
offer2-79
给定一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1： 输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2]
阅读更多
offer2-80
给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。 示例 1: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4
阅读更多
offer2-81
给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。 candidates 中的数字可以无限制重复被选取。如果至少一个所选数字
阅读更多
offer2-82
给定一个可能有重复数字的整数数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次，解集不能包含重复的组
阅读更多
【转载】设计模式：责任链模式
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在这种模式中，通常每个接收者都
阅读更多
offer2-83
给定一个不含重复数字的整数数组 nums ，返回其 所有可能的全排列 。可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[
阅读更多
offer2-84
给定一个可包含重复数字的整数集合 nums ，按任意顺序 返回它所有不重复的全排列。 示例 1： 输入：nums = [1,1,2] 输出： [[1,1,2], [1,2,1], [2,1,1]] 示例 2： 输入：nums = [1
阅读更多
offer2-85
正整数 n 代表生成括号的对数，请设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。 示例 1： 输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()()"] 示例 2：
阅读更多
offer2-86
给定一个字符串 s ，请将 s 分割成一些子串，使每个子串都是 回文串 ，返回 s 所有可能的分割方案。 回文串 是正着读和反着读都一样的字符串。 示例 1： 输入：s = "google" 输出：[["g","o","o","g","l"
阅读更多
offer2-87
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。 有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间
阅读更多
offer2-88
数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。 每当爬上一个阶梯都要花费对应的体力值，一旦支付了相应的体力值，就可以选择向上爬一个阶梯或者爬两个阶梯。 请找出达到楼层顶部的最低花
阅读更多
offer2-89
一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响小偷偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组 nums ，
阅读更多
offer2-90
一个专业的小偷，计划偷窃一个环形街道上沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会
阅读更多
offer2-91
假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。 当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷
阅读更多
offer2-92
如果一个由 '0' 和 '1' 组成的字符串，是以一些 '0'（可能没有 '0'）后面跟着一些 '1'（也可能没有 '1'）的形式组成的，那么该字符串是 单调递增 的。 我们给出一个由字符 '0' 和 '1' 组成的字符串 s，我们可以将任
阅读更多
offer2-93
如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的： n >= 3 对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2} 给定一个严格递增的正整数数组形成序
阅读更多
offer2-94
给定一个字符串 s，请将 s 分割成一些子串，使每个子串都是回文串。 返回符合要求的 最少分割次数 。 示例 1： 输入：s = "aab" 输出：1 解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。 示例
阅读更多
sql-1
表: Person +-------------+---------+ | 列名 | 类型 | +-------------+---------+ | PersonId | int | | FirstN
阅读更多
offer2-95
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不
阅读更多
offer2-96
给定三个字符串 s1、s2、s3，请判断 s3 能不能由 s1 和 s2 交织（交错） 组成。 两个字符串 s 和 t 交织 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串： s = s1 + s2 + ... + sn
阅读更多
offer2-97
给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。 字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而
阅读更多
offer2-98
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ 示例 1： 输
阅读更多
offer2-99
给定一个包含非负整数的 *m* x *n* 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：一个机器人每次只能向下或者向右移动一步。 示例 1： 输入：grid = [[1,3,1],[1,5,1]
阅读更多
offer2-100
给定一个三角形 triangle ，找出自顶向下的最小路径和。 每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i
阅读更多
offer2-101
给定一个非空的正整数数组 nums ，请判断能否将这些数字分成元素和相等的两部分。 示例 1： 输入：nums = [1,5,11,5] 输出：true 解释：nums 可以分割成 [1, 5, 5] 和 [11] 。 示例 2： 输入：
阅读更多
offer2-102
给定一个正整数数组 nums 和一个整数 target 。 向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ： 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加
阅读更多
offer2-103
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 你可以认为每种硬币的数量是无限的。 示例 1： 输入：coins = [1
阅读更多
offer2-104
给定一个由 不同 正整数组成的数组 nums ，和一个目标整数 target 。请从 nums 中找出并返回总和为 target 的元素组合的个数。数组中的数字可以在一次排列中出现任意次，但是顺序不同的序列被视作不同的组合。 题目数据保证答
阅读更多
gold-1-1
实现一个算法，确定一个字符串 s 的所有字符是否全都不同。 示例 1： 输入: s = "leetcode" 输出: false 示例 2： 输入: s = "abc" 输出: true 限制： 0 <= len(s) <
阅读更多
gold-1-2
给定两个由小写字母组成的字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。 示例 1： 输入: s1 = "abc", s2 = "bca" 输出: true 示例 2： 输入: s1 =
阅读更多
gold-1-3
URL化。编写一种方法，将字符串中的空格全部替换为%20。假定该字符串尾部有足够的空间存放新增字符，并且知道字符串的“真实”长度。（注：用Java实现的话，请使用字符数组实现，以便直接在数组上操作。） 示例 1： 输入："Mr John S
阅读更多
gold-1-4
给定一个字符串，编写一个函数判定其是否为某个回文串的排列之一。 回文串是指正反两个方向都一样的单词或短语。排列是指字母的重新排列。 回文串不一定是字典当中的单词。 示例1： 输入："tactcoa" 输出：true（排列有"tacocat"
阅读更多
gold-1-5
字符串有三种编辑操作:插入一个英文字符、删除一个英文字符或者替换一个英文字符。 给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。 示例 1: 输入: first = "pale" second = "ple" 输出:
阅读更多
gold-1-6
字符串压缩。利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3。若“压缩”后的字符串没有变短，则返回原先的字符串。你可以假设字符串中只包含大小写英文字母（a至z）。 示例
阅读更多
gold-1-7
给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。 不占用额外内存空间能否做到？ 示例 1: 给定 matrix = [ [1,2,3], [4,5,6], [7,
阅读更多
gold-1-8
编写一种算法，若M × N矩阵中某个元素为0，则将其所在的行与列清零。 示例 1： 输入： [ [1,1,1], [1,0,1], [1,1,1] ] 输出： [ [1,0,1], [0,0,0], [1,0,1]
阅读更多
gold-1-9
字符串轮转。给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成（比如，waterbottle是erbottlewat旋转后的字符串）。 示例1: 输入：s1 = "waterbottle", s2 = "erbottlewat"
阅读更多
gold-2-1
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。 示例1: 输入：[1, 2, 3, 3, 2, 1] 输出：[1, 2, 3] 示例2: 输入：[1, 1, 1, 1, 2] 输出：[1, 2] 提示： 链表长度在[0,
阅读更多
gold-2-2
实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。 注意：本题相对原题稍作改动 示例： 输入： 1->2->3->4->5 和 k = 2 输出： 4 说明： 给定的 k 保证是有效的。 //lee
阅读更多
gold-2-3
若链表中的某个节点，既不是链表头节点，也不是链表尾节点，则称其为该链表的「中间节点」。 假定已知链表的某一个中间节点，请实现一种算法，将该节点从链表中删除。 例如，传入节点 c（位于单向链表 a->b->c->d->
阅读更多
gold-2-4
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你不需要 保留 每个分区中各节点的初始相对位置。 示例 1： 输入：head = [1,4,3,2,
阅读更多
gold-2-5
给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果。 示例： 输入：(7 -> 1 -> 6) + (5 -> 9 ->
阅读更多
gold-2-6
编写一个函数，检查输入的链表是否是回文的。 示例 1： 输入： 1->2 输出： false 示例 2： 输入： 1->2->2->1 输出： true 进阶：你能否用 O(n) 时间复杂度和 O(1) 空间
阅读更多
gold-2-7
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，
阅读更多
gold-2-8
给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。若环不存在，请返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接
阅读更多
gold-3-1
三合一。描述如何只用一个数组来实现三个栈。 你应该实现push(stackNum, value)、pop(stackNum)、isEmpty(stackNum)、peek(stackNum)方法。stackNum表示栈下标，value表示压
阅读更多
gold-3-2
请设计一个栈，除了常规栈支持的pop与push函数以外，还支持min函数，该函数返回栈元素中的最小值。执行push、pop和min操作的时间复杂度必须为O(1)。 示例： MinStack minStack = new MinStack()
阅读更多
gold-3-3
堆盘子。设想有一堆盘子，堆太高可能会倒下来。因此，在现实生活中，盘子堆到一定高度时，我们就会另外堆一堆盘子。请实现数据结构SetOfStacks，模拟这种行为。SetOfStacks应该由多个栈组成，并且在前一个栈填满时新建一个栈。此外，S
阅读更多
gold-3-4
实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 que
阅读更多
gold-3-5
栈排序。 编写程序，对栈进行排序使最小元素位于栈顶。最多只能使用一个其他的临时栈存放数据，但不得将元素复制到别的数据结构（如数组）中。该栈支持如下操作：push、pop、peek 和 isEmpty。当栈为空时，peek 返回 -1。 示例
阅读更多
gold-2-6
动物收容所。有家动物收容所只收容狗与猫，且严格遵守“先进先出”的原则。在收养该收容所的动物时，收养人只能收养所有动物中“最老”（由其进入收容所的时间长短而定）的动物，或者可以挑选猫或狗（同时必须收养此类动物中“最老”的）。换言之，收养人不能
阅读更多
gold-4-1
节点间通路。给定有向图，设计一个算法，找出两个节点之间是否存在一条路径。 示例1: 输入：n = 3, graph = [[0, 1], [0, 2], [1, 2], [1, 2]], start = 0, target = 2 输出：t
阅读更多
gold-4-2
给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树。 示例: 给定有序数组: [-10,-3,0,5,9], 一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉
阅读更多
gold-4-3
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。 示例： 输入：[1,2,3,4,5,null,7,8] 1
阅读更多
gold-4-4
实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 /
阅读更多
gold-4-5
实现一个函数，检查一棵二叉树是否为二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输出: f
阅读更多
gold-4-6
设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。 如果指定节点没有对应的“下一个”节点，则返回null。 示例 1: 输入: root = [2,1,3], p = 1 2 / \ 1 3 输出: 2
阅读更多
gold-4-8
设计并实现一个算法，找出二叉树中某两个节点的第一个共同祖先。不得将其他的节点存储在另外的数据结构中。注意：这不一定是二叉搜索树。 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 3
阅读更多
gold-4-9
从左向右遍历一个数组，通过不断将其中的元素插入树中可以逐步地生成一棵二叉搜索树。 给定一个由不同节点组成的二叉搜索树 root，输出所有可能生成此树的数组。 示例 1: 输入: root = [2,1,3] 输出: [[2,1,3],[2,
阅读更多
gold-4-10
检查子树。你有两棵非常大的二叉树：T1，有几万个节点；T2，有几万个节点。设计一个算法，判断 T2 是否为 T1 的子树。 如果 T1 有这么一个节点 n，其子树与 T2 一模一样，则 T2 为 T1 的子树，也就是说，从节点 n 处把树砍
阅读更多
gold-4-12
给定一棵二叉树，其中每个节点都含有一个整数数值(该值或正或负)。设计一个算法，打印节点数值总和等于某个给定值的所有路径的数量。注意，路径不一定非得从二叉树的根节点或叶节点开始或结束，但是其方向必须向下(只能从父节点指向子节点方向)。 示例:
阅读更多
gold-5-1
给定两个整型数字 N 与 M，以及表示比特位置的 i 与 j（i <= j，且从 0 位开始计算）。 编写一种方法，使 M 对应的二进制数字插入 N 对应的二进制数字的第 i ~ j 位区域，不足之处用 0 补齐。具体插入过程如图所示
阅读更多
gold-5-2
二进制数转字符串。给定一个介于0和1之间的实数（如0.72），类型为double，打印它的二进制表达式。如果该数字无法精确地用32位以内的二进制表示，则打印“ERROR”。 示例1: 输入：0.625 输出："0.101" 示例2: 输入
阅读更多
gold-5-3
给定一个32位整数 num，你可以将一个数位从0变为1。请编写一个程序，找出你能够获得的最长的一串1的长度。 示例 1： 输入: num = 1775(110111011112) 输出: 8 示例 2： 输入: num = 7(01112
阅读更多
gold-5-4
下一个数。给定一个正整数，找出与其二进制表达式中1的个数相同且大小最接近的那两个数（一个略大，一个略小）。 示例1: 输入：num = 2（或者0b10） 输出：[4, 1] 或者（[0b100, 0b1]） 示例2: 输入：num =
阅读更多
gold-5-6
整数转换。编写一个函数，确定需要改变几个位才能将整数A转成整数B。 示例1: 输入：A = 29 （或者0b11101）, B = 15（或者0b01111） 输出：2 示例2: 输入：A = 1，B = 2 输出：2 提示: A，B
阅读更多
gold-5-7
配对交换。编写程序，交换某个整数的奇数位和偶数位，尽量使用较少的指令（也就是说，位0与位1交换，位2与位3交换，以此类推）。 示例1: 输入：num = 2（或者0b10） 输出 1 (或者 0b01) 示例2: 输入：num = 3 输
阅读更多
gold-8-1
三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。 示例1: 输入：n = 3 输出：4 说明: 有四种走法 示例
阅读更多
gold-8-2
设想有个机器人坐在一个网格的左上角，网格 r 行 c 列。机器人只能向下或向右移动，但不能走到一些被禁止的网格（有障碍物）。设计一种算法，寻找机器人从左上角移动到右下角的路径。 网格中的障碍物和空位置分别用 1 和 0 来表示。 返回一条
阅读更多
gold-8-3
魔术索引。 在数组A[0...n-1]中，有所谓的魔术索引，满足条件A[i] = i。给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。若有多个魔术索引，返回索引值最小的一个。 示例
阅读更多
gold-8-4
幂集。编写一种方法，返回某集合的所有子集。集合中不包含重复的元素。 说明：解集不能包含重复的子集。 示例: 输入： nums = [1,2,3] 输出： [ [3], [1], [2], [1,2,3], [1,3]
阅读更多
gold-8-5
递归乘法。 写一个递归函数，不使用 * 运算符， 实现两个正整数的相乘。可以使用加号、减号、位移，但要吝啬一些。 示例1: 输入：A = 1, B = 10 输出：10 示例2: 输入：A = 3, B = 4 输出：12 提示: 保
阅读更多
gold-8-6
在经典汉诺塔问题中，有 3 根柱子及 N 个不同大小的穿孔圆盘，盘子可以滑入任意一根柱子。一开始，所有盘子自上而下按升序依次套在第一根柱子上(即每一个盘子只能放在更大的盘子上面)。移动圆盘时受到以下限制:(1) 每次只能移动一个盘子;(2)
阅读更多
gold-8-7
无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。 示例1: 输入：S = "qwe" 输出：["qwe", "qew", "wqe", "weq", "ewq", "eqw"] 示例2: 输入：S
阅读更多
gold-8-8
有重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合。 示例1: 输入：S = "qqe" 输出：["eqq","qeq","qqe"] 示例2: 输入：S = "ab" 输出：["ab", "ba"] 提示: 字符都是英
阅读更多
gold-8-9
括号。设计一种算法，打印n对括号的所有合法的（例如，开闭一一对应）组合。 说明：解集不能包含重复的子集。 例如，给出 n = 3，生成结果为： [ "((()))", "(()())", "(())()", "()(())"
阅读更多
gold-8-10
编写函数，实现许多图片编辑软件都支持的「颜色填充」功能。 待填充的图像用二维数组 image 表示，元素为初始颜色值。初始坐标点的行坐标为 sr 列坐标为 sc。需要填充的新颜色为 newColor 。 「周围区域」是指颜色相同且在上、下、
阅读更多
gold-8-11
硬币。给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算n分有几种表示法。(结果可能会很大，你需要将结果模上1000000007) 示例1: 输入: n = 5 输出：2 解释: 有两种方式可以凑成总金额: 5=5 5
阅读更多
gold-8-12
设计一种算法，打印 N 皇后在 N × N 棋盘上的各种摆法，其中每个皇后都不同行、不同列，也不在对角线上。这里的“对角线”指的是所有的对角线，不只是平分整个棋盘的那两条对角线。 注意：本题相对原题做了扩展 示例: 输入：4 输出：[[
阅读更多
gold-8-13
堆箱子。给你一堆n个箱子，箱子宽 wi、深 di、高 hi。箱子不能翻转，将箱子堆起来时，下面箱子的宽度、高度和深度必须大于上面的箱子。实现一种方法，搭出最高的一堆箱子。箱堆的高度为每个箱子高度的总和。 输入使用数组[wi, di, hi]
阅读更多
gold-8-14
给定一个布尔表达式和一个期望的布尔结果 result，布尔表达式由 0 (false)、1 (true)、& (AND)、 | (OR) 和 ^ (XOR) 符号组成。实现一个函数，算出有几种可使该表达式得出 result 值的括号
阅读更多
gold-10-1
给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。 初始化 A 和 B 的元素数量分别为 m 和 n。 示例: 输入: A = [1,2,3,0,0,0], m = 3
阅读更多
gold-10-3
搜索旋转数组。给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次了，次数不详。请编写代码找出数组中的某个元素，假设数组元素原先是按升序排列的。若有多个相同元素，返回索引值最小的一个。 示例1: 输入: arr = [15, 16
阅读更多
gold-10-5
稀疏数组搜索。有个排好序的字符串数组，其中散布着一些空字符串，编写一种方法，找出给定字符串的位置。 示例1: 输入: words = ["at", "", "", "", "ball", "", "", "car", "", "","dad
阅读更多
gold-10-9
给定M×N矩阵，每一行、每一列都按升序排列，请编写代码找出某元素。 示例: 现有矩阵 matrix 如下： [ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 1
阅读更多
gold-10-10
假设你正在读取一串整数。每隔一段时间，你希望能找出数字 x 的秩(小于或等于 x 的值的个数)。请实现数据结构和算法来支持这些操作，也就是说： 实现 track(int x) 方法，每读入一个数字都会调用该方法； 实现 getRankOfN
阅读更多
gold-10-11
在一个整数数组中，“峰”是大于或等于相邻整数的元素，相应地，“谷”是小于或等于相邻整数的元素。例如，在数组{5, 8, 4, 2, 3, 4, 6}中，{8, 6}是峰， {5, 2}是谷。现在给定一个整数数组，将该数组按峰与谷的交替顺序排
阅读更多
gold-16-1
编写一个函数，不用临时变量，直接交换numbers = [a, b]中a与b的值。 示例： 输入: numbers = [1,2] 输出: [2,1] 提示： numbers.length == 2 `-2147483647 <=
阅读更多
gold-16-2
设计一个方法，找出任意指定单词在一本书中的出现频率。 你的实现应该支持如下操作： WordsFrequency(book)构造函数，参数为字符串数组构成的一本书 get(word)查询指定单词在书中出现的频率 示例： WordsFreq
阅读更多
gold-16-3
给定两条线段（表示为起点start = {X1, Y1}和终点end = {X2, Y2}），如果它们有交点，请计算其交点，没有交点则返回空值。 要求浮点型误差不超过10^-6。若有多个交点（线段重叠）则返回 X 值最小的点，X 坐标相同则
阅读更多
gold-16-4
设计一个算法，判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘，由字符” “，”X”和”O”组成，其中字符” “代表一个空位。 以下是井字游戏的规则： 玩家轮流将字符放入空位（” “）中。 第一个玩家总是放字符”O”，且第二个
阅读更多
gold-16-5
设计一个算法，算出 n 阶乘有多少个尾随零。 示例 1: 输入: 3 输出: 0 解释: 3! = 6, 尾数中没有零。 示例 2: 输入: 5 输出: 1 解释: 5! = 120, 尾数中有 1 个零. 说明: 你算法的时间复杂度应
阅读更多
gold-16-6
给定两个整数数组a和b，计算具有最小差绝对值的一对数值（每个数组中取一个值），并返回该对数值的差 示例： 输入：{1, 3, 15, 11, 2}, {23, 127, 235, 19, 8} 输出：3，即数值对(11, 8) 提示：
阅读更多
gold-16-7
编写一个方法，找出两个数字a和b中最大的那一个。不得使用if-else或其他比较运算符。 示例： 输入： a = 1, b = 2 输出： 2 //leetcode submit region begin(Prohibit modific
阅读更多
gold-16-8
给定一个整数，打印该整数的英文描述。 示例 1: 输入: 123 输出: "One Hundred Twenty Three" 示例 2: 输入: 12345 输出: "Twelve Thousand Three Hundred Fort
阅读更多
gold-16-9
请实现整数数字的乘法、减法和除法运算，运算结果均为整数数字，程序中只允许使用加法运算符和逻辑运算符，允许程序中出现正负常数，不允许使用位运算。 你的实现应该支持如下操作： Operations() 构造函数 minus(a, b) 减法，
阅读更多
gold-16-10
给定 N 个人的出生年份和死亡年份，第 i 个人的出生年份为 birth[i]，死亡年份为 death[i]，实现一个方法以计算生存人数最多的年份。 你可以假设所有人都出生于 1900 年至 2000 年（含 1900 和 2000 ）之间
阅读更多
gold-16-11
你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为shorter，长度较长的木板长度为longer。你必须正好使用k块木板。编写一个方法，生成跳水板所有可能的长度。 返回的长度需要从小到大排列。 示例 1 输入： sh
阅读更多
gold-16-13
给定两个正方形及一个二维平面。请找出将这两个正方形分割成两半的一条直线。假设正方形顶边和底边与 x 轴平行。 每个正方形的数据square包含3个数值，正方形的左下顶点坐标[X,Y] = [square[0],square[1]]，以及正方
阅读更多
gold-16-14
给定一个二维平面及平面上的 N 个点列表Points，其中第i个点的坐标为Points[i]=[Xi,Yi]。请找出一条直线，其通过的点的数目最多。 设穿过最多点的直线所穿过的全部点编号从小到大排序的列表为S，你仅需返回[S[0],S[1]
阅读更多
gold-16-15
珠玑妙算游戏（the game of master mind）的玩法如下。 计算机有4个槽，每个槽放一个球，颜色可能是红色（R）、黄色（Y）、绿色（G）或蓝色（B）。例如，计算机可能有RGGB 4种（槽1为红色，槽2、3为绿色，槽4为蓝色）
阅读更多
gold-16-16
给定一个整数数组，编写一个函数，找出索引m和n，只要将索引区间[m,n]的元素排好序，整个数组就是有序的。注意：n-m尽量最小，也就是说，找出符合条件的最短序列。函数返回值为[m,n]，若不存在这样的m和n（例如整个数组是有序的），请返回[
阅读更多
gold-16-17
给定一个整数数组，找出总和最大的连续数列，并返回总和。 示例： 输入： [-2,1,-3,4,-1,2,1,-5,4] 输出： 6 解释： 连续子数组 [4,-1,2,1] 的和最大，为 6。 进阶： 如果你已经实现复杂度为 O(n) 的
阅读更多
gold-16-18
你有两个字符串，即pattern和value。 pattern字符串由字母"a"和"b"组成，用于描述字符串中的模式。例如，字符串"catcatgocatgo"匹配模式"aabab"（其中"cat"是"a"，"go"是"b"），该字符串也匹
阅读更多
gold-16-19
你有一个用于表示一片土地的整数矩阵land，该矩阵中每个点的值代表对应地点的海拔高度。若值为0则表示水域。由垂直、水平或对角连接的水域为池塘。池塘的大小是指相连接的水域的个数。编写一个方法来计算矩阵中所有池塘的大小，返回值需要从小到大排序。
阅读更多
gold-16-20
在老式手机上，用户通过数字键盘输入，手机将提供与这些数字相匹配的单词列表。每个数字映射到0至4个字母。给定一个数字序列，实现一个算法来返回匹配单词的列表。你会得到一张含有有效单词的列表。映射如下图所示： 示例 1: 输入: num = "
阅读更多
gold-16-21
给定两个整数数组，请交换一对数值（每个数组中取一个数值），使得两个数组所有元素的和相等。 返回一个数组，第一个元素是第一个数组中要交换的元素，第二个元素是第二个数组中要交换的元素。若有多个答案，返回任意一个均可。若无满足条件的数值，返回空数
阅读更多
gold-16-22
一只蚂蚁坐在由白色和黑色方格构成的无限网格上。开始时，网格全白，蚂蚁面向右侧。每行走一步，蚂蚁执行以下操作。 (1) 如果在白色方格上，则翻转方格的颜色，向右(顺时针)转 90 度，并向前移动一个单位。(2) 如果在黑色方格上，则翻转方格的
阅读更多
gold-16-24
设计一个算法，找出数组中两数之和为指定值的所有整数对。一个数只能属于一个数对。 示例 1: 输入: nums = [5,6,5], target = 11 输出: [[5,6]] 示例 2: 输入: nums = [5,6,5,6], t
阅读更多
gold-16-25
设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和
阅读更多
gold-16-26
给定一个包含正整数、加(+)、减(-)、乘(*)、除(/)的算数表达式(括号除外)，计算其结果。 表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。 示例 1: 输入: "3+2*2" 输出: 7
阅读更多
gold-17-1
设计一个函数把两个数字相加。不得使用 + 或者其他算术运算符。 示例: 输入: a = 1, b = 1 输出: 2 提示： a, b 均可能是负数或 0 结果不会溢出 32 位整数 //leetcode submit region
阅读更多
gold-17-4
数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？ 注意：本题相对书上原题稍作改动 示例 1： 输入：[3,0,1] 输出：2 示例 2： 输入：[9,6,4,2,3,5,7
阅读更多
gold-17-5
给定一个放有字母和数字的数组，找到最长的子数组，且包含的字母和数字的个数相同。 返回该子数组，若存在多个最长子数组，返回左端点下标值最小的子数组。若不存在这样的数组，返回一个空数组。 示例 1: 输入: ["A","1","B","C","
阅读更多
gold-17-6
编写一个方法，计算从 0 到 n (含 n) 中数字 2 出现的次数。 示例: 输入: 25 输出: 9 解释: (2, 12, 20, 21, 22, 23, 24, 25)(注意 22 应该算作两次) 提示： n <= 10^
阅读更多
gold-17-7
每年，政府都会公布一万个最常见的婴儿名字和它们出现的频率，也就是同名婴儿的数量。有些名字有多种拼法，例如，John 和 Jon 本质上是相同的名字，但被当成了两个名字公布出来。给定两个列表，一个是名字及对应的频率，另一个是本质相同的名字对。
阅读更多
gold-17-8
有个马戏团正在设计叠罗汉的表演节目，一个人要站在另一人的肩膀上。出于实际和美观的考虑，在上面的人要比下面的人矮一点且轻一点。已知马戏团每个人的身高和体重，请编写代码计算叠罗汉最多能叠几个人。 示例： 输入：height = [65,70,5
阅读更多
gold-17-9
有些数的素因子只有 3，5，7，请设计一个算法找出第 k 个数。注意，不是必须有这些素因子，而是必须不包含其他的素因子。例如，前几个数按顺序应该是 1，3，5，7，9，15，21。 示例 1: 输入: k = 5 输出: 9 cla
阅读更多
gold-17-11
有个内含单词的超大文本文件，给定任意两个不同的单词，找出在这个文件中这两个单词的最短距离(相隔单词数)。如果寻找过程在这个文件中会重复多次，而每次寻找的单词不同，你能对此优化吗? 示例： 输入：words = ["I","am","a","
阅读更多
gold-17-12
二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。实现一个方法，把二叉搜索树转换为单向链表，要求依然符合二叉搜索树的性质，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改。 返回转换后的
阅读更多
gold-17-13
哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。像句子"I reset the computer. It still didn’t boot!"已经变成了"iresetthecomputeritstilldidn
阅读更多
gold-17-15
给定一组单词words，编写一个程序，找出其中的最长单词，且该单词由这组单词中的其他单词组合而成。若有多个长度相同的结果，返回其中字典序最小的一项，若没有符合要求的单词则返回空字符串。 示例： 输入： ["cat","banana","do
阅读更多
gold-17-16
一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。 注意：本题相对原题稍作改动
阅读更多
gold-17-17
给定一个较长字符串big和一个包含较短字符串的数组smalls，设计一个方法，根据smalls中的每一个较短字符串，对big进行搜索。输出smalls中的字符串在big里出现的所有位置positions，其中positions[i]为sma
阅读更多
gold-17-18
假设你有两个数组，一个长一个短，短的元素均不相同。找到长数组中包含短数组所有的元素的最短子数组，其出现顺序无关紧要。 返回最短子数组的左端点和右端点，如有多个满足条件的子数组，返回左端点最小的一个。若不存在，返回空数组。 示例 1: 输入:
阅读更多
gold-17-19
给定一个数组，包含从 1 到 N 所有的整数，但其中缺了两个数字。你能在 O(N) 时间内只用 O(1) 的空间找到它们吗？ 以任意顺序返回这两个数字均可。 示例 1: 输入: [1] 输出: [2,3] 示例 2: 输入: [2,3]
阅读更多
gold-17-20
随机产生数字并传递给一个方法。你能否完成这个方法，在每次产生新值时，寻找当前所有值的中间值（中位数）并保存。 中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。 例如， [2,3,4] 的中位数是 3 [2,3]
阅读更多
gold-17-22
给定字典中的两个词，长度相等。写一个方法，把一个词转换成另一个词， 但是一次只能改变一个字符。每一步得到的新词都必须能在字典中找到。 编写一个程序，返回一个可能的转换序列。如有多个可能的转换序列，你可以返回任何一个。 示例 1: 输入: b
阅读更多
lc-106
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。 示例 1: 输入：inorder = [9,3,15,20,
阅读更多
lc-889
给定两个整数数组，preorder 和 postorder ，其中 preorder 是一个具有 无重复 值的二叉树的前序遍历，postorder 是同一棵树的后序遍历，重构并返回二叉树。 如果存在多个答案，您可以返回其中 任何 一个。 示
阅读更多
lc-135
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。 你需要按照以下要求，给这些孩子分发糖果： 每个孩子至少分配到 1 个糖果。 相邻两个孩子评分更高的孩子会获得更多的糖果。 请你给每个孩子分发糖果，计算并返回需要
阅读更多
lc-225
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并
阅读更多
lc-143
给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为： L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … 不能只是单纯的改
阅读更多
lc-144
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例 1： 输入：root = [1,null,2,3] 输出：[1,2,3] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输
阅读更多
lc-145
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。 示例 1： 输入：root = [1,null,2,3] 输出：[3,2,1] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1]
阅读更多
lc-147
给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待
阅读更多
lc-150
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。 请你计算该表达式。返回一个表示表达式值的整数。 注意： 有效的算符为 '+'、'-'、'*' 和 '/' 。 每个操作数（运算对象）都可以是一个整数或者另
阅读更多
lc-153
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到： 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2] 若旋转
阅读更多
lc-164
给定一个无序的数组 nums，返回 数组在排序之后，相邻元素之间最大的差值 。如果数组元素个数小于 2，则返回 0 。 您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。 示例 1: 输入: nums = [3,6,9,1]
阅读更多
lc-167
给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，
阅读更多
lc-168
给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。 例如： A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 ...
阅读更多
lc-172
给定一个整数 n ，返回 n! 结果中尾随零的数量。 提示 n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1 示例 1： 输入：n = 3 输出：0 解释：3! = 6 ，不含尾随 0 示例 2：
阅读更多
lc-174
恶魔们抓住了公主并将她关在了地下城 dungeon 的 右下角 。地下城是由 m x n 个房间组成的二维网格。我们英勇的骑士最初被安置在 左上角 的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。 骑士的初始健康点数为一个正整数。如果他
阅读更多
lc-176
Employee 表： +-------------+------+ | Column Name | Type | +-------------+------+ | id | int | | salary |
阅读更多
lc-177
表: Employee +-------------+------+ | Column Name | Type | +-------------+------+ | id | int | | salary |
阅读更多
lc-178
表: Scores +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | scor
阅读更多
lc-180
表：Logs +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | num
阅读更多
lc-199
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例 1: 输入: [1,2,3,null,5,null,4] 输出: [1,3,4] 示例 2: 输入: [1,null,
阅读更多
lc-181
表：Employee +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | nam
阅读更多
lc-201
给你两个整数 left 和 right ，表示区间 [left, right] ，返回此区间内所有数字 按位与 的结果（包含 left 、right 端点）。 示例 1： 输入：left = 5, right = 7 输出：4 示例 2：
阅读更多
lc-182
表: Person +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | emai
阅读更多
lc-203
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2
阅读更多
lc-151
给你一个字符串 s ，请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意：输入字符串 s中可能会存在前
阅读更多
lc-183
Customers 表： +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | n
阅读更多
lc-205
给定两个字符串 s 和 t ，判断它们是否是同构的。 如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。 每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映
阅读更多
lc-184
表： Employee +--------------+---------+ | 列名 | 类型 | +--------------+---------+ | id | int | | n
阅读更多
lc-209
给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符
阅读更多
lc-185
表: Employee +--------------+---------+ | Column Name | Type | +--------------+---------+ | id | int |
阅读更多
lc-210
现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修
阅读更多
lc-187
DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。 例如， "ACGAATTCCG" 是一个 DNA序列 。 在研究 DNA 时，识别 DNA 中的重复序列非常有用。 给定一个表示 DNA序列 的字符串
阅读更多
lc-188
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。 注意：你不能
阅读更多
  我的梦想
不是每个人都应该像我这样去建造一座水晶大教堂，但是每个人都应该拥有自己的梦想，设计自己的梦想，追求自己的梦想，实现自己的梦想。梦想是生命的灵魂，是心灵的灯塔，是引导人走向成功的信仰。有了崇高的梦想，只要矢志不渝地追求，梦想就会成为现实，奋斗就会变成壮举，生命就会创造奇迹。——罗伯·舒乐
lc-188 lc-188
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。 注意：你不能
2024-04-24 leetcode
leetcode
lc-187 lc-187
DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。 例如， "ACGAATTCCG" 是一个 DNA序列 。 在研究 DNA 时，识别 DNA 中的重复序列非常有用。 给定一个表示 DNA序列 的字符串
2024-04-23 leetcode
leetcode
lc-210 lc-210
现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修
2024-04-22 leetcode
leetcode
lc-185 lc-185
表: Employee +--------------+---------+ | Column Name | Type | +--------------+---------+ | id | int |
2024-04-19 leetcode
leetcode
lc-209 lc-209
给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符
2024-04-18 leetcode
leetcode
lc-184 lc-184
表： Employee +--------------+---------+ | 列名 | 类型 | +--------------+---------+ | id | int | | n
2024-04-17 leetcode
leetcode
lc-205 lc-205
给定两个字符串 s 和 t ，判断它们是否是同构的。 如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。 每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映
2024-04-16 leetcode
leetcode
lc-183 lc-183
Customers 表： +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | n
2024-04-15 leetcode
leetcode
lc-151 lc-151
给你一个字符串 s ，请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意：输入字符串 s中可能会存在前
2024-04-10 leetcode
leetcode
lc-203 lc-203
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2
2024-04-08 leetcode
leetcode
1 / 43