-
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;
}
}
};
133
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
