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;
}
};