(简单)剑指 Offer 03. 数组中重复的数字
找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0~n-1 的范围内。数组中某些数字是重复的,但不知道有几个数字重复了,也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
示例 1:
输入:
[2, 3, 1, 0, 2, 5, 3]
输出:2 或 3
限制:
2 <= n <= 100000
题解:
- C++
class Solution {
public:
int findRepeatNumber(vector<int>& nums) {
int i = 0;
while(i < nums.size())
{
if (nums[i] == i)
{
i++;
continue;
}
if (nums[i] == nums[nums[i]])
return nums[i];
swap(nums[i], nums[nums[i]]);
}
return -1;
}
};
- Golang
func findRepeatNumber(nums []int) int {
length := len(nums);
i := 0
for i < length {
if nums[i] == i {
i++
continue
}
if nums[i] == nums[nums[i]] {
return nums[i]
}
nums[i], nums[nums[i]] = nums[nums[i]], nums[i]
}
return -1
}
(中等)剑指 Offer 04. 二维数组中的查找
减 的顺序排序。请完成一个高效的函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下:
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5
,返回 true
。
给定 target = 20
,返回 false
。
限制:
0 <= n <= 1000
0 <= m <= 1000
题解:
- C++
class Solution {
public:
bool findNumberIn2DArray(vector<vector<int>>& matrix, int target)
{
if (matrix.size() <= 0)
return false;
int i = matrix.size() - 1;
int j = 0;
while (i >= 0 && j < matrix[0].size())
{
if (target < matrix[i][j])
i--;
else if (target > matrix[i][j])
j++;
else
return true;
};
return false;
}
};
- Golang
func findNumberIn2DArray(matrix [][]int, target int) bool {
rows := len(matrix)
if rows < 1 {
return false
}
cols := len(matrix[0])
i := rows - 1
j := 0
for i >= 0 && j < cols {
if target < matrix[i][j] {
i--
} else if target > matrix[i][j] {
j++
} else {
return true
}
}
return false
}
(简单)剑指 Offer 05. 替换空格
请实现一个函数,把字符串 s 中的每个空格替换成"%20"。
示例 1:
输入:s = "We are happy."
输出:"We%20are%20happy."
限制:
0 <= s 的长度 <= 10000
题解:
- C++
class Solution {
public:
string replaceSpace(string s) {
int count = 0;
for(auto ch: s)
if (ch == ' ')
count++;
int len = s.size();
s.resize(len + 2 * count);
for (int i = len - 1, j = s.size() - 1; i < j; i--, j--)
if (s[i] != ' ')
s[j] = s[i];
else
{
s[j] = '0';
s[j - 1] = '2';
s[j - 2] = '%';
j -= 2;
}
return s;
}
};
- Golang
func replaceSpace(s string) string {
ss := []byte(s)
length := len(ss)
count := 0
for _, ch := range ss {
if ch == ' ' {
count++
}
}
cmp := make([]byte, 2 * count)
ss = append(ss, cmp...)
for i, j := length - 1, len(ss) - 1; i < j; i, j = i - 1, j - 1 {
if ss[i] != ' ' {
ss[j] = ss[i]
} else {
ss[j] = '0'
ss[j - 1] = '2'
ss[j - 2] = '%'
j -= 2
}
}
return string(ss)
}
(简单)剑指 Offer 06. 从尾到头打印链表
输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。
示例 1:
输入:head = [1,3,2]
输出:[2,3,1]
限制:
0 <= 链表长度 <= 10000
题解:
- C++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
std::vector<int> res;
while(head)
{
res.push_back(head->val);
head = head->next;
}
int n = res.size();
for (int i = 0; i < (n >> 1); i++)
swap(res[i], res[n - 1 -i]);
return res;
}
};
- Golang
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func reversePrint(head *ListNode) []int {
v := make([]int, 0)
for head != nil {
v = append(v, head.Val)
head = head.Next
}
length := len(v)
for i := 0; i < length / 2; i++ {
v[i], v[length - 1 - i] = v[length - 1 - i], v[i]
}
return v
}
(中等)剑指 Offer 07. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果,请构建该二叉树并返回其根节点。
假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
示例 1:
Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]
示例 2:
Input: preorder = [-1], inorder = [-1]
Output: [-1]
限制:
0 <= 节点个数 <= 5000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
private:
std::unordered_map<int, int> m_index;
TreeNode* _buildTree(std::vector<int>& preorder, int preLeft, int preRight,
std::vector<int>& inorder , int inLeft , int inRight)
{
if (preLeft > preRight)
return nullptr;
int rootValue = preorder[preLeft];
TreeNode* root = new TreeNode(rootValue);
// root node value in inorder.
int index = m_index[rootValue];
// length of left subtree.
int length = index - inLeft; // (index -1) - inLeft + 1
root->left = _buildTree(preorder, preLeft + 1, (preLeft + 1) + (length - 1),
inorder, inLeft, index - 1);
root->right = _buildTree(preorder, (preLeft + 1) + length, preRight,
inorder, index + 1, inRight);
return root;
}
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
{
int n = preorder.size();
for (int i = 0; i < n; i++)
m_index[inorder[i]] = i;
return _buildTree(preorder, 0, n -1, inorder , 0, n -1);
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func buildTreeInternal(preorder, inorder []int, preLeft, preRight, inLeft, inRight int, indexMap map[int]int) *TreeNode {
if preLeft > preRight {
return nil
}
rootValue := preorder[preLeft]
index := indexMap[rootValue]
root := &TreeNode{rootValue, nil, nil}
length := index - inLeft
root.Left = buildTreeInternal(preorder, inorder, preLeft + 1, preLeft + length, inLeft, index - 1, indexMap)
root.Right = buildTreeInternal(preorder, inorder, preLeft + length + 1, preRight, index + 1, inRight, indexMap)
return root;
}
func buildTree(preorder []int, inorder []int) *TreeNode {
n := len(preorder)
indexMap := map[int]int{}
for i, v := range inorder {
indexMap[v] = i
}
return buildTreeInternal(preorder, inorder, 0, n - 1, 0, n - 1, indexMap)
}
(简单)剑指 Offer 09. 用两个栈实现队列
用两个栈实现一个队列。队列的声明如下,请实现它的两个函数 appendTail
和 deleteHead
,分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素,deleteHead
操作返回 -1
)
示例 1:
输入:
["CQueue","appendTail","deleteHead","deleteHead","deleteHead"]
[[],[3],[],[],[]]
输出:[null,null,3,-1,-1]
示例 2:
输入:
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出:[null,-1,null,null,5,2]
提示:
1 <= values <= 10000
- 最多会对
appendTail
、deleteHead
进行10000
次调用
题解:
- C++
class CQueue {
private:
std::stack<int> m_stackA, m_stackB;
void moveA2B() {
while(!m_stackA.empty()){
m_stackB.push(m_stackA.top());
m_stackA.pop();
}
}
public:
CQueue() {
}
void appendTail(int value) {
m_stackA.push(value);
}
int deleteHead() {
if (m_stackB.empty()) {
if (m_stackA.empty())
return -1;
moveA2B();
}
int result = m_stackB.top();
m_stackB.pop();
return result;
}
};
/**
* Your CQueue object will be instantiated and called as such:
* CQueue* obj = new CQueue();
* obj->appendTail(value);
* int param_2 = obj->deleteHead();
*/
- Golang
type CQueue struct {
inStack, outStack []int
}
func Constructor() CQueue {
return CQueue{}
}
func (this *CQueue)moveStack() {
for len(this.inStack) != 0 {
this.outStack = append(this.outStack, this.inStack[len(this.inStack) - 1])
this.inStack = this.inStack[:len(this.inStack) - 1]
}
}
func (this *CQueue) AppendTail(value int) {
this.inStack = append(this.inStack, value)
}
func (this *CQueue) DeleteHead() int {
if len(this.outStack) == 0 {
if len(this.inStack) == 0 {
return -1
}
this.moveStack()
}
r := this.outStack[len(this.outStack) - 1]
this.outStack = this.outStack[:len(this.outStack) - 1]
return r
}
/**
* Your CQueue object will be instantiated and called as such:
* obj := Constructor();
* obj.AppendTail(value);
* param_2 := obj.DeleteHead();
*/
(简单)剑指 Offer 10- I. 斐波那契数列
写一个函数,输入 n
,求斐波那契(Fibonacci)数列的第 n
项(即 F(N)
)。斐波那契数列的定义如下:
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
示例 1:
输入:n = 2
输出:1
示例 2:
输入:n = 5
输出:5
提示:
0 <= n <= 100
题解:
- C++
class Solution {
public:
int fib(int n) {
if (n < 2)
return n;
int a = 0, b = 1, sum = 0;
for (int i = 2; i <= n ; i++)
{
sum = (a + b) % 1000000007;
a = b;
b = sum;
}
return sum ;
}
};
- Golang
func fib(n int) int {
if n < 1 {
return 0
}
if n == 1 {
return 1
}
sum := 0
a, b := 0, 1
for i := 2; i <= n; i++ {
sum = (a + b) % 1000000007
a = b
b = sum
}
return sum
}
(简单)剑指 Offer 10- II. 青蛙跳台阶问题
一只青蛙一次可以跳上1级台阶,也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
示例 1:
输入:n = 2
输出:2
示例 2:
输入:n = 7
输出:21
示例 3:
输入:n = 0
输出:1
提示:
0 <= n <= 100
题解:
- C++
class Solution {
public:
int numWays(int n) {
if (n == 0)
return 1;
if (n == 1)
return 1;
int a = 1, b = 1, r = 0;
for (int i = 2; i <= n; i++)
{
r = (a + b)%1000000007;
a = b;
b = r;
}
return r;
}
};
- Golang
func numWays(n int) int {
if n == 0 {
return 1
}
if n == 1 {
return 1
}
a, b := 1, 1
sum := 0
for i := 2; i <= n; i++ {
sum = (a + b) % 1000000007
a, b = b, sum
}
return sum
}
(简单)剑指 Offer 11. 旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。
给你一个可能存在 重复 元素值的数组 numbers
,它原来是一个升序排列的数组,并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如,数组 [3,4,5,1,2]
为 [1,2,3,4,5]
的一次旋转,该数组的最小值为 1。
注意,数组 [a[0], a[1], a[2], ..., a[n-1]]
旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]
。
示例 1:
输入:numbers = [3,4,5,1,2]
输出:1
示例 2:
输入:numbers = [2,2,2,0,1]
输出:0
提示:
n == numbers.length
1 <= n <= 5000
-5000 <= numbers[i] <= 5000
numbers
原来是一个升序排序的数组,并进行了1
至n
次旋转
题解:
- C++
class Solution {
public:
int minArray(vector<int>& numbers) {
int low = 0;
int high = numbers.size() - 1;
while (low < high)
{
int pivot = low + ((high - low) >> 1);
if (numbers[pivot] < numbers[high])
high = pivot;
else if (numbers[pivot] > numbers[high])
low = pivot + 1;
else
high--;
}
return numbers[low];
}
};
- Golang
func minArray(numbers []int) int {
low := 0
high := len(numbers) - 1
for low < high {
pivot := low + (high - low) / 2
if numbers[pivot] < numbers[high] {
high = pivot
} else if numbers[pivot] > numbers[high] {
low = pivot + 1
} else {
high--
}
}
return numbers[low]
}
(中等)剑指 Offer 12. 矩阵中的路径
给定一个 m x n
二维字符网格 board
和一个字符串单词 word
。如果 word
存在于网格中,返回 true
;否则,返回 false
。
单词必须按照字母顺序,通过相邻的单元格内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
例如,在下面的 3×4 的矩阵中包含单词 “ABCCED”(单词中的字母已标出)。
示例 1:
输入:board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出:true
示例 2:
输入:board = [["a","b"],["c","d"]], word = "abcd"
输出:false
提示:
m == board.length
n = board[i].length
1 <= m, n <= 6
1 <= word.length <= 15
board
和word
仅由大小写英文字母组成
题解:
- C++
class Solution {
private:
int m_columns, m_rows;
bool dfs(vector<vector<char>>& board, string word, int i, int j, int index)
{
if (i >= m_rows ||
j >= m_columns ||
i < 0 ||
j < 0 ||
board[i][j] != word[index])
return false;
if (index == word.size() - 1)
return true;
board[i][j] = '\0';
bool result = dfs(board, word, i + 1, j, index + 1) || dfs(board, word, i - 1, j, index + 1) ||
dfs(board, word, i, j + 1, index + 1) || dfs(board, word, i, j - 1, index + 1);
board[i][j] = word[index];
return result;
}
public:
bool exist(vector<vector<char>>& board, string word)
{
m_rows = board.size();
m_columns = board[0].size();
for (int i = 0; i < m_rows; i++)
for (int j = 0; j < m_columns; j++)
if (dfs(board, word, i, j, 0))
return true;
return false;
}
};
- Golang
func exist(board [][]byte, word string) bool {
for i := range board {
for j := range board[i] {
if dfs(board, word, i, j, 0) {
return true
}
}
}
return false
}
func dfs(board [][]byte, word string, i, j, index int) bool {
if i < 0 || j < 0 || i >= len(board) || j >= len(board[0]) || board[i][j] != word[index] {
return false
}
if index == len(word) - 1 {
return true
}
board[i][j] = 0
r := dfs(board, word, i + 1, j, index + 1) ||
dfs(board, word, i - 1, j, index + 1) ||
dfs(board, word, i, j + 1, index + 1) ||
dfs(board, word, i, j - 1, index + 1)
board[i][j] = word[index]
return r
}
(中等)剑指 Offer 13. 机器人的运动范围
地上有一个m行n列的方格,从坐标 [0,0]
到坐标 [m-1,n-1]
。一个机器人从坐标 [0, 0]
的格子开始移动,它每次可以向左、右、上、下移动一格(不能移动到方格外),也不能进入行坐标和列坐标的数位之和大于k的格子。例如,当k为18时,机器人能够进入方格 [35, 37] ,因为3+5+3+7=18。但它不能进入方格 [35, 38],因为3+5+3+8=19。请问该机器人能够到达多少个格子?
示例 1:
输入:m = 2, n = 3, k = 1
输出:3
示例 2:
输入:m = 3, n = 1, k = 0
输出:1
提示:
- 1 <= n,m <= 100
- 0 <= k <= 20
题解:
- C++
class Solution {
private:
int dfs(int m, int n, int i, int j, int k, vector<vector<int>>& visited) {
if (i >= m || j >= n || getNumberSum(i, j) > k || visited[i][j]) {
return 0;
}
visited[i][j] = 1;
return 1 + dfs(m, n, i + 1, j, k, visited) + dfs(m, n, i, j + 1, k, visited);
}
int getNumberSum(int i, int j) {
int sum = 0;
while (i) {
sum += i % 10;
i /= 10;
}
while (j) {
sum += j % 10;
j /= 10;
}
return sum;
}
public:
int movingCount(int m, int n, int k) {
vector<vector<int>> visited(m, vector<int>(n));
return dfs(m, n, 0, 0, k, visited);
}
};
- Golang
func movingCount(m int, n int, k int) int {
visited := make([][]int, m)
for i := 0; i < len(visited); i++ {
visited[i] = make([]int, n)
}
return dfs(m, n, 0, 0, k, visited)
}
func getNumberSum(i, j int) int {
sum := 0;
for i > 0 {
sum = sum + i % 10
i = i / 10
}
for j > 0 {
sum = sum + j % 10
j = j / 10
}
return sum
};
func dfs(m, n, i, j, k int, visited [][]int) int {
if i < 0 || j < 0 || i >= m || j >= n || getNumberSum(i, j) > k || visited[i][j] > 0 {
return 0
}
visited[i][j] = 1;
return 1 + dfs(m, n, i + 1, j, k, visited) + dfs(m, n, i, j + 1, k, visited)
};
(中等)剑指 Offer 14- I. 剪绳子
给你一根长度为 n 的绳子,请把绳子剪成整数长度的 m
段(m、n都是整数,n>1并且m>1),每段绳子的长度记为 k[0],k[1]...k[m-1]
。请问 k[0]*k[1]*...*k[m-1]
可能的最大乘积是多少?例如,当绳子的长度是8时,我们把它剪成长度分别为2、3、3的三段,此时得到的最大乘积是18。
示例 1:
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示:
2 <= n <= 58
题解:
- C++
class Solution {
public:
int cuttingRope(int n) {
if (n < 4)
return n - 1;
int a = n / 3;
int b = n % 3;
if (b == 0) {
return pow(3, a);
} else if (b == 1) {
return pow(3, a - 1) * 4;
}
return pow(3, a) * 2;
}
};
- Golang
func cuttingRope(n int) int {
if n < 4 {
return n - 1
}
a := n / 3;
b := n % 3;
if b == 0 {
return int(math.Pow(3, float64(a)))
} else if b == 1 {
return int(math.Pow(3, float64(a - 1)) * 4)
}
return int(math.Pow(3, float64(a)) * 2)
}
(中等)剑指 Offer 14- II. 剪绳子 II
给你一根长度为 n 的绳子,请把绳子剪成整数长度的 m
段(m、n都是整数,n>1并且m>1),每段绳子的长度记为 k[0],k[1]...k[m - 1]
。请问 k[0]*k[1]*...*k[m - 1]
可能的最大乘积是多少?例如,当绳子的长度是8时,我们把它剪成长度分别为2、3、3的三段,此时得到的最大乘积是18。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
示例 1:
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示:
2 <= n <= 1000
题解:
- C++
class Solution {
private:
const int MOD = (int)1000000007;
int mpow(long a, long b) {
if (b < 1)
return 1;
long result = 1;
while(b > 0) {
if (b & 1)
result = (a * result) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return result;
}
public:
int cuttingRope(int n) {
if (n < 4)
return n - 1;
int a = n / 3;
int b = n % 3;
int result = 0;
if (b == 0) {
return (int)mpow(3, a) % MOD;
} else if (b == 1) {
return (int)((mpow(3, a - 1) * 4L) % MOD);
}
return (int)((mpow(3, a) * 2L) % MOD);
}
};
- Golang
var base, mod uint64 = 3, 1000000007
func cuttingRope(n int) int {
if n < 4 {
return n - 1;
}
exponent := uint64(n) / base
remainder := uint64(n) % base
if remainder == 0 {
return int(mPow(base, exponent))
} else if remainder == 1 {
return int((mPow(base, exponent - 1) * uint64(4)) % mod)
}
return int((mPow(base, exponent) * uint64(2)) % mod)
}
func mPow(base, exponent uint64) uint64 {
if exponent < 1 {
return 1;
}
var result uint64 = 1
for exponent > 0 {
if (exponent & 1) > 0 {
result = (result * base) % mod;
}
base = (base * base) % mod;
exponent >>= 1
}
return result
}
(简单)剑指 Offer 15. 二进制中1的个数
编写一个函数,输入是一个无符号整数(以二进制串的形式),返回其二进制表达式中数字位数为 ‘1’ 的个数(也被称为 汉明重量).)。
提示:
- 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。
- 在 Java 中,编译器使用 二进制补码 记法来表示有符号整数。因此,在上面的 示例 3 中,输入表示有符号整数
-3
。
示例 1:
输入:n = 11 (控制台输入 00000000000000000000000000001011)
输出:3
解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。
示例 2:
输入:n = 128 (控制台输入 00000000000000000000000010000000)
输出:1
解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。
示例 3:
输入:n = 4294967293 (控制台输入 11111111111111111111111111111101,部分语言中 n = -3)
输出:31
解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。
提示:
输入必须是长度为 32 的 二进制串 。
题解:
- C++
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
while (n) {
count++;
n &= n - 1;// 去掉最后一个1
}
return count;
}
};
- Golang
func hammingWeight(num uint32) int {
count := 0
for num > 0 {
count++
num &= num - 1
}
return count
}
(中等)剑指 Offer 16. 数值的整数次方
实现 pow(x, n),即计算 x 的 n 次幂函数(即,xn)。不得使用库函数,同时不需要考虑大数问题。
示例 1:
输入:x = 2.00000, n = 10
输出:1024.00000
示例 2:
输入:x = 2.10000, n = 3
输出:9.26100
示例 3:
输入:x = 2.00000, n = -2
输出:0.25000
解释:2-2 = 1/22 = 1/4 = 0.25
提示:
-100.0 < x < 100.0
-231 <= n <= 231-1
-104 <= xn <= 104
题解:
- C++
class Solution {
public:
double myPow(double x, int n) {
double result = 1;
long long nNew = n;
if (nNew < 0) {
x = 1 / x;
nNew = -nNew;
}
while (nNew) {
if (nNew & 1)
result = result * x;
x = x * x;
nNew >>= 1;
}
return result;
}
};
- Golang
func myPow(x float64, n int) float64 {
r, nNew := float64(1), int64(n)
if n < 0 {
x = 1 / x
nNew = -nNew
}
for nNew > 0 {
if (nNew & 1) > 0 {
r = r * x
}
x *= x
nNew >>= 1
}
return r
}
(简单)剑指 Offer 17. 打印从1到最大的n位数
输入数字 n
,按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3,则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:
输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]
说明:
- 用返回一个整数列表来代替打印
- n 为正整数
题解:
- C++
class Solution {
public:
vector<int> printNumbers(int n) {
int size = pow(10, n) - 1;
vector<int> r(size, 0);
int left = 1, right = size;
while (left <= right) {
r[left - 1] = left;
r[right - 1] = right;
left++;
right--;
}
return r;
}
};
- Golang
func printNumbers(n int) []int {
size := int(math.Pow(10, float64(n)) - 1)
r := make([]int, size)
for i, j := 1, size; i <= j; i, j = i + 1, j - 1 {
r[i - 1] = i
r[j - 1] = j
}
return r
}
(简单)剑指 Offer 18. 删除链表的节点
给定单向链表的头指针和一个要删除的节点的值,定义一个函数删除该节点。
返回删除后的链表的头节点。
注意: 此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9.
说明:
- 题目保证链表中节点的值互不相同
- 若使用 C 或 C++ 语言,你不需要 free 或 delete 被删除的节点
题解:
- C++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
if (!head) {
return nullptr;
}
if (head->val == val) {
return head->next;
}
ListNode* pre = head, *cur = head->next;
while (cur) {
if (cur->val == val) {
pre->next = cur->next;
break;
}
pre = cur;
cur = cur->next;
}
return head;
}
};
- Golang
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func deleteNode(head *ListNode, val int) *ListNode {
if head == nil {
return nil
}
if head.Val == val {
return head.Next
}
pre, cur := head, head.Next
for head != nil {
if cur.Val == val {
pre.Next = cur.Next
break
}
pre = cur
cur = cur.Next
}
return head
}
(困难)剑指 Offer 19. 正则表达式匹配
请实现一个函数用来匹配包含'. '
和'*'
的正则表达式。模式中的字符'.'
表示任意一个字符,而'*'
表示它前面的字符可以出现任意次(含0次)。在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"
与模式"a.a"
和"ab*ac*a"
匹配,但与"aa.a"
和"ab*a"
均不匹配。
示例 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
示例 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。
示例 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个,这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
提示:
s
可能为空,且只包含从a-z
的小写字母。p
可能为空,且只包含从a-z
的小写字母以及字符.
和*
,无连续的'*'
。
题解:
- C++
class Solution {
public:
bool isMatch(string s, string p) {
int m = s.size();
int n = p.size();
// lambda 表达式:s 和 p 通过引用传递
// s 要匹配的第 i 个,下标 i - 1
// p 要匹配的第 j 个,下表 j - 1
auto matches = [&s, &p](int i, int j) {
if (i == 0) {
return false;
}
if (p[j - 1] == '.') {
return true;
}
return (s[i - 1] == p[j - 1]);
};
vector<vector<int>> f(m + 1, vector<int>(n + 1));
// i = 0, j = 0 表示 s 和 p 都没有字符
f[0][0] = true;
for (int i = 0; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (p[j - 1] == '*') {
f[i][j] |= f[i][j - 2]; // 匹配 0 个 * 前面的字符
if (matches(i , j - 1)) { //
f[i][j] |= f[i - 1][j];
}
} else {
if (matches(i, j)) {
f[i][j] |= f[i - 1][j - 1];
}
}
}
}
return f[m][n];
}
};
- Golang
func isMatch(s string, p string) bool {
m, n := len(s), len(p)
matches := func(i, j int) bool {
if i ==0 {
return false
}
if p[j - 1] == '.' {
return true
}
return s[i - 1] == p[j - 1]
}
f := make([][]bool, m + 1)
for index := 0; index < len(f); index++ {
f[index] = make([]bool, n + 1)
}
f[0][0] = true
for i := 0; i <= m; i++ {
for j := 1; j <= n; j++ {
if p[j - 1] == '*' {
f[i][j] = f[i][j] || f[i][j - 2]
if matches(i , j - 1) {
f[i][j] = f[i][j] || f[i - 1][j]
}
} else {
if matches(i, j) {
f[i][j] = f[i][j] || f[i - 1][j - 1]
}
}
}
}
return f[m][n]
}
(中等)剑指 Offer 20. 表示数值的字符串
请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。
数值(按顺序)可以分成以下几个部分:
- 若干空格
- 一个 小数 或者 整数
- (可选)一个
'e'
或'E'
,后面跟着一个 整数 - 若干空格
小数(按顺序)可以分成以下几个部分:
- (可选)一个符号字符(
'+'
或'-'
) - 下述格式之一:
- 至少一位数字,后面跟着一个点
'.'
- 至少一位数字,后面跟着一个点
'.'
,后面再跟着至少一位数字 - 一个点
'.'
,后面跟着至少一位数字
- 至少一位数字,后面跟着一个点
整数(按顺序)可以分成以下几个部分:
- (可选)一个符号字符(
'+'
或'-'
) - 至少一位数字
部分数值列举如下:
["+100", "5e2", "-123", "3.1416", "-1E-16", "0123"]
部分非数值列举如下:
["12e", "1a3.14", "1.2.3", "+-5", "12e+5.4"]
示例 1:
输入:s = "0"
输出:true
示例 2:
输入:s = "e"
输出:false
示例 3:
输入:s = "."
输出:false
示例 4:
输入:s = " .1 "
输出:true
提示:
1 <= s.length <= 20
s
仅含英文字母(大写和小写),数字(0-9
),加号'+'
,减号'-'
,空格' '
或者点'.'
。
题解:
- C++
方式一:
class Solution {
public:
bool isNumber(string s) {
if (s.empty()) {
return false;
}
s.erase(0, s.find_first_not_of(" "));
s.erase(s.find_last_not_of(" ") + 1);
bool numFlag = false;
bool dotFlag = false;
bool eFlag = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= '0' && s[i] <= '9') {
numFlag = true;
} else if (s[i] == '.' && !dotFlag && !eFlag) {
dotFlag = true;
} else if ((s[i] == 'E' || s[i] == 'e') && !eFlag && numFlag) {
eFlag = true;
numFlag = false;
} else if ((s[i] == '+' || s[i] == '-') && (i == 0 || s[i - 1] == 'E' || s[i - 1] == 'e')) {
} else {
return false;
}
}
return numFlag;
}
};
方式二:
class Solution {
public:
bool isNumber(string s) {
if(s.empty()) {
return false;
}
s.erase(0, s.find_first_not_of(" "));
s.erase(s.find_last_not_of(" ") + 1);
int index = 0;
bool numeric = scanInteger(s, index);
if (s[index] == '.') {
index++;
numeric = scanUnsignedInteger(s, index) || numeric;
}
if (s[index] == 'e' || s[index] == 'E') {
index++;
numeric = scanInteger(s, index) && numeric;
}
return numeric && (index == s.size());
}
private:
bool scanInteger(string& s, int &index) {
if (s[index] == '+' || s[index] == '-') {
index++;
}
return scanUnsignedInteger(s, index);
}
bool scanUnsignedInteger(string& s, int &index) {
int begin = index;
while(s[index] != '\0' && ::isdigit(s[index])) {
index++;
}
return index > begin;
}
};
- Golang
func isNumber(s string) bool {
s = strings.TrimLeft(s, " ")
s = strings.TrimRight(s, " ")
numFlag := false
dotFlag := false
eFlag := false
for i := 0; i < len(s); i++ {
if (s[i] >= '0' && s[i] <= '9') {
numFlag = true
} else if (s[i] == '.' && !dotFlag && !eFlag) {
dotFlag = true
} else if (s[i] == 'e' || s[i] == 'E') && !eFlag && numFlag {
numFlag = false
eFlag = true
} else if (s[i] == '+' || s[i] == '-') && (i == 0 || s[i - 1] == 'e' || s[i - 1] == 'E') {
} else {
return false
}
}
return numFlag
}
(简单)剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数在数组的前半部分,所有偶数在数组的后半部分。
示例:
输入:nums = [1,2,3,4]
输出:[1,3,2,4]
注:[3,1,2,4] 也是正确的答案之一。
提示:
0 <= nums.length <= 50000
0 <= nums[i] <= 10000
题解:
- C++
class Solution {
public:
vector<int> exchange(vector<int>& nums) {
int left = 0, right = nums.size() - 1;
while (left < right) {
if (nums[left] % 2 == 1) {
left++;
continue;
}
if (nums[right] % 2 == 0) {
right--;
continue;
}
swap(nums[left++], nums[right--]);
}
return nums;
}
};
- Golang
func exchange(nums []int) []int {
left, right := 0, len(nums) - 1
for left < right {
if nums[left] % 2 == 1 {
left++
continue
}
if nums[right] % 2 == 0 {
right--
continue
}
nums[left], nums[right] = nums[right], nums[left]
right--
left++
}
return nums
}
(简单)剑指 Offer 22. 链表中倒数第k个节点
输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6
个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6
。这个链表的倒数第 3
个节点是值为 4
的节点。
示例:
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
题解:
- C++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* getKthFromEnd(ListNode* head, int k) {
ListNode* fast = head, *slow = head;
while (fast) {
if (k) {
fast = fast->next;
k--;
continue;
}
fast = fast->next;
slow = slow->next;
}
return slow;
}
};
- Golang
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func getKthFromEnd(head *ListNode, k int) *ListNode {
fast, slow := head, head
for fast != nil {
if k > 0 {
k--
fast = fast.Next
continue
}
fast = fast.Next
slow = slow.Next
}
return slow
}
(简单)剑指 Offer 24. 反转链表
定义一个函数,输入一个链表的头节点,反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
限制:
0 <= 节点个数 <= 5000
题解:
- C++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* pre = nullptr;
ListNode* cur = head;
while (cur) {
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
return pre;
}
};
- Golang
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func reverseList(head *ListNode) *ListNode {
var pre *ListNode
cur := head
for cur != nil {
next := cur.Next
cur.Next = pre
pre = cur
cur = next
}
return pre
}
(简单)剑指 Offer 25. 合并两个排序的链表
输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1:
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
限制:
0 <= 链表长度 <= 1000
题解:
- C++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* preHead = new ListNode(-1);
ListNode* pre = preHead;
while (l1 && l2) {
if (l1->val < l2->val) {
pre->next = l1;
l1 = l1->next;
} else {
pre->next = l2;
l2 = l2->next;
}
pre = pre->next;
}
pre->next = l1 == nullptr ? l2 : l1;
ListNode* r = preHead->next;
delete preHead;
return r;
}
};
- Golang
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
preHead := new(ListNode)
pre := preHead
for l1 != nil && l2 != nil {
if l1.Val < l2.Val {
pre.Next = l1
l1 = l1.Next
} else {
pre.Next = l2
l2 = l2.Next
}
pre = pre.Next
}
if l1 == nil {
pre.Next = l2
} else {
pre.Next = l1
}
return preHead.Next
}
(中等)剑指 Offer 26. 树的子结构
输入两棵二叉树A和B,判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构, 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:
3
/ \
4 5
/ \
1 2
给定的树 B:
4
/
1
返回 true,因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1:
输入:A = [1,2,3], B = [3,1]
输出:false
示例 2:
输入:A = [3,4,5,1,2], B = [4,1]
输出:true
限制:
0 <= 节点个数 <= 10000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSubStructure(TreeNode* A, TreeNode* B) {
bool res = false;
if (A && B){
if (!(res = hasTreeB(A, B))) { // 判断A树是否存在B树
// 如果没有,则判断左子树是否存在B树,以及右子树是否存在B树
res = isSubStructure(A->left, B) || isSubStructure(A->right, B);
}
}
return res;
}
bool hasTreeB(TreeNode* A, TreeNode* B) {
if (B == nullptr) {
return true; //到达最后,没有子节点了
}
if (A == nullptr) {
return false; // A遍历完了,B还没有遍历完,即没找到B树
}
if (A->val != B->val) { //如果A树和B树的值不相等,则返回false
return false;
}
// 继续判断A的左子树是否包含B的右子树
// ..........右...................
return hasTreeB(A->left, B->left) && hasTreeB(A->right, B->right);
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func isSubStructure(A *TreeNode, B *TreeNode) bool {
res := false
if A != nil && B != nil {
res = hasTreeB(A, B)
if !res {
res = isSubStructure(A.Left, B) || isSubStructure(A.Right, B);
}
}
return res
}
func hasTreeB(A , B *TreeNode) bool {
if B == nil {
return true
}
if A == nil {
return false
}
if A.Val != B.Val {
return false
}
return hasTreeB(A.Left, B.Left) && hasTreeB(A.Right, B.Right);
}
(简单)剑指 Offer 27. 二叉树的镜像
请完成一个函数,输入一个二叉树,该函数输出它的镜像。
例如输入:
4
/ \
2 7
/ \ / \
1 3 6 9
镜像输出:
4
/ \
7 2
/ \ / \
9 6 3 1
示例 1:
输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]
限制:
- 0 <= 节点个数 <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* mirrorTree(TreeNode* root) {
if (root == nullptr) {
return nullptr;
}
TreeNode* temp = root->left;
root->left = mirrorTree(root->right);
root->right = mirrorTree(temp);
return root;
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func mirrorTree(root *TreeNode) *TreeNode {
if root == nil {
return root
}
temp := root.Left;
root.Left = mirrorTree(root.Right)
root.Right = mirrorTree(temp)
return root
}
(简单)剑指 Offer 28. 对称的二叉树
请实现一个函数,用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样,那么它是对称的。
例如,二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
示例 1:
输入:root = [1,2,2,3,4,4,3]
输出:true
示例 2:
输入:root = [1,2,2,null,3,null,3]
输出:false
限制:
0 <= 节点个数 <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
return check(root, root);
}
private:
bool check(TreeNode* a, TreeNode* b) {
if (a == nullptr && b == nullptr) {
return true;
}
if (a == nullptr || b == nullptr) {
return false;
}
return a->val == b->val && check(a->left, b->right) && check(a->right, b->left);
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func isSymmetric(root *TreeNode) bool {
return check(root, root)
}
func check(a, b *TreeNode) bool {
if a == nil && b == nil {
return true
}
if a == nil || b == nil {
return false
}
return (a.Val == b.Val) && check(a.Left, b.Right) && check(a.Right, b.Left)
}
(简单)剑指 Offer 29. 顺时针打印矩阵
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1:
输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出:[1,2,3,6,9,8,7,4,5]
示例 2:
输入:matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出:[1,2,3,4,8,12,11,10,9,5,6,7]
限制:
0 <= matrix.length <= 100
0 <= matrix[i].length <= 100
题解:
- C++
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
vector<int> s;
// 矩阵大小异常
if (matrix.size() < 1 || matrix[0].size() < 1) {
return s;
}
int left = 0;
int top = 0;
int right = matrix[0].size() - 1;
int bottom = matrix.size() - 1;
while (left <= right && top <= bottom) {
// 上边: 左 → 右
for (int i = left; i <= right; i++)
s.push_back(matrix[top][i]);
// 右边: 上(第2行)→ 下
for (int i = top + 1; i <= bottom; i++)
s.push_back(matrix[i][right]);
if (left < right && top < bottom) {
// 下边: 右(倒数第2列) → 左(第2列)
for (int i = right - 1; i > left; i--)
s.push_back(matrix[bottom][i]);
// 左边: 下 → 上
for (int i = bottom ; i > top; i--)
s.push_back(matrix[i][left]);
}
left++;
top++;
right--;
bottom--;
}
return s;
}
};
- Golang
func spiralOrder(matrix [][]int) []int {
if len(matrix) < 1 || len(matrix[0]) < 1 {
return []int{}
}
left, top, right, bottom := 0, 0, len(matrix[0]) - 1, len(matrix) - 1
r, index := make([]int, len(matrix) * len(matrix[0])), 0
for left <= right && top <= bottom {
for j := left; j < right; j++ {
r[index] = matrix[top][j]
index++
}
for i := top; i <= bottom; i++ {
r[index] = matrix[i][right]
index++
}
if left < right && top < bottom {
for j := right - 1; j > left; j-- {
r[index] = matrix[bottom][j]
index++
}
for i := bottom; i > top; i-- {
r[index] = matrix[i][left]
index++
}
}
left++
top++
right--
bottom--
}
return r
}
(简单)剑指 Offer 30. 包含min函数的栈
定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中,调用 min、push 及 pop 的时间复杂度都是 O(1)。
示例:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.
提示:
-
- 各函数的调用总次数不超过 20000 次
题解:
- C++
class MinStack {
private:
stack<int> m_stack;
stack<int> m_minStack;
public:
/** initialize your data structure here. */
MinStack() {
// 在栈底压入一个最大整数
m_minStack.push(INT_MAX);
}
void push(int x) {
// x 压入栈
m_stack.push(x);
int min = m_minStack.top();
// x 和 辅助栈顶元素比较,将最小的值压入辅助栈
m_minStack.push(min > x ? x : min);
}
void pop() {
m_stack.pop();
m_minStack.pop();
}
int top() {
return m_stack.top();
}
int min() {
return m_minStack.top();
}
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(x);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->min();
*/
- Golang
type MinStack struct {
stack []int
minStack []int
}
/** initialize your data structure here. */
func Constructor() MinStack {
return MinStack {
stack: []int{},
minStack: []int{math.MaxInt64},
}
}
func (this *MinStack) Push(x int) {
this.stack = append(this.stack, x)
min := this.minStack[len(this.minStack) - 1]
for min > x {
min = x
}
this.minStack = append(this.minStack, min)
}
func (this *MinStack) Pop() {
this.stack = this.stack[:len(this.stack) - 1]
this.minStack = this.minStack[:len(this.minStack) - 1]
}
func (this *MinStack) Top() int {
return this.stack[len(this.stack) - 1]
}
func (this *MinStack) Min() int {
return this.minStack[len(this.minStack) - 1]
}
/**
* Your MinStack object will be instantiated and called as such:
* obj := Constructor();
* obj.Push(x);
* obj.Pop();
* param_3 := obj.Top();
* param_4 := obj.Min();
*/
(中等)剑指 Offer 31. 栈的压入、弹出序列
输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如,序列 {1,2,3,4,5} 是某栈的压栈序列,序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列,但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
示例 1:
输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出:true
解释:我们可以按以下顺序执行:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2:
输入:pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出:false
解释:1 不能在 2 之前弹出。
提示:
0 <= pushed.length == popped.length <= 1000
0 <= pushed[i], popped[i] < 1000
pushed
是popped
的排列。
题解:
- C++
class Solution {
public:
bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
stack<int> s;
for (int i = 0, j = 0; i < pushed.size(); i++) {
// 压入辅助栈
s.push(pushed[i]);
// 当辅助栈顶元素和弹出序列的元素相等时,弹出,不相等继续压
while (!s.empty() && s.top() == popped[j]) {
s.pop();
j++;
}
}
// 所有的元素都和弹出序列匹配,即所有的元素都弹出
return s.empty();
}
};
- Golang
func validateStackSequences(pushed []int, popped []int) bool {
s := make([]int, 0)
for i, j := 0, 0; i < len(pushed); i++ {
s = append(s, pushed[i])
for len(s) > 0 && s[len(s) - 1] == popped[j] {
s = s[:len(s) - 1]
j++
}
}
return len(s) == 0
}
(中等)剑指 Offer 32 - I. 从上到下打印二叉树
从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回:
[3,9,20,15,7]
提示:
节点总数 <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> levelOrder(TreeNode* root) {
if (!root) {
return {};
}
queue<TreeNode*> que;
que.push(root);
vector<int> res;
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
res.push_back(node->val);
if (node->left) {
que.push(node->left);
}
if (node->right) {
que.push(node->right);
}
}
}
return res;
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func levelOrder(root *TreeNode) []int {
if root == nil {
return []int{}
}
queue := []*TreeNode{root}
res := []int{}
for len(queue) > 0 {
q := queue
queue = nil
for _, node := range q {
res = append(res, node.Val)
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
}
return res
}
(简单)剑指 Offer 32 - II. 从上到下打印二叉树 II
从上到下按层打印二叉树,同一层的节点按从左到右的顺序打印,每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回其层次遍历结果:
[
[3],
[9,20],
[15,7]
]
提示:
节点总数 <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
if (!root) {
return {};
}
queue<TreeNode*> que;
que.push(root);
vector<vector<int>> res;
while (!que.empty()) {
int size = que.size();
vector<int> v;
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
v.push_back(node->val);
if (node->left) {
que.push(node->left);
}
if (node->right) {
que.push(node->right);
}
}
res.push_back(v);
}
return res;
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func levelOrder(root *TreeNode) [][]int {
if root == nil {
return [][]int{}
}
que := []*TreeNode{root};
res := make([][]int, 0)
for len(que) > 0 {
q := que
que = nil
v := make([]int, 0)
for _, node := range q {
v = append(v, node.Val)
if node.Left != nil {
que = append(que, node.Left)
}
if node.Right != nil {
que = append(que, node.Right)
}
}
res = append(res, v)
}
return res
}
(中等)剑指 Offer 32 - III. 从上到下打印二叉树 III
请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,第三行再按照从左到右的顺序打印,其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回其层次遍历结果:
[
[3],
[20,9],
[15,7]
]
提示:
节点总数 <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if (!root) {
return res;
}
queue<TreeNode*> que;
que.push(root);
bool leftToRightOrder = true;
while (!que.empty()) {
vector<int> v;
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
v.emplace_back(node->val);
if (node->left) {
que.push(node->left);
}
if (node->right) {
que.push(node->right);
}
}
if (leftToRightOrder) {
res.push_back(v);
} else {
res.push_back(vector<int>(v.rbegin(), v.rend()));
}
leftToRightOrder = !leftToRightOrder;
}
return res;
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func levelOrder(root *TreeNode) [][]int {
res := make([][]int, 0)
if root == nil {
return res
}
queue := []*TreeNode{root};
leftToRightOrder := true
for len(queue) > 0 {
q := queue
queue = nil
v := make([]int, 0)
for _, node := range q {
v = append(v, node.Val)
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
if !leftToRightOrder {
n := len(v)
for i := 0; i < n / 2; i++ {
v[i], v[n - 1 - i] = v[n - 1 - i], v[i]
}
}
res = append(res, v)
leftToRightOrder = !leftToRightOrder
}
return res
}
(中等)剑指 Offer 33. 二叉搜索树的后序遍历序列
输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true
,否则返回 false
。假设输入的数组的任意两个数字都互不相同。
参考以下这颗二叉搜索树:
5
/ \
2 6
/ \
1 3
示例 1:
输入: [1,6,3,2,5]
输出: false
示例 2:
输入: [1,3,2,6,5]
输出: true
提示:
数组长度 <= 1000
题解:
- C++
class Solution {
public:
bool verifyPostorder(vector<int>& postorder) {
return verifyInternal(postorder, 0, postorder.size() - 1);
}
private:
bool verifyInternal(vector<int>& postorder, int i, int j) {
if (i >= j) {
return true;
}
int k = i;
while (postorder[k] < postorder[j]) {
k++;
}
int m = k;
while (postorder[k] > postorder[j]) {
k++;
}
return verifyInternal(postorder, i, m - 1) && verifyInternal(postorder, m, j - 1) && (k == j);
}
};
- Golang
func verifyPostorder(postorder []int) bool {
return verifyInternal(postorder, 0, len(postorder) - 1)
}
func verifyInternal(postorder []int, i, j int) bool {
if i >= j {
return true
}
k := i
for postorder[k] < postorder[j] {
k++
}
m := k
for postorder[k] > postorder[j] {
k++
}
return (k == j) && verifyInternal(postorder, i, m - 1) && verifyInternal(postorder, m, j - 1)
}
(中等)剑指 Offer 34. 二叉树中和为某一值的路径
给你二叉树的根节点 root
和一个整数目标和 targetSum
,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
示例 2:
输入:root = [1,2,3], targetSum = 5
输出:[]
示例 3:
输入:root = [1,2], targetSum = 0
输出:[]
提示:
- 树中节点总数在范围
[0, 5000]
内 -1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000
题解:
- C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> pathSum(TreeNode* root, int target) {
vector<vector<int>> res;
if (!root) {
return res;
}
vector<int> tmp;
std::function<void(TreeNode*, int)> dfs;
dfs = [&res, &tmp, &dfs](TreeNode* root, int target) {
target -= root->val;
tmp.push_back(root->val);
if (!target && !root->left && !root->right) {
res.push_back(tmp);
}
if (root->left) {
dfs(root->left, target);
}
if (root->right) {
dfs(root->right, target);
}
tmp.pop_back();
};
dfs(root, target);
return res;
}
};
- Golang
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func pathSum(root *TreeNode, target int) [][]int {
res := [][]int{}
if root == nil {
return res
}
tmp := []int{}
var dfs func(*TreeNode, int)
dfs = func (root *TreeNode, target int) {
target -= root.Val
tmp = append(tmp, root.Val)
if target == 0 && root.Left == nil && root.Right == nil {
res = append(res, append([]int(nil), tmp...))
}
if root.Left != nil {
dfs(root.Left, target)
}
if root.Right != nil {
dfs(root.Right, target)
}
tmp = tmp[:len(tmp) - 1]
}
dfs(root, target)
return res
}
(中等)剑指 Offer 35. 复杂链表的复制
请实现 copyRandomList
函数,复制一个复杂链表。在复杂链表中,每个节点除了有一个 next
指针指向下一个节点,还有一个 random
指针指向链表中的任意节点或者 null
。
示例 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。
提示:
-10000 <= Node.val <= 10000
Node.random 为空(null)或指向链表中的节点。
节点数目不超过 1000 。
题解:
- C++
/*
// Definition for a Node.
class Node {
public:
int val;
Node* next;
Node* random;
Node(int _val) {
val = _val;
next = NULL;
random = NULL;
}
};
*/
class Solution {
public:
Node* copyRandomList(Node* head) {
if (!head)
return nullptr;
for (Node* node = head; node != nullptr; node = node->next->next) {
Node* nodeNew = new Node(node->val);
nodeNew->next = node->next;
node->next = nodeNew;
}
for (Node* node = head; node != nullptr; node = node->next->next) {
Node* nodeNew = node->next;
nodeNew->random = (node->random != nullptr) ? node->random->next : nullptr;
}
Node* headNew = head->next;
for (Node* node = head; node != nullptr; node = node->next) {
Node* nodeNew = node->next;
node->next = node->next->next;
nodeNew->next = (nodeNew->next != nullptr) ? nodeNew->next->next : nullptr;
}
return headNew;
}
};
- Golang
(中等)剑指 Offer 36. 二叉搜索树与双向链表
输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点,只能调整树中节点指针的指向。
为了让您更好地理解问题,以下面的二叉搜索树为例:
我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表,第一个节点的前驱是最后一个节点,最后一个节点的后继是第一个节点。
下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。
特别地,我们希望可以就地完成转换操作。当转化完成以后,树中节点的左指针需要指向前驱,树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。
题解:
- C++
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node() {}
Node(int _val) {
val = _val;
left = NULL;
right = NULL;
}
Node(int _val, Node* _left, Node* _right) {
val = _val;
left = _left;
right = _right;
}
};
*/
class Solution {
private:
Node* pre, *head; // 定义先前节点和头节点
void dfs(Node* cur) {
if (!cur)
return;
dfs(cur->left);
//pre用于记录双向链表中位于cur左侧的节点,即上一次迭代中的cur,当pre==null时,cur左侧没有节点,即此时cur为双向链表中的头节点
if(pre == nullptr) //最左边的时候就是头节点
head = cur;
else // cur位于头节点右边时,pre是cur的前一个节点
pre->right = cur;
cur->left = pre; //pre是否为null对这句没有影响,且这句放在上面两句if else之前也是可以的。
pre = cur;//pre指向当前的cur
dfs(cur->right);//全部迭代完成后,pre指向双向链表中的尾节点
}
public:
Node* treeToDoublyList(Node* root) {
if(!root)
return nullptr;
dfs(root);
pre->right = head;
head->left = pre;
return head;
}
};
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang
题解:
- C++
- Golang