题目地址
一、二维数组中的查找
题目描述
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
算法思想
首先在二维数组的第一行的数与这个整数比较，找到比这个整数大的位置的前一个位置，如果都比这个整数小，则这个位置就是第一行的最后一个位置。确定第一行的位置，就从这个位置往下找，如果找到就成功返回，找不到就把第一行确定的位置往前一个，再往下找，如果找到第一列没找到，就返回false。
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int row = array.size();
int col = array[0].size();
int i , j;
for(j = 0; j < col; j++) {
if(array[0][j] == target)
return true;
else if(array[0][j] > target)
break;
}
j--;
while(j >= 0) {
i = 1;
while(i < row) {
if(array[i][j] == target)
return true;
i++;
}
j--;
}
return false;
}
};
二、替换空格
题目描述
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
算法思想
简单的题目，放了很久才拿起来，而且还是学习了别人的做法才会的，其实就是先统计空格的数量（count），才从后面往前遍历，遇到字幕往后移动 2 * count 位置，2 因为还有个空格，这样就刚好装下%20，遇到空格往后，将%20 填到字母前面。
class Solution {
public:
void replaceSpace(char *str,int length) {
int space = 0;
for(int i = 0; i < length; i++) {
if(*(str+i) == ' ') {
space++;
}
}
int pr = length - 1;
while(length > 0 && pr > -1) {
if(*(str + pr) == ' ') {
*(str + pr + space * 2) = '0';
*(str + pr + space * 2 - 1) = '2';
*(str + pr + space * 2 - 2) = '%';
space--;
}
else
*(str + pr + space * 2) = *(str + pr);
pr--;
}
}
};
三、从尾到头打印链表
题目描述
输入一个链表，从尾到头打印链表每个节点的值
算法思想
从头到尾将链表的值存到栈中，再一一从栈中取出。
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
stack<int> S;
vector<int> V;
ListNode *p = head;
while(p) {
S.push(p->val);
p = p->next;
}
while(!S.empty()) {
int tmp = S.top();
S.pop();
V.push_back(tmp);
}
return V;
}
};
四、重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
算法思路
首先，将根结点的值找到，将前序的第一个找到在中序的位置（mid），这个中序的mid的左右便是根的左右子树，并且根据这个mid将中序分为两部分，分别为左右子树的中序遍历，并且将前序遍历也分为左右子树的前序遍历，再进行递归就行了，结束条件便是中序或者是前序的长度为0 了，返回NULL；
class Solution {
public:
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
int mid = 0, j = 0, len = vin.size();
if(len == 0)
return NULL;
vector<int> pre_left, pre_right, vin_left, vin_right;
root->val = pre[0];
for(; mid < len; mid++) {
if(vin[mid] == pre[0])
break;
}
while(j < mid) {
vin_left.push_back(vin[j]);
pre_left.push_back(pre[j+1]);
j++;
}
j++;
while(j < len) {
vin_right.push_back(vin[j]);
pre_right.push_back(pre[j]);
j++;
}
root->left = reConstructBinaryTree(pre_left, vin_left);
root->right = reConstructBinaryTree(pre_right, vin_right);
return root;
}
};
五、用两个栈实现队列
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
算法思想
进队列操作就用栈1进栈保存数据，出队列需要借助栈2，当栈2为空时，需要把栈1的数据出栈，将数据进栈到栈2，再将栈2出栈即为出队列，当栈2不为空时，栈2出栈的数据即为出队列数据。
class Solution
{
public:
void push(int node) {
stack1.push(node);
}
int pop() {
if(stack2.empty()) {
while(!stack1.empty()) {
stack2.push(stack1.top());
stack1.pop();
}
int t = stack2.top();
stack2.pop();
return t;
}
else {
int t = stack2.top();
stack2.pop();
return t;
}
}
private:
stack<int> stack1;
stack<int> stack2;
};
六、旋转数组中的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
算法描述
数组旋转前是非递减的，只要找到旋转后不是非递减的位置就是最小值。
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
int i = 1;
while(i < rotateArray.size()) {
if(rotateArray[i] < rotateArray[i-1])
return rotateArray[i];
i++;
}
return 0;
}
};