pisecespeng / pisecespeng.record.me Goto Github PK

回文链表

请判断一个链表是否为回文链表.

示例 1:
输入: 1 -> 2
输出: false

示例 2:
输入: 1 -> 2 -> 2 -> 1
输出: true

进阶:
你能否用O(n)时间复杂度和O(1)空间复杂度解决此题?

题目地址: https://leetcode-cn.com/problems/palindrome-linked-list/

二叉树的层序遍历

给你一个二叉树,
请你返回其按层序遍历得到的节点值.(即逐层地，从左到右访问所有节点).

示例:

二叉树：[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/

x的平方根

实现int sqrt(int x)函数.

计算并返回x的平方根, 其中x是非负整数.

由于返回类型是整数, 结果只保留整数的部分, 小数点将被舍去.

示例1:
输入: 4
输出: 2

示例2:
输入: 8
输出: 2
说明: 
8的平方根是2.82842...,
由于返回类型是整数, 
小数部分将被舍去.

题目地址: https://leetcode-cn.com/problems/sqrtx/

从尾到头打印链表

输入一个链表的头节点, 从尾到头反过来返回每个节点的值(用数组返回).

示例 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'的个数(也被称为汉明重量).

提示:
请注意, 在某些语言(如 Java)中, 没有无符号整数类型.
在这种情况下, 输入和输出都将被指定为有符号整数类型, 并且不应影响您的实现,
因为无论整数是有符号的还是无符号的, 其内部的二进制表示形式都是相同的.
在Java中, 编译器使用二进制补码记法来表示有符号整数.
因此, 在下面的示例3中, 输入表示有符号整数-3.

进阶:
如果多次调用这个函数, 你将如何优化你的算法?

示例 1: 
输入: 00000000000000000000000000001011
输出: 3
解释: 输入的二进制串 00000000000000000000000000001011 中, 共有三位为 '1'.

示例 2: 
输入: 00000000000000000000000010000000
输出: 1
解释: 输入的二进制串 00000000000000000000000010000000 中, 共有一位为 '1'.

示例 3: 
输入: 11111111111111111111111111111101
输出: 31
解释: 输入的二进制串 11111111111111111111111111111101 中, 共有 31 位为 '1'.

提示:
输入必须是长度为32的 二进制串 .

题目地址: https://leetcode-cn.com/problems/number-of-1-bits/

两数之和

给定一个整数数组nums和一个目标值target, 请你在该数组中找到和为目标值的那两个整数, 并返回他们的数组下标.

你可以假设每种输入只会对应一个答案. 但是, 你不能重复利用这个数组中同样的元素.

示例:

给定 nums = [2,7,11,15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回[0,1]

题目地址: https://leetcode-cn.com/problems/two-sum/

回文数

判断一个整数是否是回文数.
回文数是指正序(从左到右)和倒序(从右到左)读都是一样的整数.

示例1 :
输入: 121
输出: true

示例2 :
输入: -121
输出: false
解释: 从左向右读是 -121, 从右向左读是 121-.因此不是回文数.

示例3 :
输入: 10
输出: false
解释: 从左向右读是 10, 从右向左读是 01.因此不是回文数.

进阶:
能不将整数转化为字符串来解决这个问题?

题目地址: https://leetcode-cn.com/problems/palindrome-number/

反转链表

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶 :
你可以迭代或递归地反转链表.你能否用两种方法解决这道题?

题目地址: https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/

合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回.
新链表是通过拼接给定的两个链表的所有节点组成的.

示例 :

输入: 1->2->4, 1->3->4
输出: 1->1->2->3->4->4

题目地址: https://leetcode-cn.com/problems/merge-two-sorted-lists/

加一

给定一个由整数组成的非空数组所表示的非负数,

在该数的基础上加一.

最高位数组存放在数组的首位, 数组中每个元素只储存单个数字.

你可以假设除了整数0之外, 这个整数不会以零开头.

示例1:
输入: [1, 2, 3]
输出: [1, 2, 4]
解释: 输入数组表示数字123.

示例2:
输入: [4, 3, 2, 1]
输出: [4, 3, 2, 2]
解释: 输入数组表示数字4321.

题目地址: https://leetcode-cn.com/problems/plus-one/

合并两个有序数组

给你两个有序整数数组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

题目地址: https://leetcode-cn.com/problems/merge-sorted-array/

买卖股票的最佳时期2

给定一个数组, 它的第 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/

3的幂

给定一个整数, 写一个函数来判断它是否是'3'的幂次方.
如果是, 返回true;
否则, 返回false.

整数'n'是'3'的幂次方需满足: 存在整数'x'使得n == 3x

示例 1: 
输入: n = 27
输出: true

示例 2: 
输入: n = 0
输出: false

示例 3: 
输入: n = 9
输出: true

示例 4: 
输入: n = 45
输出: false

提示:

• -2^31 <= n <= 2^31 - 1

进阶:

• 你能不使用循环或者递归来完成本题吗？

题目地址: https://leetcode-cn.com/problems/power-of-three/

两数相加

给出两个非空的链表用来表示两个非负的整数.
其中, 它们各自的位数是按照 逆序 的方式存储的, 并且它们的每个节点只能存储 一位 数字.
如果, 我们将这两个数相加起来, 则会返回一个新的链表来表示它们的和.
您可以假设除了数字0之外, 这两个数都不会以0开头.

示例:
输入: (2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 0 -> 8
原因: 342 + 465 = 807

题目地址: https://leetcode-cn.com/problems/add-two-numbers/

二叉树的最大深度

给定一个二叉树, 找出其最大深度.
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数.

说明: 叶子节点是指没有子节点的节点.

示例:

给定二叉树[3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度3.

题目地址: https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

买卖股票的最佳时期

给定一个数组, 它的第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/

两个数组的交集 II

给定两个数组, 编写一个函数来计算它们的交集.

示例 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/

反转字符串

编写一个函数, 其作用是将输入的字符串反转过来.输入字符串以字符数组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"]

题目地址: https://leetcode-cn.com/problems/reverse-string/

丑数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

题目地址: https://leetcode-cn.com/problems/ugly-number-ii/

回文链表

给你一个长度为n的链表, 每个节点包含一个额外增加的随机指针random, 该指针可以指向链表中的任何节点或空节点.

构造这个链表的深拷贝.
深拷贝应该正好由n个全新节点组成, 其中每个新节点的值都设为其对应的原节点的值.
新节点的next指针和random指针也都应指向复制链表中的新节点,
并使原链表和复制链表中的这些指针能够表示相同的链表状态.
复制链表中的指针都不应指向原链表中的节点.

例如, 如果原链表中有x和y两个节点, 其中x.random --> y.
那么在复制链表中对应的两个节点x和y, 同样有x.random --> y.

返回复制链表的头节点.

用一个由n个节点组成的链表来表示输入/输出中的链表.
每个节点用一个[val, random_index]表示:

• val: 一个表示 Node.val 的整数.
• random_index: 随机指针指向的节点索引(范围从 0 到 n-1);如果不指向任何节点, 则为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,2,1]
输出: 1

示例 2:
输入: [4,1,2,1,2]
输出: 4

题目地址: https://leetcode-cn.com/problems/single-number/

Fizz Buzz

写一个程序, 输出从'1'到'n'数字的字符串表示.

1. 如果'n'是3的倍数, 输出“Fizz”;
2. 如果'n'是5的倍数, 输出“Buzz”;
3. 如果'n'同时是3和5的倍数, 输出 “FizzBuzz”.

示例: 
n = 15,

返回:
[
  "1",
  "2",
  "Fizz",
  "4",
  "Buzz",
  "Fizz",
  "7",
  "8",
  "Fizz",
  "Buzz",
  "11",
  "Fizz",
  "13",
  "14",
  "FizzBuzz"
]

题目地址: https://leetcode-cn.com/problems/fizz-buzz/

删除排序数组中的重复项

给定一个排序数组, 你需要在'原地'删除重复出现的元素,

使得每个元素只出现一次, 返回移除后数组的新长度.

不要使用额外的数组空间, 你必须在'原地'修改输入数组,

并在使用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/

外观数列

"外观数列"是一个整数序列, 从数字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".

题目地址: https://leetcode-cn.com/problems/count-and-say/

二进制求和

给定两个二进制字符串, 返回他们的和(用二进制表示).

输入为非空字符串且只包含数字1和0.

示例1:
输入: a = "11", b = "1"
输出: "100"

示例2:
输入: a = "1010", b = "1011"
输出: "10101"

题目地址: https://leetcode-cn.com/problems/add-binary/

删除链表的倒数第N个节点

给定一个链表, 删除链表的倒数第 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/