pisecespeng / pisecespeng.record.me Goto Github PK
View Code? Open in Web Editor NEW:beach_umbrella: All things are difficult before they are easy
License: MIT License
:beach_umbrella: All things are difficult before they are easy
License: MIT License
给定一个数组, 它的第i
个元素是一支给定股票第i
天的价格.
如果你最多只允许完成一笔交易(即买入和卖出一支股票一次), 设计一个算法来计算你所能获取的最大利润.
注意: 你不能在买入股票前卖出股票.
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天(股票价格 = 1)的时候买入, 在第 5 天(股票价格 = 6)的时候卖出, 最大利润 = 6-1 = 5 .
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格; 同时, 你不能在买入前卖出股票.
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0.
题目地址: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
给定一个二叉树, 找出其最大深度.
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数.
说明: 叶子节点是指没有子节点的节点.
示例:
给定二叉树[3,9,20,null,null,15,7]
3
/ \
9 20
/ \
15 7
返回它的最大深度3.
题目地址: https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
给定一个非空整数数组, 除了某个元素只出现一次以外, 其余每个元素均出现两次.
找出那个只出现了一次的元素.
说明:
你的算法应该具有线性时间复杂度. 你可以不使用额外空间来实现吗?
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
给定一个由整数组成的非空数组所表示的非负数,
在该数的基础上加一.
最高位数组存放在数组的首位, 数组中每个元素只储存单个数字.
你可以假设除了整数0之外, 这个整数不会以零开头.
示例1:
输入: [1, 2, 3]
输出: [1, 2, 4]
解释: 输入数组表示数字123.
示例2:
输入: [4, 3, 2, 1]
输出: [4, 3, 2, 2]
解释: 输入数组表示数字4321.
写一个程序, 输出从'1'到'n'数字的字符串表示.
示例:
n = 15,
返回:
[
"1",
"2",
"Fizz",
"4",
"Buzz",
"Fizz",
"7",
"8",
"Fizz",
"Buzz",
"11",
"Fizz",
"13",
"14",
"FizzBuzz"
]
给你一个长度为n
的链表, 每个节点包含一个额外增加的随机指针random
, 该指针可以指向链表中的任何节点或空节点.
构造这个链表的深拷贝
.
深拷贝应该正好由n
个全新节点组成, 其中每个新节点的值都设为其对应的原节点的值.
新节点的next
指针和random
指针也都应指向复制链表中的新节点,
并使原链表和复制链表中的这些指针能够表示相同的链表状态.
复制链表中的指针都不应指向原链表中的节点.
例如, 如果原链表中有x
和y
两个节点, 其中x.random --> y
.
那么在复制链表中对应的两个节点x
和y
, 同样有x.random --> y
.
返回复制链表的头节点.
用一个由n
个节点组成的链表来表示输入/输出中的链表.
每个节点用一个[val, random_index]
表示:
null
.你的代码只接受原链表的头节点head
作为传入参数.
示例 1:
输入: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出: [[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2:
输入: head = [[1,1],[2,1]]
输出: [[1,1],[2,1]]
示例 3:
输入: head = [[3,null],[3,0],[3,null]]
输出: [[3,null],[3,0],[3,null]]
示例 4:
输入: head = []
输出: []
解释: 给定的链表为空(空指针), 因此返回null.
提示:
0 <= n <= 1000
.-10000 <= Node.val <= 10000
.Node.random 为空(null)
或指向链表中的节点.题目地址: https://leetcode-cn.com/problems/copy-list-with-random-pointer/
将两个有序链表合并为一个新的有序链表并返回.
新链表是通过拼接给定的两个链表的所有节点组成的.
示例 :
输入: 1->2->4, 1->3->4
输出: 1->1->2->3->4->4
题目地址: https://leetcode-cn.com/problems/merge-two-sorted-lists/
给定一个链表, 删除链表的倒数第 n 个节点, 并且返回链表的头结点.
示例:
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后, 链表变为 1->2->3->5.
说明:
给定的 n 保证是有效的.
进阶:
你能尝试使用一趟扫描实现吗?
题目地址: https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
编写一个函数, 其作用是将输入的字符串反转过来.输入字符串以字符数组char[]
的形式给出.
不要给另外的数组分配额外的空间, 你必须原地修改输入数组、使用O(1)
的额外空间解决这一问题.
你可以假设数组中的所有字符都是ASCII码表中的可打印字符.
示例1:
输入: ["h","e","l","l","o"]
输出: ["o","l","l","e","h"]
示例2:
输入: ["H","a","n","n","a","h"]
输出: ["h","a","n","n","a","H"]
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶 :
你可以迭代或递归地反转链表.你能否用两种方法解决这道题?
题目地址: https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/
给你两个有序整数数组nums1
和nums2
, 请你将nums2
合并到nums1
中, 使nums1
成为一个有序数组.
说明:
nums1
和nums2
的元素数量分别为m
和n
.nums1
有足够的空间(空间大小大于或等于m + n
)来保存nums2
中的元素.示例:
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
提示:
-10^9 <= nums1[i], nums2[i] <= 10^9
nums1.length == m + n
nums2.length == n
给定两个数组, 编写一个函数来计算它们的交集.
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明:
进阶:
nums1
的大小比nums2
小很多, 哪种方法更优?nums2
的元素存储在磁盘上, 磁盘内存是有限的, 并且你不能一次加载所有的元素到内存中, 你该怎么办?题目地址: https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/
实现int sqrt(int x)
函数.
计算并返回x的平方根, 其中x是非负整数.
由于返回类型是整数, 结果只保留整数的部分, 小数点将被舍去.
示例1:
输入: 4
输出: 2
示例2:
输入: 8
输出: 2
说明:
8的平方根是2.82842...,
由于返回类型是整数,
小数部分将被舍去.
"外观数列"是一个整数序列, 从数字1开始, 序列中的每一项都是对前一项的描述.
前五项如下:
1. 1
2. 11
3. 21
4. 1211
5. 111221
1
被读做"one 1" ("一个一"), 即11
.
11
被读做"two 1" ("两个一"), 即21
.
21
被读做"one 2","one 1" ("一个二", "一个一"), 即1211
.
给定正整数n(1 <= b <= 30), 输出外观数列的第n项.
注意: 整数序列中的每一项将表示为一个字符串.
示例1:
输入: 1
输出: "1"
解释: 这是一个基本样例
示例2:
输入: 4
输出: "1211"
解释:
当n=3时, 序列是"21", 其中我们有"2"和"1"两组,
"2"可以读作"12", 也就是出现 频次 = 1而 值 = 2;
类似"1"可以读作"11".
所以答案是"12"和"11"组合在一起, 也就是"1211".
编写一个函数, 输入是一个无符号整数(以二进制串的形式),
返回其二进制表达式中数字位数为'1'的个数(也被称为汉明重量).
提示:
请注意, 在某些语言(如 Java)中, 没有无符号整数类型.
在这种情况下, 输入和输出都将被指定为有符号整数类型, 并且不应影响您的实现,
因为无论整数是有符号的还是无符号的, 其内部的二进制表示形式都是相同的.
在Java
中, 编译器使用二进制补码记法来表示有符号整数.
因此, 在下面的示例3
中, 输入表示有符号整数-3
.
进阶:
如果多次调用这个函数, 你将如何优化你的算法?
示例 1:
输入: 00000000000000000000000000001011
输出: 3
解释: 输入的二进制串 00000000000000000000000000001011 中, 共有三位为 '1'.
示例 2:
输入: 00000000000000000000000010000000
输出: 1
解释: 输入的二进制串 00000000000000000000000010000000 中, 共有一位为 '1'.
示例 3:
输入: 11111111111111111111111111111101
输出: 31
解释: 输入的二进制串 11111111111111111111111111111101 中, 共有 31 位为 '1'.
提示:
输入必须是长度为32
的 二进制串 .
给出两个非空
的链表用来表示两个非负的整数.
其中, 它们各自的位数是按照 逆序
的方式存储的, 并且它们的每个节点只能存储 一位
数字.
如果, 我们将这两个数相加起来, 则会返回一个新的链表来表示它们的和.
您可以假设除了数字0
之外, 这两个数都不会以0
开头.
示例:
输入: (2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 0 -> 8
原因: 342 + 465 = 807
给定两个二进制字符串, 返回他们的和(用二进制表示).
输入为非空字符串且只包含数字1
和0
.
示例1:
输入: a = "11", b = "1"
输出: "100"
示例2:
输入: a = "1010", b = "1011"
输出: "10101"
输入一个链表的头节点, 从尾到头反过来返回每个节点的值(用数组返回).
示例 1:
输入: head = [1,3,2]
输出: [2,3,1]
限制: 0 <= 链表长度 <= 10000
题目地址: https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/
请判断一个链表是否为回文链表.
示例 1:
输入: 1 -> 2
输出: false
示例 2:
输入: 1 -> 2 -> 2 -> 1
输出: true
进阶:
你能否用O(n)
时间复杂度和O(1)
空间复杂度解决此题?
题目地址: https://leetcode-cn.com/problems/palindrome-linked-list/
给定一个整数数组nums
和一个目标值target
, 请你在该数组中找到和为目标值的那两个
整数, 并返回他们的数组下标.
你可以假设每种输入只会对应一个答案. 但是, 你不能重复利用这个数组中同样的元素.
示例:
给定 nums = [2,7,11,15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回[0,1]
判断一个整数是否是回文数.
回文数是指正序(从左到右)和倒序(从右到左)读都是一样的整数.
示例1 :
输入: 121
输出: true
示例2 :
输入: -121
输出: false
解释: 从左向右读是 -121, 从右向左读是 121-.因此不是回文数.
示例3 :
输入: 10
输出: false
解释: 从左向右读是 10, 从右向左读是 01.因此不是回文数.
进阶:
能不将整数转化为字符串来解决这个问题?
给定一个数组, 它的第 i 个元素是一支给定股票第 i 天的价格.
设计一个算法来计算你所能获取的最大利润.你可以尽可能地完成更多的交易(多次买卖一支股票).
注意: 你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票).
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天(股票价格 = 1)的时候买入, 在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 .
随后, 在第 4 天(股票价格 = 3)的时候买入, 在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 .
示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天(股票价格 = 1)的时候买入, 在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 .
注意你不能在第 1 天和第 2 天接连购买股票, 之后再将它们卖出.
因为这样属于同时参与了多笔交易, 你必须在再次购买前出售掉之前的股票.
示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0.
提示:
1 <= prices.length <= 3 * 10 ^ 4
.
0 <= prices[i] <= 10 ^ 4
.
题目地址: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/
给你一个整数n
, 请你找出并返回第n
个丑数.
丑数就是只包含质因数2
、3
和/或5
的正整数.
示例 1:
输入: n = 10
输出: 12
解释: [1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前10个丑数组成的序列.
示例 2:
输入: n = 1
输出: 1
解释: 1 通常被视为丑数.
提示:
1 <= n <= 1690
给定一个排序数组, 你需要在'原地'删除重复出现的元素,
使得每个元素只出现一次, 返回移除后数组的新长度.
不要使用额外的数组空间, 你必须在'原地'修改输入数组,
并在使用O(1)额外空间的条件下完成.
示例1:
给定数组 nums = [1, 1, 2],
函数应该返回新的长度2, 并且原数组nums的前两个元素被修改为1,2.
你不需要考虑数组中超出新长度后面的元素
示例2:
给定数组 nums = [0, 0, 1, 1, 2, 2, 3, 3, 4],
函数应该返回新的长度5, 并且原数组nums的前五个元素被修改为0,1,2,3,4.
你不需要考虑数组中超出新长度后面的元素
说明:
为什么返回数组值是整数, 但输出的答案是数组呢?
请注意, 输入数组是以'引用'方式传递的,
这意味着在函数里修改输入数组对于调用者是可见的.
你可以想象内部操作如下:
// nums 是以'引用'方式传递的. 也就是说, 不对实参做任何拷贝
int len = removeDuplicates(nums)
// 在函数里修改输入数组对于调用者是可见的.
// 根据你的函数返回的长度, 它会打印出数组中'该长度范围内'的所有元素
for (int i = 0; i < len; i++) {
print(nums[i]);
}
题目地址: https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
给你一个二叉树,
请你返回其按层序遍历得到的节点值.(即逐层地,从左到右访问所有节点).
示例:
二叉树:[3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回其层次遍历结果:
[
[3],
[9,20],
[15,7]
]
题目地址: https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
给定一个整数, 写一个函数来判断它是否是'3'的幂次方.
如果是, 返回true;
否则, 返回false.
整数'n'是'3'的幂次方需满足: 存在整数'x'使得n == 3x
示例 1:
输入: n = 27
输出: true
示例 2:
输入: n = 0
输出: false
示例 3:
输入: n = 9
输出: true
示例 4:
输入: n = 45
输出: false
提示:
进阶:
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.