-
1.二叉树的深度
时间限制:1秒 空间限制:32768K 热度指数:98813
题目描述
输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。
解题思路:
- 如果树只有一个根节点,深度为1
- 如果树只有左子树,那么树的深度为左子树的深度加1
- 如果树只有右子树,那么树的深度为右子树的深度加1
- 如果左右子树都存在,就选择深度较大的加1
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if(NULL == pRoot)
return NULL;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
return (left > right) ? (left+1) : (right+1);
}
};
2.平衡二叉树
时间限制:1秒 空间限制:32768K 热度指数:121509
题目描述输入一棵二叉树,判断该二叉树是否是平衡二叉树。
解题思路:
思路一:需要重复遍历节点多次的解法,简单但是效率不高
- 在遍历树的每个节点的时候,调用上一题我们写出的TreeDepth得到它的左右子树的深度
- 然后比较左右子树的深度之差是否超过1
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if(NULL == pRoot)
return NULaL;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
return (left > right) ? (left+1) : (right+1);
}
bool IsBalanced_Solution(TreeNode* pRoot) {
if(pRoot == NULL)
return true;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
int depth = left - right;
if(depth >1 || depth < -1)
return false;
return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
}
};
思路二:每个节点只遍历一次的节点
- 从根节点开始遍历的话,就会和上一种方法一样,下层节点会遍历多次
- 从下往上遍历就只会遍历一次了,这种方法可以采用树的后序遍历
- 在遍历每个节点之前我们已经遍历了它的左右子树,并且记得记录深度
- 然后根据左右子节点的深度判断它是不是平衡的,并可以得到当前节点的深度
- 最后遍历到树的根节点的时候,也就判断了整棵二叉树是不是平衡树
class Solution {
public:
bool IsBalanced_Solution(TreeNode* pRoot) {
int depth = 0;
return IsBalanced(pRoot, &depth);
}
bool IsBalanced(TreeNode* pRoot, int* depth)
{
if(NULL == pRoot)
{
*depth = 0;
return true;
}
int left, right;
if(IsBalanced(pRoot->left, &left) && IsBalanced(pRoot->right, &right))
{
int depthdiff = left - right;
if(depthdiff <= 1 && depthdiff >= -1)
{
*depth = 1 + (left > right ? left : right);
return true;
}
}
return false;
}
};
3.数组中只出现一次的数字
时间限制:1秒 空间限制:32768K 热度指数:142221
本题知识点: 数组
题目描述
一个整型数组里除了两个数字之外,其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
解题思路:
- 以数组{2, 4, 3, 6, 3, 2, 5, 5}为例,当我们对数组的每个数字进行异或运算,得到的结果为0010
- 然后我们可以看到倒数第二位为1,所以我们根据数字的倒数第二位是不是1进行分组
- 倒数第二位为1的子数组是{2, 3, 6, 3, 2};倒数第二位不是1的子数组是{4, 5, 5}
- 然后只要分别对这两个子数组求异或运算,就可以分别找出两个子数组中只出现一次的数字
- 说明一下:得到的结果至少有一个比特位是1,那么我们只要选择比特位上的第一个1为基准即可
class Solution {
public:
void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
int len = data.size();
if(len < 2)
return;
int resultXOR = 0; //标记数组的异或结果
for(int i = 0; i < len; i++){
resultXOR ^= data[i]; //1.得到了数组的异或结果,该结果数字二级制表示中至少有一个为1
}
//2. 找到该结果数字中最右边的1的位置
unsigned int indexOf1 = FindFirstBitIs1(resultXOR);
//3. 以1的位置进行划分子数组
*num1 = *num2 = 0;
for(int j = 0; j < data.size(); j++){
if(IsBit1(data[j], indexOf1))
*num1 ^= data[j];
else
*num2 ^= data[j];
}
}
//找结果数字的二进制表示中最右边的1的位置
unsigned int FindFirstBitIs1(int num){
int indexBit = 0;
while(((num & 1) == 0) && (indexBit < 8*sizeof(int))){
num = num >> 1;
indexBit++;
}
return indexBit;
}
//判断每个数字的二进制表示中在1的位置是否为1
bool IsBit1(int num, unsigned int indexBit){
num = num >> indexBit;
return (num&1);
}
};
4.和为S的两个数字
时间限制:1秒 空间限制:32768K 热度指数:130233
题目描述
输入一个递增排序的数组和一个数字S,在数组中查找两个数,使得他们的和正好是S,如果有多对数字的和等于S,输出两个数的乘积最小的。
输出描述:
对应每个测试案例,输出两个数,小的先输出。
解题思路:{1,2,4,7,11,15},输出15
思路一:时间复杂度为O(n2),看到题的直观想法
- 从数组中的1开始,向后和每个数字相加,如果不等于输出的和,就和下一个数字相加,直到有等于输出的和15为止,如果没有遍历完数组结束
- 然后从2开始,重复和1一样的操作
- 然后比较所有和为S的序列的乘积,找出最小的乘积
思路二:时间复杂度为O(n)
- 我们可以定义两个指针,第一个指针指向数组的第一个数字,第二个指针指向数组的最后一个数字
- 然后看这两个数字的和是否等于15
- 如果等于,就记录下来;
- 如果小于15,就让第一个指针向后移动,相加看是否等于15,如果大于就让第二个指针向前移动;如果等于记录;如果小于,就让第一个指针继续向后移动
- 如果大于15,就让第二个指针向前移动,重复上述动作即可
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
int len = array.size();
vector<int> result;
if(len <= 1)
return result;
int left = 0;
int right = len-1;
while(left < right)
{
int curSum = array[left] + array[right];
if(curSum == sum)
{
result.push_back(array[left]);
result.push_back(array[right]);
break;
}
else if(curSum < sum)
++left;
else
--right;
}
return result;
}
};
5.和为S的连续正序列
时间限制:1秒 空间限制:32768K 热度指数:141210
题目描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序,序列间按照开始数字从小到大的顺序
解题思路:
- 有了上一个题目的思路,此处我们也可以考虑用两个数来分别表示序列的最小值和最大值
- 我们以求和为9为例,small初始化为1,big初始化为2.此时small和big组成的序列为{1,2},序列的和为3,小于9; 所以我们下一步就是让序列包含更多的数字,将big增加到3,序列为{1,2,3},和为6,仍然小于9;继续增大big,序列为{1,2,3,4},和为10,大于9,此时small增大,也就是相当于去掉了1,序列为{2,3,4},和为9
- 接下来继续增大big的值,重复上述过程即可,可以找到第二个序列{4,5}
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int>> result;
if(sum < 3)
return result;
int small = 1;
int big = 2;
int curSum = 3;
int middle = (1 + sum)>>1;
while(small < middle)
{
if(curSum == sum)
{
vector<int> temp;
for(int i = small; i <= big; ++i)
{
temp.push_back(i);
}
result.push_back(temp);
}
while(curSum > sum && small < middle)
{
curSum -= small;
small++;
if(curSum == sum)
{
vector<int> temp;
for(int i = small; i <= big; ++i)
{
temp.push_back(i);
}
result.push_back(temp);
}
}
big++;
curSum += big;
}
return result;
}
};
6.左旋转字符串
时间限制:1秒 空间限制:32768K 热度指数:128425
本题知识点: 字符串
题目描述
汇编语言中有一种移位指令叫做循环左移(ROL),现在有个简单的任务,就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S,请你把其循环左移K位后的序列输出。例如,字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果,即“XYZdefabc”。是不是很简单?OK,搞定它!
解题思路:
三次翻转
class Solution {
public:
string LeftRotateString(string str, int n) {
int len = str.length();
if(len == 0|| n < 0|| n > len){ //这道题只要求我们考虑n<=len的情况
return str;
}
if(n!= 0&& n != len){
Reverse(str, 0, n-1);
Reverse(str, n, len-1);
Reverse(str, 0, len-1);
}
return str;
}
void Reverse(string &str,int begin,int end){
while( begin < end){
char temp = str[begin];
str[begin] = str[end];
str[end] = temp;
++begin;
--end;
}
}
};