5 优化时间和空间效率
只要不是特别大的内存开销，时间复杂度比较重要。
通常用户更关心速度。
- C++ 尽量传引用，因为传值的时候会进行一次复制，需要避免掉。
- 循环和递归效率可能天差地别（参考 DP）
- 面试时要展示敏捷的思维能力以及追求完美的激情。一定不能轻严放弃，要表现出积极思考的态度，努力从不同的角度去思考问题。
面试题39 数组中出现次数超过一半的数字
题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为 9 的数组 {1,2,3,2,2,2,5,4,2}。由于数字 2 在数组中出现了 5 次，超过数组长度的一半，因此输出 2 。如果不存在则输出 0 。
解题思路
- 解法一：观察数据的特点。遍历数组，一开始默认出现次数最多的元素是第一个，然后去统计它出现的个数，如果重复出现，那么个数加一，否则个数减一，如果出现次数变成了
0，那么把它的下一个当作是出现次数最多的元素，继续操作。 - 解法二：利用快速排序的思想。寻找数组的中间位置的元素。假设找的足够随机，每次会减少一半的运算，最后需要的运算为
n(1+1/2+1/4+...)，不会超过2n，所以时间复杂度为O(n)。但是这种做法会修改输入的数组。
Code
解法一：
class Solution {
public:
int MoreThanHalfNum_Solution(vector<int> numbers) {
int count = 1;
int num = numbers[0], n = numbers.size();
for (int i = 1; i < n; i ++){
if(numbers[i] == num){
count ++;
}
else{
count --;
if (count == 0){
num = numbers[i];
count = 1;
}
}
}
count = 0;
for (int i = 0; i < numbers.size(); i ++){
if (numbers[i] == num)
count ++;
}
if (count > n / 2)
return num;
else
return 0;
}
};
解法二：
class Solution {
public:
int MoreThanHalfNum_Solution(vector<int> numbers) {
int n = numbers.size();
int num = find(numbers, 0, n - 1, n >> 1), count = 0;
for (int i = 0; i < numbers.size(); i ++){
if (numbers[i] == num)
count ++;
}
if (count > n / 2)
return num;
else
return 0;
}
private:
int partition(std::vector<int>& numbers, int start, int end){
int pivot = numbers[start];
while (start < end){
while(start < end && numbers[end] >= pivot){
end --;
}
numbers[start] = numbers[end];
while(start < end && numbers[start] < pivot){
start ++;
}
numbers[end] = numbers[start];
}
numbers[start] = pivot;
return start;
}
int find(std::vector<int>& numbers, int start, int end, int target){
int mid = partition(numbers, start, end);
if (mid == target){
return numbers[mid];
}
if (mid > target){
return find(numbers, start, mid - 1, target);
}
else {
return find(numbers, mid + 1, end, target);
}
}
};
面试题40 最小的 k 个数
题目描述
输入n个整数，找出其中最小的 k 个数。例如输入 4,5,1,6,2,7,3,8 这 8 个数字，则最小的 4 个数字是 1,2,3,4 。
解题思路
- 思想和上题一样，借鉴快速排序的思想，找到第
k个元素，这时它左边的元素就是需要返回的结果，时间复杂度O(n) - 维持一个最大堆，如果堆内元素不足
k个，直接插入，如果堆内有k个元素，那么在堆中取出最大值与当前值进行比较，如果堆内元素更大，需要删除掉，然后插入当前的值，直到所有数据处理完毕。时间复杂度为O(n logk)，这种方法有两个好处- 特别适合处理海量数据
- 不会修改输入的数组
c++ multiset 的使用：
- 实现是用的红黑树，所以可以实现最坏情况下插入和删除元素，而且集合内的元素保持有序
insert传入参数是待插入的 值erase传入参数是待删除的 迭代器
Code
解法一（本地测试没问题，但提交结果不正确，不知道为什么）：
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
if (k <= 0) return {};
find_k(input, 0, input.size() - 1, k);
vector<int> result;
for (int i = 0; i < k; i ++){
result.push_back(input[i]);
}
return result;
}
private:
int partition(vector<int>& numbers, int low, int high){
int pivot = numbers[low];
while(low < high){
while(low < high && numbers[high] >= pivot){
high --;
}
numbers[low] = numbers[high];
while(low < high && numbers[low] < pivot){
low ++;
}
numbers[high] = numbers[low];
}
numbers[low] = pivot;
return low;
}
void find_k(vector<int>& numbers, int low, int high, int k){
int mid = partition(numbers, low, high);
printf("%d %d %d\n", low, mid, high);
if ( mid == k ){
return;
}
if (mid < k){
find_k(numbers,mid + 1, high, k);
}
else{
find_k(numbers, low, mid - 1, k);
}
return;
}
};
解法二：
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k){
if (k < 1 || k > input.size()) return {};
multiset<int> s;
for (int i = 0; i < input.size(); i ++){
if(s.size() < k){
s.insert(input[i]);
}
else{
auto it = s.end();
it --;
if (*it > input[i]){
s.erase(it);
s.insert(input[i]);
}
}
}
return vector<int>(s.begin(), s.end());
}
};
面试题41 数据流中的中位数
题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用 Insert() 方法读取数据流，使用 GetMedian() 方法获取当前读取数据的中位数。
解题思路
- 使用无序数组来实现，插入
O(1)，查找O(n) - 使用有序数组来实现，插入
O(n)，查找O(1) - AVL 树，插入
O(logn)，查找O(1) - 观察中位数具有以下的特点：比如说有
P1和P2是最中间的两个数的位置（当数组个数是奇数时，P1=P2），那么P1一定是数组左边部分中最大的数，而P2是数组右边部分中最小的数，所以我们只需要维持两个数组个数相等的情况下，左边维持一个最大堆，右边维持一个最小堆，且左边堆中的每个元素都需要小于右边的堆。具体的实现方式是，每次插入时，先插入到右边的堆，然后在右边的堆中删除最小的元素，插入到左边的堆，这样可以保证左边的始终小于右边的。然后在取得中位数时，再从左边的删除，加到右边的，来保证两边个数统一。插入 O(logn)，查找 O(1)。
Code
class Solution {
public:
void Insert(int num)
{
r.insert(num);
l.insert(*r.begin());
r.erase(r.begin());
}
double GetMedian()
{
while(l.size() > r.size()){
auto it = l.end();
it --;
r.insert(*it);
l.erase(it);
}
auto t2 = r.begin();
if (l.size() == r.size()){
auto t1 = l.end(); t1 --;
return (double(*t1) + double(*t2)) / 2;
}
return *t2;
}
private:
multiset<int> r; //r
multiset<int> l; //l
};
面试题42 连续子数组的最大和
题目描述
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。球所有子数组和的最大值。
解题思路
利用一个变量来保存当前值之前的子数组的和，如果这个和小于 0 ，那么直接从当前的值开始计算子数组，会比带上之前的子数组更大。否则的话，就加上当前的值，继续去计算子数组。
Code
class Solution {
public:
int FindGreatestSumOfSubArray(vector<int> array) {
int m = array[0], pre = array[0];
for (int i = 1; i < array.size(); i ++){
if (pre < 0) pre = 0;
pre += array[i];
if (pre > m){
m = pre;
}
}
return m;
}
};
面试题45 把数组排成最小的数
题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323 。
解题思路
观察可以看出，我们需要将这些数按照某个顺序排好，这时我们可以写一个比较大小的函数，如果 a 放在 b 前得到的结果比 b 放在 a 前得到的结果更小，那么就返回小于，这样将数组排序好以后直接拼起来就可以了。
Code
class Solution {
public:
static bool cmp(int a, int b){
long long c, d;
for (c = 1; c <= a; c *= 10){}
for (d = 1; d <= b; d *= 10){}
return (long long)a * d + b < (long long)b * c + a;
}
string PrintMinNumber(vector<int> numbers) {
sort(numbers.begin(), numbers.end(), cmp);
string result = "";
for (int i : numbers){
result += to_string(i);
}
return result;
}
};
面试题48 最长不重复子串
参考 Leetcode 3，解法是滑动窗口
面试题49 丑数
题目描述
丑数：只包含因子 2、3 和 5 的数。求按从小到大的第 n 个丑数。
解法一 生成然后排序
思想
每一个丑数可以表示成 2^i*3^j*5^k 枚举所有的 i,j,k 即可。
时间复杂度：O(nlogn)
空间复杂度：O(n)
注意使用静态变量，只会声明一次，不会多次重复计算，多次调用的话就是 O(1) 的时间
代码
class Solution {
public:
int nthUglyNumber(int n) {
static vector<int> nums;
if (nums.empty()){
for (long a = 1; a <= INT_MAX; a *= 2){
for (long b = a; b <= INT_MAX; b *= 3){
for (long c = b; c <= INT_MAX; c *= 5){
nums.push_back(c);
}
}
}
sort(nums.begin(), nums.end());
}
return nums[n - 1];
}
};
解法二 从小到大生成
思想
生成的同时记录着 3 个索引，里面记录的信息分别是上一次用因子 2，3，5 生成的最大的丑数，然后利用这些数继续去生成一个最小的丑数。
时间复杂度：O(n)
空间复杂度：O(n)
代码
class Solution {
public:
int nthUglyNumber(int n) {
static vector<int> nums;
if (nums.empty()){
int i2 = 0, i3 = 0, i5 = 0;
nums.push_back(1);
int count = 1;
while(count <= 1690){
int next = min(nums[i2] * 2, min(nums[i3] * 3, nums[i5] * 5));
if (next == nums[i2] * 2) i2 ++;
if (next == nums[i3] * 3) i3 ++;
if (next == nums[i5] * 5) i5 ++;
nums.push_back(next);
count ++;
}
}
return nums[n - 1];
}
};
面试题50 第一个只出现一次的字符
题目一 字符串中第一个只出现一次的字符
解题思路
用一个字典记录每个字母出现了多少次，然后从头到尾遍历，找到第一次只出现一次的字符。时间 O(n)，空间 O(1)，因为字母的个数是固定的，是个常数。
Code
class Solution {
public:
int FirstNotRepeatingChar(string str) {
unordered_map<char, int> m;
for (int i = 0; i < 26; i ++){
m['a' + i] = 0;
m['A' + i] = 0;
}
for (int i = 0; i < str.size(); i ++){
m[str[i]] ++;
}
for (int i = 0; i < str.size(); i ++){
if (m[str[i]] == 1)
return i;
}
return -1;
}
};
题目二 字符流中地一个不重复的字符
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g" 。当从该字符流中读出前六个字符 "google" 时，第一个只出现一次的字符是 "l" 。
解题思路
插入的时候保存一个队列，里面记录了只出现一次的字符。再使用一个字典记录每个字符出现几次。找到第一个不重复的字符时，按照队列的顺序，找到第一个只出现一次的字符。
一个更巧妙的解法：ASCII 字符一共有 256 个，新建一个 256 大小的数组，里面初始化为 -1。每次插入的时候，利用 ASCII 码去记录，如果里面是 -1，那么记录该字符在流中出现的位置；否则的话，说明是第二次出现，把它里面置为 -2 即可。查询的时候，遍历这个数组，找到最小的大于等于 0 的字符。
代码
class Solution
{
public:
queue<char> q;
unordered_map<char, int> m;
//Insert one char from stringstream
void Insert(char ch)
{
if (m.count(ch)){
m[ch] += 1;
return;
}
else{
q.push(ch);
m[ch] = 1;
return;
}
}
//return the first appearence once char in current stringstream
char FirstAppearingOnce()
{
char ch = 0;
while(!q.empty()){
ch = q.front();
if (m[ch] != 1){
q.pop();
ch = 0;
}
else{
break;
}
}
return ch == 0 ? '#' : ch;
}
};
面试题51 数组中的逆序对
题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数 P。并将 P 对 1000000007 取模的结果输出。 即输出 P%1000000007
解题思路
逆序对要想到归并排序，在归并的过程中不断统计逆序对的个数。归并排序需要使用额外的一个数组，时间 O(nlogn) 空间 O(n)。
Code
#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
long long count;
void merge(int start1, int end1, int start2, int end2,
vector<int>& newArray, vector<int>& data) {
int s1 = start1;
int left_num = end1 - start1 + 1;
int current_index = start1;
while(start1 <= end1 && start2 <= end2){
if (data[start1] > data[start2]) {
newArray[current_index ++] = data[start2 ++];
count += left_num;
count %= 1000000007;
}
else {
newArray[current_index ++] = data[start1 ++];
left_num -= 1;
}
}
while(start1 <= end1){
newArray[current_index ++] = data[start1 ++];
}
while(start2 <= end2){
newArray[current_index ++] = data[start2 ++];
}
for (int i = s1; i <= end2; i ++){
data[i] = newArray[i];
}
}
void mergeSort(vector<int>& data, vector<int>& newArray, int start, int end){
if (end <= start)
return;
int mid = start + (end - start) / 2;
cout << mid << " " << start << " " << end << endl;
mergeSort(data, newArray, start, mid);
mergeSort(data, newArray, mid + 1, end);
merge(start, mid, mid + 1, end, newArray, data);
}
int InversePairs(vector<int> data) {
count = 0;
std::vector<int> nums(data.size());
mergeSort(data, nums, 0, data.size() - 1);
return count;
}
};
int main(){
Solution s;
vector<int> v = {1,2,3,4,5,6,7,0};
cout << s.InversePairs(v) << endl;
}
面试题52 两个链表的第一个公共节点
题目描述
输入两个链表，找出它们的第一个公共节点。
解题思路
- 利用辅助栈，因为最后的节点都是相同的，将两个链表的节点都入栈，然后一直出栈直到找到不相同的节点。时间复杂度为
O(m + n)，空间复杂度也为O(m + n) - 统计两个链表的长度，然后先让长的链表往后走一部分，然后两个链表共同往后走，知道碰到同一个节点，时间复杂度为
O(m + n)，空间复杂度为O(1) - 比较难理解的一种想法：假如第一个链表长度为
a+n，第二个链表长度为b+n，其中n为公共的节点的长度，不失一般性，假如a < b，设置两个指针，一开始让两个指针从两个链表开始共同往后遍历，当第一个指针往后走到头时，第二个链表往后走了a+n步，此时，让第一个指针继续从第二个链表的头开始遍历，当它走b-a步时，第二个指针走到了末尾，此时再让第二个指针从第一个链表的头开始走，这时，两个指针共同往前走a步就碰到了。
Code
class Solution {
public:
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
ListNode* p1 = pHead1;
ListNode* p2 = pHead2;
while(p1 != p2){
if (p1) p1 = p1 -> next;
if (p2) p2 = p2 -> next;
if (p1 != p2){
if (p1 == NULL) p1 = pHead2;
if (p2 == NULL) p2 = pHead1;
}
}
return p1;
}
};
4557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
