1.二维数组中的查找
解法1:
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int m = array.size();
int n = array[0].size();
for(int i=0; i<m; i++)
if(binarySearch(target, array[i], 0, n-1)) //binary_search(array[i].begin(), array[i].end(), target)
return true;
return false;
}
private:
bool binarySearch(int target, vector<int> arr, int l, int r)
{
while(l <= r)
{
int mid = (l + r) / 2;
if(arr[mid] < target)
l = mid+1;
else if(arr[mid] > target)
r = mid-1;
else
return true;
}
return false;
}
};
解法二:
从左下角开始
- 当前值比target大,上移
- 当前值比target小,右移
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int m = array.size();
int n = array[0].size();
int i = m-1;
int j = 0;
while(i>=0 && j<n)
{
if(array[i][j] == target)
return true;
else if(array[i][j] > target)
i--;
else
j++;
}
return false;
}
};
2.替换空格
使用realloc()扩容,从尾往前拷贝
class Solution {
public:
void replaceSpace(char *str,int length) {
int nSpace = 0;
for(int i=0; i<length; i++)
{
if(str[i] == ' ')
nSpace++;
}
if(nSpace == 0)
return ;
str = (char*)realloc(str, length + nSpace * 2);
int index = length + nSpace * 2-1;
for(int i = length-1; i>=0; i--)
{
if(str[i] == ' ')
{
str[index--] = '0';
str[index--] = '2';
str[index--] = '%';
}
else
str[index--] = str[i];
}
}
};
3.从尾到头打印链表
- 栈
- 头插
- 递归
//头插
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) :
* val(x), next(NULL) {
* }
* };
*/
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
ListNode *dummyHead = new ListNode(-1);
ListNode *cur = head;
while(cur)
{
ListNode *tmp = cur->next;
cur->next = dummyHead->next;
dummyHead->next = cur;
cur = tmp;
}
vector<int> ret;
cur = dummyHead->next;
while(cur)
{
ret.push_back(cur->val);
cur = cur->next;
}
return ret;
}
};
//递归
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) :
* val(x), next(NULL) {
* }
* };
*/
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
vector<int> ret;
help(head, ret);
return ret;
}
private:
void help(ListNode *node, vector<int> &v)
{
if(node == NULL)
return ;
help(node->next, v);
v.push_back(node->val);
}
};
4.重建二叉树
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
return help(pre, vin, 0, pre.size()-1, 0, vin.size()-1);
}
private:
TreeNode* help(vector<int> pre, vector<int> vin, int pl, int pr, int vl, int vr)
{
if(pl > pr)
return NULL;
TreeNode* root = new TreeNode(pre[pl]);
int i = vl;
for(; i<vr; i++)
if(vin[i] == pre[pl])
break;
root->left = help(pre, vin, pl+1, pl+i-vl, vl, i-1);
root->right = help(pre, vin, pl+i-vl+1, pr, i+1, vr);
return root;
}
};
5.用两个栈实现队列
- 一个栈负责push操作
- 一个栈负责pop操作
class Solution
{
public:
void push(int node) {
stack1.push(node);
}
int pop() {
if(stack2.size() != 0)
{
int ret = stack2.top();
stack2.pop();
return ret;
}
while(stack1.size() > 0)
{
stack2.push(stack1.top());
stack1.pop();
}
int ret = stack2.top();
stack2.pop();
return ret;
}
private:
stack<int> stack1;
stack<int> stack2;
};
扩展:
- 两个队列实现栈
- 任意时刻其中一个队列为空
6.旋转数组的最小数字
- 经过旋转之后,数组分为两个非减序列
情况一:arr[mid] > arr[l](即mid指向前非减序列)
情况二:arr[mid] < arr[l](即mid指向后非减序列)
情况三:arr[mid] == arr[l](无法判断指向前还是后)每次更新,让l始终指向前非减序列,r指向后非减序列
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
if(rotateArray.size() == 0)
return 0;
int l = 0 ;
int r = rotateArray.size() - 1;
while(l < r){
if(r-l == 1)
return rotateArray[r];
int mid = l + (r - l) / 2;
if(rotateArray[mid] > rotateArray[l]){
l = mid;
}else if(rotateArray[mid] == rotateArray[l]){
l = mid + 1;
}else{
r = mid;
}
}
return rotateArray[l];
}
};
7.斐波那契数列
class Solution {
public:
int Fibonacci(int n) {
if(n <= 1)
return n;
int a = 0;
int b = 1;
int ret;
for(int i=2; i<=n; i++)
{
ret = a + b;
a = b;
b = ret;
}
return ret;
}
};
8.跳台阶
class Solution {
public:
int jumpFloor(int number) {
if(number <= 2)
return number;
int a = 1; //一级台阶跳法
int b = 2; //二级台阶跳法
int ret;
for(int i=3; i<=number; i++)
{
ret = a + b;
a = b;
b = ret;
}
return ret;
}
};
9.变态跳台阶
f(0) = 1
f(1)
f(n) = f(0) + f(1) + f(2) + … + f(n-1)
class Solution {
public:
int jumpFloorII(int number) {
if(number <= 1)
return number;
memo = vector<int>(number+1, 0);
memo[0] = 1;
for(int i=1; i<=number; i++)
{
int tmp = 0;
for(int j=i-1; j>=0; j--)
tmp += memo[j];
memo[i] = tmp;
}
return memo[number];
}
private:
vector<int> memo;
};
10.矩形覆盖
f(1) = 1
f(2) = 2
f(n) = f(n-1) + f(n-2)
class Solution {
public:
int rectCover(int number) {
if(number <= 2)
return number;
int a = 1; // 2*1的方法
int b = 2; // 2*2的方法
int ret = 0;
for(int i=3; i<=number; i++)
{
ret = a + b;
a = b;
b = ret;
}
return ret;
}
};