剑指offer保姆级题解全集—C/C++版
Posted ych9527
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了剑指offer保姆级题解全集—C/C++版相关的知识，希望对你有一定的参考价值。
前言
剑指offer作为经典算法题、在面试中遇到的几率非常之高，赶紧行动起来。
下次学妹，啊呸，面试官，再问你剑指offer直接一番天秀。
数组中重复的数字
找出数组中重复的数字。在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
方法1：
sort排序后，遍历数组，前面的值和后面的值相等即可
时间复杂度：nongn；
空间复杂度：快排需要递归，栈桢消耗 longn
class Solution {
public:
int findRepeatNumber(vector<int>& nums) {
sort(nums.begin(),nums.end());
int count=0;
for(int i=0;i<nums.size()-1;i++)
{
if(nums[i]==nums[i+1])
{
count=nums[i];
break;
}
}
return count;
}
};
方法2：
统计排序、找出统计数组之中，值大于1的选项，然后+1返回
时间复杂度：O(n);
空间复杂度： O(n)；
class Solution {
public:
int findRepeatNumber(vector<int>& nums) {
vector<int> ret(nums.size(),0);
for(auto &e:nums)
{
if(ret[e]!=0)
return e;
ret[e]++;
}
return 0;
}
};
二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
时间复杂度：O(m*n)
空间复杂度：O(1)
class Solution {
public:
bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
if(matrix.size()==0)
return false;
int row=0;
int col=matrix[0].size()-1;
while(row>=0&&row<matrix.size()&&col>=0&&col<matrix[0].size())
{
if(matrix[row][col]>target)
col--;
else if(matrix[row][col]<target)
row++;
else
return true;
}
return false;
}
};
替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
遍历s，遇到空格，则str+=“%20”，其余情况之下，+=s[i]
【注意：先开辟好str的空间，避免发生增容，导致发生拷贝】
时间复杂度:O(n)
空间复杂度:O(n)
class Solution {
public:
string replaceSpace(string s) {
string str;
str.reserve(s.size());
for(int i=0;i<s.size();i++)
{
if(s[i]==' ')
str+="%20";
else
str+=s[i];
}
return str;
}
};
从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
方法1：递归
链表天然具有递归属性
时间复杂度：O(N) 遍历整个链表
空间复杂度： O(N) 栈桢消耗n，返回数组n
class Solution {
public:
void _reversePrint(ListNode* head,vector<int> &ret)
{
if(head==NULL)
return ;
_reversePrint(head->next,ret);
ret.push_back(head->val);
}
vector<int> reversePrint(ListNode* head) {
vector<int> ret;
_reversePrint(head,ret);
return ret;
}
};
方法2：遍历reverse
遍历链表，将所有的内容添加至数组之中
然后将数组逆转
时间复杂度： O(N) 遍历整个链表
空间复杂度：O(N) 返回数组消耗
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
vector<int> ret;
ListNode* cur=head;
while(cur)
{
ret.push_back(cur->val);
cur=cur->next;
}
reverse(ret.begin(),ret.end());
return ret;
}
};
重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
中序之中寻找该根节点的位置，然后在中序之中判断该节点是否还有左右子树
时间复杂度：O(N^2)：需要每次需要在中序之中遍历寻找根节点的位置
空间复杂度：O(N) 开辟N个节点空间、递归深度O(N)
class Solution {
public:
TreeNode* _buildTree(vector<int>& preorder, vector<int>& inorder,int &prev,int &inor_begin,int &inor_end)
{
if(prev>=preorder.size()||inor_begin>inor_end)
return NULL;
TreeNode *root=new TreeNode(preorder[prev]);//构造根节点
int start=inor_begin;
while(start<inor_end)
{
if(inorder[start]==preorder[prev])
break;
start++;
}
int end=start-1;
if(inor_begin<=end)//还有左区间
root->left= _buildTree(preorder,inorder,++prev,inor_begin,end);
else
root->left=NULL;
int begin=start+1;
if(begin<=inor_end)//还有右区间
root->right=_buildTree(preorder,inorder,++prev,begin,inor_end);
else
root->right=NULL;
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
//在前序中找根节点、找到后去中序遍历中找左右子树
int prev=0;
int inor_begin=0;
int inor_end=inorder.size()-1;
return _buildTree(preorder,inorder,prev,inor_begin,inor_end);
}
};
用栈实现两个队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
定义两个栈 -> st1、st2
入数据入到栈st1,当需要出数据的时候判断st2是否为空，不为空则直接从st2之中出
为空则将st1的全部内容倒过来，然后再出数据
class CQueue {
public:
CQueue() {}//自定义类型、自动调用构造函数
void appendTail(int value) {
st1.push(value);
}
int deleteHead() {
if(st2.empty())
{
while(!st1.empty())
{
st2.push(st1.top());
st1.pop();
}
}
if(st2.empty())
return -1;
int val=st2.top();
st2.pop();
return val;
}
stack<int> st1;
stack<int> st2;
};
斐波那契数列
方法1：递归法(超时)
方法2：三指针迭代法（first=1、second=0、third=0）
时间复杂度 ：O(N)
空间复杂度：O(1)
class Solution {
public:
int fib(int n) {
int first=1;
int second=0;
int third=0;
for(int i=0;i<n;i++)
{
third=(first+second)%1000000007;
first=second;
second=third;
}
return third;
}
};
青蛙跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
将题目转换一下就是： 1 1 2 3 5 斐波那契数列的斐波那契数列
class Solution {
public:
int numWays(int n) {
// 1 1 2 3 5 斐波那契数列
int first=0;
int second=1;
int third=1;
for(int i=0;i<n;i++)
{
third=(second+first)%1000000007;
first=second;
second=third;
}
return third;
}
};
旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
class Solution {
public:
int minArray(vector<int>& numbers) {
int left=0;
int right=numbers.size()-1;
while(left<right)
{
int mid=left+(right-left)/2;
if(numbers[mid]>numbers[right])
left=mid+1;
else if(numbers[mid]<numbers[right])
right=mid;
else//相等时
right--;
}
return numbers[left];
}
};
矩阵的路径
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
深度搜索、回溯法：遍历搜索二维数组，找到第一个头节点之后，传入递归搜索函数，往四个方向进行搜索
机器人运动范围
地上有一个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。请问该机器人能够到达多少个格子？
机器人坐标统计：sum=i%10+i/10+j%10+j/10;（n、m都是大于小101的，即i和j最高是两位数、为横坐标、j为纵坐标）
要想到达一个格子：那么 当前坐标和sum<=k&&有方向可以过来
因此可以建立一个二维数组、全部初始化为false，（0,0,）->true
得到转移方程 dp[i][j]=(dp[i-1] [j]||dp[i+1] [j]|| dp[i] [j-1] || dp[i] [j+1])&&sum<=k
又是从左往右、从上之下进行遍历，因此只需要判断左边和上边的格子是否能够过来即可
class Solution {
public:
int movingCount(int m, int n, int k) {
vector<vector<bool>>ret(m,vector<bool>(n,false));
ret[0][0]=true;
int count=1;
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
int sum=i%10+i/10+j%10+j/10;//统计坐标和
//K满足条件，还需要判断四周是否有可以过来的格子
if(((i>0&&ret[i-1][j])||(j>0&&ret[i][j-1]))&&sum<=k)//判断是否可以从上面或者左边过来&&sum<=k
{
ret[i][j]=true;
count++;
}
}
}
return count;
}
};
空间优化：
由上述可知，当前坐标只与上边和左边的格子有关系，因此可以用一个滚动数组来进行优化
class Solution {
public:
int movingCount(int m, int n, int k) {
vector<bool> ret(n,false);
ret[0]=true;
int count=1;
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
if(i==0&&j==0)
continue;
int sum=i%10+i/10+j%10+j/10;//坐标和
if(sum<=k&&((j>0&&ret[j-1])||ret[j]))
{
ret[j]=true;
count++;
}
else
ret[j]=false;//滚动数组、当sum不满足条件时，需要重新赋值
}
}
return count;
}
};
回溯法：
class Solution {
public:
void _movingCount(vector<vector<bool>> &ret,int m, int n, int k,int &count)
{
if(m>=ret.size()||n>=ret[0].size())//坐标越界
return ;
if(ret[m][n]==true&&(m!=0||n!=0))
return;
int sum=m%10+m/10+n%10+n/10;//坐标和
if(sum>k)//当前肯定进不来
return;
if(sum<=k&&((m>0&&ret[m-1][n])||(n>0&&ret[m][n-1])))
{
ret[m][n]=true;
count++;
}
//往右下走
_movingCount(ret,m,n+1,k,count);
_movingCount(ret,m+1,n,k,count);
}
int movingCount(int m, int n, int k) {
vector<vector<bool>> ret(m,vector<bool>(n,false));
ret[0][0]=true;
int count=1;
_movingCount(ret,0,0,k,count);
return count;
}
};
减绳子
给你一根长度为 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。
题目链接
任何一个大于4的自然数都可分解成2、3的组合 -> 要想乘积最大就需要3的数量最多
class Solution {
public:
int cuttingRope(int n) {
//最少分成2端段
if(n==2)
return 1;
if(n==3)
return 2;
int count=1;
while(n>4)//小于5的数不可以被分解为2和3
{
count*=3;
n-=3;
}
if(n!=0)
count*=n;
return count;
}
};
剪绳子 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。
题目链接
和上题的解题思路是一样的，不过需要注意返回值越界的问题
class Solution {
public:
int cuttingRope(int n) {
//最少分成2端段
if(n==2)
return 1;
if(n==3)
return 2;
long long count=1;//用 longlong防止越界
while(n>4)//小于5的数不可以被分解为2和3
{
count*=3;
n-=3;
count%=1000000007;
}
if(n!=0)
count*=n;
return (int)(count%1000000007);//返回值结果再取余、强转
}
};
二进制中1的个数
请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
题目链接
n&(n-1) -> 每次减少一个1
class Solution {
public:
int hammingWeight(uint32_t n) {
int count=0;
while(n)
{
n&=(n-1);
count++;
}
return count;
}
};
数值的整数次方
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^n）。不得使用库函数，同时不需要考虑大数问题。
题目链接
利用大幂数计算
时间复杂度：O(logn）每次指数减少一半
class Solution {
public:
double myPow(double x, int n) {
long long index=n;//防止n转正数的时候越界
if(n<0)
{
x=1/x;
index*=-1;;
}
double ret=1;
while(index)
{
if(index&1==1)
ret*=x;
//指数右移动一位，缩小两倍 -> 基数^2
index>>=1;
x*=x;
}
return ret;
}
};
打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
题目链接
由题可知：数字是从 1 -> pow(10,n)-1;
class Solution {
public:
vector<int> printNumbers(int n) {
vector<int> ret(pow(10,n)-1);
for(int i=1;i<pow(10,n);i++)
{
ret[i-1]=i;
}
return ret;
}
};
删除链表的节点
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。
题目链接
定义两个前后两个指针，遍历链表，找到后断开点前链接
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
if(head==NULL)
return head;
if(head->val==val)//头结点即是
return head->next;
ListNode *prev=NULL;
ListNode *cur=head;
while(cur)
{
if(cur->val==val)
prev->next=cur->next;
prev=cur;
cur=cur->next;
}
return head;
}
};
表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）
题目链接
字符串分为：
整数 . 小数
e出现在整数部分、并且e后面不能有小数点、并且e后面可以跟一个符号、并且e后面必须有数字
class Solution {
public:
bool isNumber(string s) {
//一个数 = 整数 + 小数
// 先整数部分进行操作 -> 去除前导空格、去除符号
//去除完毕之后、判断是否有整数部分 -> 如果遇到点，则需要判断后面是否有数字(现在还是去除前缀阶段)
//前缀处理完毕，来到后序的处理
//如果遇到点，判断是第几次出现&&点的前面不能出现e
//如果遇到e，e后面可以有一个符号位，并且符号位后面必须有一位数字
int sub=0;
int size=s.size();
while(sub<size&&s[sub]==' ')
{
sub++;//去除前缀空格
}
if(sub<size&&(s[sub]=='+'||s[sub]=='-'))
sub++;//去除符号
//上述过程、前缀整数部分处理完毕
int flag=0;//记录点的个数
if(sub<size&&s[sub]=='.')
{
sub++;
flag=1;
}
if(flag==1&&(sub>=size||(!(s[sub]>='0'&&s[sub]<='9'))))
return false;//.后面没有数字
int _e=0;//记录e的出现次数、
if(sub>=size||s[sub]=='e'||s[sub]=='E')
return false;//e不能出现在前面
while(sub<size)
{
if(s[sub]=='.')
{
if(flag>0)//多次出现
return false;
if(_e!=0)//前面出现了e
return false;
else
flag++;
}
else if(s[sub]=='e'||s[sub]=='E')//出现e
{
if(_e>0)//只可出现一次
return false;
if(++sub>=size)//e后面必须由数字
return false;
if(s[sub]=='+'||s[sub]=='-')
sub++;//去除符号位
if(sub>=size||(!(s[sub]>='0'&&s[sub]<='9')))
return false;//不是数字
_e++;
}
else if(s[sub]==' ')//遇到末端空格
{
while(sub<size)
{
if(s[sub]==' ')
sub++;
else
break;
}
if(sub<size)
return false;//遇到空格并不是结尾
else
return true;
}
else
{
if(!(s[sub]>='0'&&s[sub]<='9'))
return false;//遇到的不是数字
}
sub++;//下标后移
}
return true;
}
};
调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
题目链接
利用快排之中的双指法，进行交换
class Solution {
public:
vector<int> exchange(vector<int>& nums) {
int left=0;
int right=nums.size()-1;
while(left<right)
{
while(left<right&&nums[right]%2==0)
right--;
while(left<right&&nums[left]%2==1)
left++;
if(left<right)
swap(nums[left],nums[right]);
}
return nums;
}
};
链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
题目链接
快慢指针：快指针先走k步，然后慢指针再出发，快指针为空时，就是倒数第K个节点
class Solution {
public:
ListNode* getKthFromEnd(ListNode* head, int k) {
if(head==NULL)
return head;
ListNode *cur=head;
ListNode *next=head;
while(k)
{
next=next->next;
k--;
}
while(next)
{
cur=cur->next;
next=next->next;
}
return cur;
}
};
反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
递归法
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(head==NULL||head->next==NULL)
return head;
ListNode *newhead=reverseList(head->next);
head->next->next=head;
head->next=NULL;
return newhead;
}
};
迭代法
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(head==NULL||head->next==NULL)
return head;
ListNode* prev=NULL;
ListNode* cur=head;
ListNode* next=cur->next;
while(cur)
{
cur->next=prev;
prev=cur;
cur=next;
if(next)
next=next->next;
}
return prev;
}
};
合并两个排序链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
题目链接
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode *cur1=l1;
ListNode *cur2=l2;
ListNode *newhead=new ListNode;
ListNode *ret=newhead;
while(cur1&&cur2)
{
if(cur1->val<cur2->val)
{
newhead->next=cur1;
cur1=cur1->next;
}
else
{
newhead->next=cur2;
cur2=cur2->next;
}
newhead=newhead->next;
}
if(cur1)
newhead->next=cur1;
else
newhead->next=cur2;
return ret->next;
}
};
树的子结构
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)，B是A的子结构， 即 A中有出现和B相同的结构和节点值。
此处需要连个个递归，一个递归遍历树A，以树A任意一个节点为根节，判断是否与树B相等。 ->递归条件，当树B为空时，返回false，题目规定空树不是任何树的子树。
当A为空时，返回false，表示当前的树A已经走完了，但是还没有找到对应B的子结构，此时说明B不是A的子结构。
另外一个递归则判断，以当前的A的一个节点为根节点的树，是否和树B相等
这里的递归出口是，如果B树不为空，A树为空，说明A中没有B的节点，返回false。
如果B树为空，说明全部找到了返回false。
最后的返回是，左&&右子&&当前节点对应的值是否相等
class Solution {
public:
bool _isSubStructure(TreeNode *A,TreeNode*B)
{
if(A==NULL&&B!=NULL)
return false;
if(B==NULL)
return true;
if(A->val!=B->val)
return false;
return _isSubStructure(A->left,B->left)&&_isSubStructure(A->right,B->right);
}
bool isSubStructure(TreeNode* A, TreeNode* B) {
if(A==NULL||B==NULL)//遍历完了，还未找到对应结构
return false;
if(_isSubStructure(A,B))//如果有找到的
return true;
return isSubStructure(A->left,B)||isSubStructure(A->right,B);//递归遍历
}
};
二叉树的镜像
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
class Solution {
public:
void _mirrorTree(TreeNode *root)
{
if(root==NULL)
return ;
swap(root->left,root->right);
_mirrorTree(root->left);
_mirrorTree(root->right);
}
TreeNode* mirrorTree(TreeNode* root) {
_mirrorTree(root);
return root;
}
};
对称的二叉树
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
class Solution {
public:
bool _isSymmetric(TreeNode* root1,TreeNode* root2)
{
if(root1==NULL&&root2==NULL)
return true;
if(root1==NULL||root2==NULL)//其中一个为空
return false;
return
(root1->val==root2->val)&&
_isSymmetric(root1->left,root2->right)&&
_isSymmetric(root1->right,root2->left);
}
bool isSymmetric(TreeNode* root) {
if(root==NULL)
return true;
return _isSymmetric(root->left,root->right);
}
};
顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
vector<int> ret;
if(matrix.size()==0)
return ret;
int left=0;
int right=matrix[0].size()-1;
int up=0;
int down=matrix.size()-1;
while(left<=right||up<=down)
{
while(up<=down)//从左至右
{
for(int i=left;i<=right;i++ )
{
ret.push_back(matrix[up][i]);
}
up++;
break;
}
while(left<=right)//从上之下
{
for(int i=up;i<=down;i++)
{
ret.push_back(matrix[i][right]);
}
right--;
break;
}
while(up<=down)//从右往左
{
for(int i=right;i>=left;i--)
{
ret.push_back(matrix[down][i]);
}
down--;
break;
}
while(left<=right)//从下至上
{
for(int i=down;i>=up;i--)
{
ret.push_back(matrix[i][left]);
}
left++;
break;
}
}
return ret;
}
};
包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。
class MinStack {
public:
/** initialize your data structure here. */
MinStack() {
//自动调用自定义成员的构造函数
}
void push(int x) {
st1.push(x);
if(st2.empty()||x<=st2.top())
st2.push(x);
}
void pop() {
if(st1.top()==st2.top())
st2.pop();
st1.pop();
}
int top() {
return st1.top();
}
int min() {
return st2.top();
}
stack<int> st1;
stack<int> st2;
};
栈的压入弹出顺序
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。题目链接
class Solution {
public:
bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
stack<int> st;
int sub1=0;
int sub2=0;
while(sub1<pushed.size())
{
st.push(pushed[sub1++]);
while(!st.empty()&&st.top()==popped[sub2])
{
sub2++;
st.pop();
}
}
if(st.empty())
return true;
return false;
}
};
从上之下打印二叉树
给定一个队列和一个一维数组，将不为空的节点依次入队，取出来的时候再将对应的值填入一维数组之中
class Solution {
public:
vector<int> levelOrder(TreeNode* root) {
vector<int> ret;
queue<TreeNode*>q;
if(root)
q.push(root);
while(!q.empty())
{
TreeNode* node=q.front();
q.pop();
ret.push_back(node->val);
if(node->left)
q.push(node->left);
if(node->right)
q.push(node->right);
}
return ret;
}
};
从上之下打印二叉树||
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
利用队列保存节点的同时，给定一个变量，保存每一层节点的数目
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ret;
queue<TreeNode*> q;
if(root)
q.push(root);
int count=1;
vector<int> temp;
while(!q.empty())
{
vector<int> temp;
while(count--)//将当前层节点全部取出来
{
TreeNode* node=q.front();
q.pop();
temp.push_back(node->val);
if(node->left)
q.push(node->left);
if(node->right)
q.push(node->right);
}
ret.push_back(temp);
temp.clear();
count=q.size();//更新下一层节点的数
}
return ret;
}
};
从上至下打印二叉树|||
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
本题和上题本质上是一样的，只需要再给定一个变量，如果当前是奇数层，将当前层的数组逆转一下，再插入至返回数组中即可
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ret;
queue<TreeNode*> q;
if(root)
q.push(root);
int count=1;
int flag=0;
vector<int> temp;
while(!q.empty())
{
vector<int> temp;
while(count--)//将当前层节点全部取出来
{
TreeNode* node=q.front();
q.pop();
temp.push_back(node->val);
if(node->left)
q.push(node->left);
if(node->right)
q.push(node->right);
}
if(flag%2==1)//为奇数则逆转
reverse(temp.begin(),temp.end());
ret.push_back(temp);
temp.clear();
count=q.size();//更新下一层节点的数
flag++;
}
return ret;
}
};
二叉树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。题目链接
class Solution {
public:
bool _verifyPostorder(vector<int>&postorder,int begin,int end)
{
if(begin>=end)//此时表明没有区间可以划分了 -> 返回true
return true;
int start=end;
for(int i=begin;i<end;i++)
{
if(postorder[i]>postorder[end])
{
start=i;//得到右子树区间的起点
break;
}
}
for(int i=start+1;i<end;i++)
{
if(postorder[i]<postorder[end])//右子树全部大于根
return false;
}
return
_verifyPostorder(postorder,begin,start-1)&&
_verifyPostorder(postorder,start,end-1);
}
bool verifyPostorder(vector<int>& postorder) {
return _verifyPostorder(postorder,0,postorder.size()-1);
}
};
二叉树中和为某一值的路径
输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。题目链接
class Solution {
public:
void _pathSum(TreeNode*root,int target,vector<vector<int>>&ret,vector<int>&temp,int sum)
{
if(root==nullptr)
return ;
temp.push_back(root->val);//保存当前节点
sum+=root->val;//当齐前路径和
if(sum==target&&root->left==nullptr&&root->right==nullptr)//找到了一条路径
ret.push_back(temp);
_pathSum(root->left,target,ret,temp,sum);
_pathSum(root->right,target,ret,temp,sum);
temp.pop_back();//回溯,sum是临时变量，不需要回溯
}
vector<vector<int>> pathSum(TreeNode* root, int target) {
vector<vector<int>>ret;
vector<int>temp;
_pathSum(root,target,ret,temp,0);
return ret;
}
};
复杂链表的赋值
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。题目链接
方法1：
class Solution {
public:
Node* copyRandomList(Node* head) {
if(head==NULL)
return NULL;
Node *newhead=new Node(head->val);//新链表的头
//两个链表的临时头
Node *tnewhead=newhead;
Node *thead=head->next;
while(thead)//创建新链表
{
tnewhead->next=new Node(thead->val);
thead=thead->next;
tnewhead=tnewhead->next;
}
//至此新链表已经被完全创建出来了、接下来便是填入随机指针
//回到起始位置
tnewhead=newhead;
thead=head;
//寻找相对位置
while(thead)
{
if(thead->random==NULL)//为空指针
tnewhead->random=NULL;
else//不为空指针
{
//从起始位置起
Node *temph=head;
Node *tempn=newhead;
while(temph !=thead->random)
{
temph=temph->next;
tempn=tempn->next;
}
//此时通过随机位置，找到了对应的random指针
tnewhead->random=tempn;
}
thead=thead->next;
tnewhead=tnewhead->next;
}
return newhead;
}
};
方法2：
利用map进行解题
class Solution {
public:
Node* copyRandomList(Node* head) {
if(!head)
return nullptr;
map<Node*,Node*> list;
Node *newhead=head;
//构造map
while(newhead)//构造新旧链表的map
{
Node *cur=new Node(newhead->val);
list.insert(make_pair(newhead,cur));//将节点插入map之中
newhead=newhead->next;
}
//从map之中将拷贝的链表取出来
newhead=head;
Node *ret_node=new Node(0);
Node *ret=ret_node;
while(newhead)
{
ret_node->next=list[newhead];//将新链表链接起来
ret_node=ret_node->next;
//填入对应的random
if(newhead->random==NULL)
ret_node->random=NULL;
else
ret_node->random=list[newhead->random];
//更新位置
newhead=newhead->next;
}
return ret->next;
}
};
二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。题目链接
class Solution {
public:
void _treeToDoublyList(Node* root,Node* &prev)
{
if(root==NULL)
return;
_treeToDoublyList(root->left,prev);
if(prev!=NULL)
prev->right=root;
root->left=prev;
prev=root;//保存备份
_treeToDoublyList(root->right,prev);
}
Node* treeToDoublyList(Node* root) {
Node *head_left=root;
Node *head_right=root;
Node *prev=NULL;
if(root==NULL)
return root;
while(head_left->left!=NULL)//找到最小节点
{
head_left=head_left->left;
}
while(head_right->right!=NULL)//找到最大节点
{
head_right=head_right->right;
}
_treeToDoublyList(root,prev);
head_left->left=head_right;//左指向右
head_right->right=head_left;//右指向左
return head_left;
}
};
字符串的排列序列
输入一个字符串，打印出该字符串中字符的所有排列。你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
class Solution {
public:
void _permutation(string&s,vector<string>&ret,string &temp,vector<bool>&flag)
{
if(temp.size()==s.size())
{
ret.push_back(temp);
return;
}
for(int i=0;i<s.size();i++)
{
if(i-1>=0&&s[i]==s[i-1]&&flag[i-1]==true)//当前节点和前面节点相同，且前面的已经使用过了
continue;
if(flag[i]==false)//已经用过了
continue;
temp+=s[i];
flag[i]=false;//进行标记
_permutation(s,ret,temp,flag);
//回溯
flag[i]=true;
temp.pop_back();
}
}
vector<string> permutation(string s) {
vector<string>ret;
vector<bool>flag(s.size(),true);//标记数组
string temp;
sort(s.begin(),s.end());
_permutation(s,ret,temp,flag);
return ret;
}
};
数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。你可以假设数组是非空的，并且给定的数组总是存在多数元素。
本题采用摩尔投票法：即用一个变量记录当前数字，获得的票数。遇到相同的则票数+1，不同的票数-1，当票数等于0的时候，更换数字
class Solution {
public:
int majorityElement(vector<int>& nums) {
int num=nums[0];
int count=0;
for(auto&e:nums)
{
if(count==0)
{
count=1;
num=e;
}
else
{
if(num==e)
count++;
else
count--;
}
}
return num;
}
};
最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
top K问题，找K个最小的数，建立一个K的大堆
class Solution {
public:
vector<int> getLeastNumbers(vector<int>& arr, int k) {
vector<int> ret;
if(k==0)
return ret;
priority_queue<int,vector<int>,less<int>> heap;//建大堆,less为大堆
for(auto&e:arr)
{
if(heap.size()<k)//小于K个直接入堆
heap.push(e);
else
{
if(e<heap.top())
{
heap.pop();
heap.push(e);
}
}
}
while(!heap.empty())
{
ret.push_back(heap.top());
heap.pop();
}
return ret;
}
};
数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
解法：
构建一个大堆，一个小堆。
小堆保存较大的那一半，堆顶的元素，是较大元素中的最小的一个
大堆保存较小的那一半，堆顶的元素，是较小元素中的最大的一个
同时还得保证，两个堆的元素相差不超过1，这样才能保证，两个堆将数据平分
注意点：
在元素入小堆的时候，需要判断当期元素是否大于大堆的堆顶，如果小于则和大堆堆顶进行“交换”
在元素入大堆的时候，需要判断当前元素是否小于小堆的堆顶，如果大于，则和小堆堆顶进行"交换"
-> 这两个判断保证了，将数组中元素平分，且小堆里面的所有元素大于大堆内的所有元素
class MedianFinder {
public:
/** initialize your data structure here. */
MedianFinder() {
}
void addNum(int num) {
if(max_heap.empty())//先入大堆
max_heap.push(num);
else
{
if(min_heap.size()>max_heap.size())//小堆元素多、入大堆
{
if(num>min_heap.top())//大于小堆的堆顶元素
{
//将新来的元素与小堆顶交换
int temp=min_heap.top();
min_heap.pop();
min_heap.push(num);
//将小堆顶的元素取下来放入大堆
max_heap.push(temp);
}
else//直接放入大堆
max_heap.push(num);
}
else if(min_heap.size()<max_heap.size())//大堆元素多,入小堆
{
if(num<max_heap.top())//新来的元素小于大堆堆顶的元素
{
//将新来的元素与大碓顶交换
int temp=max_heap.top();
max_heap.pop();
max_heap.push(num);
//将大堆顶拿下的元素放入小堆
min_heap.push(temp);
}
else//直接入小堆
min_heap.push(num);
}
else//两堆元素一样多
{
if(num>max_heap.top())//小堆保存较大的那一半
min_heap.push(num);
else
max_heap.push(num);
}
}
}
double findMedian() {
if(min_heap.size()==max_heap.size())//各取一个
{
return min_heap.top()/2+max_heap.top()/2;
}
else//取一个即可
{
//谁多取谁
if(min_heap.size()>max_heap.size())
return min_heap.top();
else
return max_heap.top();
}
}
priority_queue<double,vector<double>,greater<double>> min_heap;//小堆
priority_queue<double,vector<double>,less<double>> max_heap;//大堆
};
简化写法：
当大小堆元素数量相等时，将元素插入大堆，然后将大堆顶的元素取出来，插入小堆 ->保证了小堆了元素比大堆大
当大小对元素数量不相等时，将元素插入小堆，然后将小堆顶的元素取出来，插入大堆 ->保证了大堆的所有元素比小堆小
class MedianFinder {
public:
/** initialize your data structure here. */
MedianFinder()
{}
void addNum(int num) {
if(min_heap.size()==max_heap.size())
{
max_heap.push(num);
int temp=max_heap.top();
max_heap.pop();
min_heap.push(temp);
}
else
{
min_heap.push(num);
int temp=min_heap.top();
min_heap.pop();
max_heap.push(temp);
}
}
double findMedian() {
if(min_heap.size()==max_heap.size())
return min_heap.top()/2+max_heap.top()/2;
else
return min_heap.size()>max_heap.size()?min_heap.top():max_heap.top();
}
priority_queue<double,vector<double>,greater<double>> min_heap;//小堆
priority_queue<double,vector<double>,less<double>> max_heap;//大堆
};
连续子数组的最大和
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值，要求时间复杂度为O(n)。
判断当前数对后面的数是否有"正贡献"，如果有则加到后面的数上面，如果没有则不加
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int max=nums[0];
int size=nums.size();
for(int i=0;i<size-1;i++)
{
if(nums[i]>0)//对后面的数有正贡献
nums[i+1]+=nums[i];
max=fmax(max,nums[i+1]);
}
return max;
}
};
把数组排成最小数
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
解法：
将字符串转成数组，然后写一个仿函数自定义比较负责，利用sort进行排序即可
规则：s1+s2与s2+s1进行比较
-> 两个字符串放在前后的位置，不同的放置方法得到的最终结果的大小是不一样的
->将数组转换成字符数组，然后再进行比较，即可得到最终的排列·
struct Less
{
bool operator()(string s1,string s2)
{
return s1+s2<s2+s1;
}
};
class Solution {
public:
string minNumber(vector<int>& nums) {
vector<string>arr;
for(auto&e:nums)
arr.push_back(to_string(e));
sort(arr.begin(),arr.end(),Less());
string ret;
for(auto&e:arr)
{
ret+=e;
}
return ret;
}
};
把数字翻译成字符串
给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。
解法：
1.将数组转成字符串->方便取数字
2.设dp[i]表示取第i为数字时构成的种类
3.很显然，当i-1与i构成的数字小于25的时候，和前面的构成一种方法，拆开也是一种方法 -> 转移方程：
当和前面的数字构成的数小于25时 -> dp[i]=dp[i-1]+dp[i-2]
否则 dp[i]=dp[i-1]
class Solution {
public:
int translateNum(int num) {
string str=to_string(num);
vector<int>dp(str.size()+1,0);
//dp[i]表示到数字的第i位时，解法的种类
dp[0]=1;
dp[1]=1;//只有一个字符时的翻译种类为1种
for(int i=1;i<str.size();i++)
{
string temp;
temp+=str[i-1];
temp+=str[i];
int nums=stoi(temp);
if(str[i-1]!='0'&&nums<=25)//前导不为0
dp[i+1]=dp[i]+dp[i-1];
else
dp[i+1]=dp[i];
}
return dp[str.size()];
}
};
礼物的最大价值
在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？
从左上角出发 -> 右下角可以拿到的最大价值的礼物
设dp[i][j] 表示在i行j列时能拿到的礼物 、又当前格子只能由左边和上边过来 -> dp[i][j]+=fmax(dp[i-1][j],dp[i][j-1])
位于第一行或者第一列的时候，只能由左边来，或者只能由上边来
class Solution {
public:
int maxValue(vector<vector<int>>& grid) {
int row=grid.size();
int col=grid[0].size();
for(int i=0;i<row;i++)
{
for(int j=0;j<col;j++)
{
if(i==0||j==0)
{
if(i!=0)//第一列
以上是关于剑指offer保姆级题解全集—C/C++版的主要内容，如果未能解决你的问题，请参考以下文章
剑指 Offer（第 2 版）完整题解笔记 & C++代码实现（LeetCode版）
《剑指Offer：专项突破版》 - 数组部分 JavaScript 题解