剑指offer 19-1020

数组中的逆序对

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

• 归并排序的思路(添加count进行计数即可)

count = 0
class Solution:
    def InversePairs(self, data):
        global count
        def MergeSort(lists):
            global count
            if len(lists) <= 1:
                return lists
            num = int( len(lists)/2 )
            left = MergeSort(lists[:num])
            right = MergeSort(lists[num:])
            r, l=0, 0
            result=[]
            while l<len(left) and r<len(right):
                if left[l] < right[r]:
                    result.append(left[l])
                    l += 1
                else:
                    result.append(right[r])
                    r += 1
                    count += len(left)-l
            result += right[r:]
            result += left[l:]
            return result
        MergeSort(data)
        return count%1000000007

两个列表的第一个公共节点

输入两个链表，找出它们的第一个公共结点。

• 找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走
  （因为2个链表用公共的尾部）

class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        l1,l2=0,0
        p1,p2=pHead1,pHead2
        while p1:
            p1=p1.next
            l1+=1
        while p2:
            p2=p2.next
            l2+=1
        s=l1-l2
        if s>=0:
            while s:
                pHead1=pHead1.next
                s-=1
        else:
            s=-s
            while s:
                pHead2=pHead2.next
                s-=1
        while pHead1 != pHead2:
            pHead1=pHead1.next
            pHead2=pHead2.next
        return pHead1

数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

• 类似于二分查找

class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        mid=len(data)//2
        if len(data)<1:
            return 0
        count=1
        if data[mid]==k:
            for i in range(mid-1,-1,-1):
                if data[i]!=k:
                    break
                count+=1
            for i in range(mid+1,len(data)):
                if data[i]!=k:
                    break
                count+=1
            return count
        if data[mid]<k:
            self.GetNumberOfK(data[mid+1:],k)
        else:
            self.GetNumberOfK(data[:mid],k)
        return 0

二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

• 利用一个队列进行层次遍历，直到队列为空即可

class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        if not pRoot:
            return 0
        queue=[]
        queue.append(pRoot)
        count=0
        while queue:
            length=len(queue)
            for i in range(length):
                r=queue.pop(0)
                if r.left:
                    queue.append(r.left)
                if r.right:
                    queue.append(r.right)
            count+=1
        return count

# 递归版 类似于动态规划
class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        if not pRoot:
            return 0
        count=max(self.TreeDepth(pRoot.left),self.TreeDepth(pRoot.right))+1
        return count

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        n=0
        for i in range(len(nums)):
            n=nums[i]^n
        return n