1. 二维数组中的查找
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
分析
1、每行最大的数字在最后一个位置，全局最大数字在右下角。
2、可以从右上角或者左下角开始查找，这样一次就可以排除一行或一列，效率高。
代码
// An highlighted block
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int i = 0;
int j = array[0].size()-1;
size_t size1 = array.size();//有多少行
while(i<size1 && j>=0)
{
if(target>array[i][j])//array[i][j]是当前行最大的，当前列最小的
i++;
else if(target<array[i][j])
j--;
else if(target==array[i][j])
return true;
}
return false;
}
};
2. 替换空格
题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
分析
1.要将空格替换成“%20”，每替换一次就需要多增加2个字符。
2.替换时需要从尾部往前替换，将旧的字符串尾部元素替换到新的位置上，这样可以原地替换，不需要创建新的字符串。
代码
class Solution {
public:
int isBlank(char* str,int length)
{
int sum = 0;
for(int i = 0;i<length;i++)
{
if(str[i] == ' ')
sum++;
}
return sum;
}
void replaceSpace(char *str,int length) {
int n = isBlank(str,length);
char* oldend = str+length;//包括\0
char* newend = str+length+2*n;
while(oldend>= str&& newend>=str)
{
if(*oldend != ' ')
{
*newend-- = *oldend--;;
}
else{
*newend-- = '0';
*newend-- = '2';
*newend-- = '%';
oldend--;
}
}
}
};
3. 从尾到头打印链表
题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
分析
有两种方法，其一是将链表值按顺序放入数组中，然后对数组进行reverse翻转，其二是使用递归的方法，寻找到最后一个链表位置，在倒叙插入数组中。
代码
//数组
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
vector<int> v;
while(head){
v.push_back(head->val);
head = head->next;
}
reverse(v.begin(), v.end());
return v;
}
};
//递归
class Solution {
public:
void printListFromTailToHeadcore(ListNode* head,vector<int> &vv)
{
if(head == nullptr)
return;
printListFromTailToHeadcore(head->next,vv);
vv.push_back(head->val);
}
vector<int> printListFromTailToHead(ListNode* head) {
vector<int> v;
printListFromTailToHeadcore(head,v);
return v;
}
};
4. 重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
分析
根据root节点，将中序vector划分成vin_left，vin_right两部分中序子序列
根据中序子序列长度，将前序vector划分成pre_left, pre_right对应的前序子序列
root->left递归生成
root->right递归生成
代码
class Solution {
public:
TreeNode* reConstructBinaryTreecore(vector<int>pre,int pre_left,int pre_right,vector<int>vin ,int vin_left,int vin_right)
{
if(pre_left>pre_right||vin_left>vin_right)
return nullptr;
TreeNode *root = new TreeNode(pre[pre_left]);
for(auto i = vin_left;i<=vin_right;i++)
{
if(pre[pre_left] == vin[i])
{
root->left = reConstructBinaryTreecore(pre,pre_left+1,i-vin_left+pre_left,vin,vin_left,i-1);//i-vin_left是左子树包含节点个数，i-vin_left+pre_left就是前序左子树最后一个节点位置
root->right = reConstructBinaryTreecore(pre,i-vin_left+pre_left+1,pre_right,vin,i+1,vin_right);
//break;
}
}
return root;
}
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
if(pre.empty()||vin.empty())
return nullptr;
return reConstructBinaryTreecore(pre,0,pre.size()-1,vin ,0,vin.size()-1);
}
};
5. 重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
分析
采用二分查找的方式，进行定位.
定义首尾下标，因为是非递减数组旋转，所以旋转最后可以看做成两部分，前半部分整体非递减，后半部分整体非递减，前半部分整体大于后半部分。所以，我们假设如下定义，left指向最左侧，right指向最右侧，mid为二分之后的中间位置。则，a[mid] >= a[left],说明mid位置在原数组前半部分，进一步说明，目标最小值，在mid的右侧，让left=mid,a[mid] < a[left], 说明mid位置在原数组后半部分，进一步说明，目标最小值，在mid的左侧，让right=mid,这个过程，会让[left, right]区间缩小,这个过程中，left永远在原数组前半部分，right永远在原数组的后半部分，而范围会一直缩小,当left和right相邻时，right指向的位置，就是最小元素的位置,但是，因为题目说的是非递减，也就意味着数据允许重复，因为有重复发，就可能会有a[left] ==a[mid] ==a[right]的情况，我们就无法判定数据在mid左侧还是右侧。（注意，只要有两者不相等，我们就能判定应该如何缩小范围）
代码
class Solution {
public:
//二分查找解决
int minNumberInRotateArray(vector<int> rotateArray) {
if(rotateArray.empty())
return 0;
int begin = 0;
int end = rotateArray.size()-1;
int mid = 0;
while(rotateArray[begin]>=rotateArray[end])
{
if(end-begin == 1)
{
mid = end;
break;
}
mid = begin +((end - begin)>>1);
if(rotateArray[mid] == rotateArray[begin] && rotateArray[begin] ==rotateArray[end]){
//无法判定目标数据在mid左侧，还是右侧我们采用线性遍历方式
int result = rotateArray[begin];
for(int i = begin+1; i < end; i++){
if(result > rotateArray[i]){
result = rotateArray[i];
}
}
return result;
}
if(rotateArray[mid]>= rotateArray[begin])
{
begin = mid;
}
else
{
end = mid;
}
}
return rotateArray[mid];
}
};
6. 斐波那契数列
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39
分析
使用迭代进行计算，递归容易时间复杂度过大。
代码
class Solution {
public:
int Fibonacci(int n) {
if(n == 0)
return 0;
int one = 1;
int two = 1;
int three =1;//参考状态
while(n>2)
{
three = one+two;
one = two;
two = three;
n--;
}
return three;
}
};
7. 二进制计算
题目描述
输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。
代码
class Solution {
public:
int NumberOf1(int n) {
int count = 0;
while(n){
n &=(n-1);
count++;
}
return count;
}
};
8. 调整数组顺序使奇数位于偶数前面
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
分析
可以采取插入的方法，将奇数插入到前面偶数的位置，偶数按顺序往后走，不会打乱顺序。
代码
class Solution {
public:
void reOrderArray(vector<int> &array) {
int k = 0;
for(int i = 0;i<array.size();i++)
{
if(array[i]&1)
{
int j = i;
int tmp = array[i];
while(j>k)
{
array[j] = array[j-1];
j--;
}
array[k++] = tmp;
}
}
}
};
扫一扫
1985
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
