剑指offer 35、36：数组中的逆序对 、两个链表的第一个公共结点

35.题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
思路：归并算法变体

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()==0)
            return 0;
        vector<int>temp(data);
        long long count=process(data,temp,0,data.size()-1);
        return count%1000000007;
    }
    long long process(vector<int> &data,vector<int> &temp,int start,int end)
    {
        if(start==end)
            return 0;
        int mid=(start+end)>>1;
        long long left=process(temp,data,start,mid);
        long long right=process(temp,data,mid+1,end);

        int r1=mid,r2=end;
        int k=end;
        long long count=0;
        while(r1>=start && r2>=mid+1)
        {
            if(data[r1]>data[r2])
            {
                temp[k--]=data[r1--];
                count+=r2-mid;
            }
            else
                temp[k--]=data[r2--];
        }
        while(r1>=start)
            temp[k--]=data[r1--];
        while(r2>=mid+1)
            temp[k--]=data[r2--];
        return count+left+right;
    }
};

# -*- coding:utf-8 -*-
import copy
class Solution:
    def process(self,data,temp,start,end):
        if start==end:
            return 0
        mid=(start+end)>>1
        left=self.process(temp,data,start,mid)
        right=self.process(temp,data,mid+1,end)
        r1=mid
        r2=end
        k=end
        count=0
        while r1>=start and r2>=mid+1:
            if data[r1]>data[r2]:
                temp[k]=data[r1]
                k=k-1
                r1=r1-1
                count+=r2-mid
            else:
                temp[k]=data[r2]
                k=k-1
                r2=r2-1
        while r1>=start:
            temp[k]=data[r1]
            k=k-1
            r1=r1-1
        while r2>=mid+1:
            temp[k]=data[r2]
            k=k-1
            r2=r2-1
        return count+left+right
    def InversePairs(self, data):
        if len(data)<=1:
            return 0
        temp=copy.copy(data)
        num=self.process(data,temp,0,len(data)-1)
        return num%1000000007
        # write code here

36题目描述
输入两个链表，找出它们的第一个公共结点。
思路：第一个链表在共同节点之前的有m1个节点，第二个链表在共同节点之前有m2个节点，共同节点有n个，（至少NULL是共同的节点）。
m1 + n + m2 = m2 +n + m1 说明是在第一个共同节点相遇。
第一个链表遍历完后转到第二个链表，第二个链表同样。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode* p1=pHead1;
        ListNode* p2=pHead2;
        while(p1!=p2)
        {
            p1=(p1==NULL? pHead2:p1->next);
            p2=(p2==NULL? pHead1:p2->next);
        }
        return p1;
    }
};

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        p1=pHead1
        p2=pHead2
        while p1 != p2:
            p1=pHead2 if p1==None else p1.next
            p2=pHead1 if p2==None else p2.next
        return p1