【剑指offer刷题】优化时间和空间效率

丑数

解决方案

• 空间换时间。建立丑数数组专门存储丑数。
• 新的丑数由老丑数乘以2或3或5得来
• 每次只把得到的最小的新丑数加入到数组中
• 建立3个检索数存储标签

代码

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

int Min(int number1, int number2, int number3) {
	int res = number1 < number2 ? number1 : number2;
	res = res < number3 ? res : number3;

	return res;
}

int GetUglyNumber_Solution(int index) 
{
	if (index <= 0)
		return 0;

	vector<int> uglynumbers{ 1 };
	int uglyindex = 1;
	int uglynumber2 = 0, uglynumber3 = 0, uglynumber5 = 0;
	while (uglyindex <= index) {
		uglynumbers.push_back(Min(uglynumbers[uglynumber2] * 2, uglynumbers[uglynumber3] * 3,uglynumbers[uglynumber5] * 5));
		if (uglyindex == index)
			break;
		
		while (uglynumbers[uglynumber2]*2 <= uglynumbers[uglyindex]) {
			uglynumber2++;
		}
		while (uglynumbers[uglynumber3]*3 <= uglynumbers[uglyindex]) {
			uglynumber3++;
		}
		while (uglynumbers[uglynumber5]*5 <= uglynumbers[uglyindex]) {
			uglynumber5++;
		}

		uglyindex++;
	}
	return uglynumbers[uglyindex - 1];

}

void Test1()
{
	int numbers = 4;
	int result = 5;
	if (result == GetUglyNumber_Solution(numbers))
	{
		cout << "Pass" << endl;
	}
	else
		cout << "Fail" << endl;
}


int main() {
	Test1();
	system("pause");
}

数组中的逆序对

题目

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

解决方案

• 归并排序改
• 时间复杂度$O(nlogn)$
• 空间复杂度$O(n)$

代码

int InversePairs(vector<int> data) {
        if(data.size() == 0)
            return 0;
        
        vector<int> copy;
        for(int i=0;i<data.size();i++)
            copy.push_back(data[i]);
        
        long long count = InversePairsCore(data,copy,0,data.size()-1);
        
        return count%1000000007;
    }
    
    long long InversePairsCore(vector<int>& data, vector<int>& copy, int start, int end)
    {
        if(start == end)
        {
            copy[start] = data[start];
            return 0;
        }
        
        long len = (end - start)/2;
        
        long long left = InversePairsCore(copy,data,start,start+len);
        long long right = InversePairsCore(copy,data,start+len+1,end);
        
        long i = start + len;
        long j = end;
        long indexCopy = end;
        long long count = 0;
        
        while(i >= start && j >= start+len+1){
            if(data[i] > data[j])
            {
                copy[indexCopy--] = data[i--];
                count += j - start - len;
            }
            else{
                copy[indexCopy--] = data[j--];
            }
        }
        
        for(;i>=start;--i){
            copy[indexCopy--]=data[i];
        }
        for(;j>=start+len+1;--j){
            copy[indexCopy--]=data[j];
        }
        
        return left+right+count % 1000000007;
    }

两个链表的第一个公共结点

题目

输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

解决方案

• 链表第一个公共节点后的节点都是相同的
  
• 从尾节点回溯找第一个公共节点会更容易，因为两个链表的尾节点要么是相同公用的，要不是空节点（意味着没有公共节点）
• 单向链表不能回溯，此方法类似于“后进先出”，想到使用栈
• 将两个链表分别压入两个栈，然后回溯
• 时间复杂度$O(m+n)$
• 空间复杂度$O(m+n)$

代码

ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        stack<ListNode*> s1,s2;
        // 遍历，压入栈
        PushNode(s1, pHead1);
        PushNode(s2, pHead2);

        ListNode* res = nullptr;
        while ((!s1.empty()) && (!s2.empty()) && (s1.top() == s2.top())){
            res = s2.top();
            s1.pop();
            s2.pop();
        }

        return res;
    }
    
    void PushNode(stack<ListNode*>& s, ListNode* pHead) {
        ListNode* cur = pHead;
        while (cur != nullptr) {
            s.push(cur);
            cur = cur->next;
        }
    }

复习内容

1. 各类排序的复现
2. C++容器，哈希表
3. 栈的用法