剑指Offer 1-41 代码（python实现）

  今天主要写了一下offer 1-41题，余下的稍后整理
  1 """
1 镜像二叉树: 递归
"""
def mirror(root):
    if not root:
        return None
    mirror(root.left)
    mirror(root.right)
    root.left, root.right = root.right, root.left
    return root

"""2. 链表环入口
"""
def circle(node):
    if not node:
        return None
    slow,fast = node, node
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            slow = node
            while slow != fast:
                slow = slow.next
                fast = fast.next
            return fast
    return None

"""
3 删除重复结点 
"""
def delNode(pHead):
    first = ListNode(-1)
    cur = pHead
    last = first
    while cur and cur.next:
        if cur.val != cur.next.val:
            cur = cur.next
            last = last.next
        else:
            val = cur.val
            while cur and cur.val == val:
                cur = cur.next
            last.next = cur
    return first.next

"""4 打印链表"""

def  info(pHead):
    res = []
    if not pHead:
        return None
    while pHead:
        res.index(pHead.val)
        pHead = pHead.next
    return res

"""5 斐波那契数列的第n项"""

def Fib(n):
    dp = [0,1]
    if n == 0:
        return 0
    if n == 1:
        return 1
    for i in range(2, n+1):
        dp.append(dp[i-1] + dp[i-2])
    return dp[-1]

def Fib1(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    a ,b = 0, 1
    while n-1:
        temp = a
        a = b
        b = temp + b
        n -= 1
    return b

"""6 变态跳台阶"""
def jump(n):
    if n == 1:
        return 1
    dp = [1]
    for i in range(1, n):
        dp[i] = sum(dp[:i]) + 1
    return dp[-1]

def jumpFloorII(number):
        # write code here
        if number == 1:
            return 1
        dp = [1] * (number)
        dp[0], dp[1] = 1, 2
        for i in range(2, number):
            dp[i] = 2 * dp[i - 1]
        return dp[-1]

"""10 平衡二叉树"""

def isBalance(root):

    def deep(root):
        if not root:
            return 0
        left = deep(root.left)
        right = deep(root.right)
        return max(left, right) + 1
    if not root:
        return True
    return abs(deep(root.left) - deep(root.right)) <=1

"""11.和为s的连续数字"""

def findNumber(tsum):
    res = []
    left, right = 1, 2
    if tsum < 3:
        return []
    while left< right and left < tsum//2+1:
        if sum(range(left, right+1)) == tsum:
            res.append(range(left, right+1))
            left += 1
        elif  sum(range(left, right+1)) < tsum:
            right +=1
        else:
            left+=1
    return res

"""12 左旋字符串"""
def left(s, k):
    if s == "":
        return ""
    k = k%len(s)
    return s[k:] + s[:k]

"""13 数字在排序数组出现次数"""

def numberCount(data, k):
    if not data:
        return 0
    left, right = 0, len(data) - 1
    while left <= right:
        mid = (left + right) // 2
        if data[mid] == k:
            index = mid
            res = 0
            while index < len(data) and data[index] == k:
                res += 1
                index += 1
            index = mid - 1
            while index >= 0 and data[index] == k:
                res += 1
                index -= 1
            return res
        elif data[mid] > k:
            right = mid - 1
        else:
            left = mid + 1
    return 0

"""14 数组只出现一次的数字  ： 异或运算"""

def onlyOne(array):
    temp = 0
    flag = 1
    a,b = 0,0
    for i in array:
        temp = temp ^ i
    while temp:
        if temp % 2 != 0:
            break
        temp >> 1
        flag = flag << 1
    for i in array:
        if i&flag:
            a =a^i
        else:
            b = b^i
    return a,b

"""16 二叉树深度 ： 参照10"""

"""17 和为s的两个数： 双指针：距离最远的数字最小"""
def FindNumbersWithSum( array, tsum):
    left, right = 0, len(array)-1
    a,b = 0,0
    while left<= right:
        if array[left] + array[right] == tsum:
            return array[left],array[right]

        elif array[left] + array[right] < tsum:
            left +=1
        else:
            right -=1
    return []

"""18 顺时针打印矩阵 : 思路：每次打印第一行，将矩阵逆时针旋转90 直到为None"""

def infoArray(matrix):
    if not matrix:
        return None
    res = []
    while matrix:
        res = res + matrix[0]
        matrix.pop(0)
        matrix = list(map(list, zip(*matrix)))[::-1]
    return res

"""19 二叉树的下一个结点（***）中序遍历（左 中 右）
① 如果结点存在右结点，则进入右子树（最左边的结点）             该节点相当于根
② 若该节点无右子节点，且该节点为父亲的左子节点，则为父节点      该节点为左节点
③ 若该节点无右子节点，且该节点为父亲的右子节点，则需要一直搜索父亲，直到为某个结点的左节点

"""
def nextNode(pNode):
    if not pNode:
        return None
    if pNode.right:  #情况1
        temp = pNode.right
        while temp.left:
            temp = temp.left
        return temp

    else:
        temp = pNode.next  #temp指向父亲
        while temp and temp.right == pNode:  #判断是否为父亲的右节点， 不是的话退出 返回上一行的值
            #是的话执行情况3
            pNode = temp
            temp = temp.next
        return temp

"""20 对称二叉树"""

def symme(left, right):
    if not left and not right:
        return True
    if left and right:
        return left.val == right.val and symme(left.left, right.right) and symme(left.right, right.left)
    else:
        return False
def issymme(pRoot):
    if not pRoot:
        return True
    return symme(pRoot.left, pRoot.right)

"""21 二叉树打印多行   从左往右打印"""
"""层次遍历二叉树(补充)"""
def cengci(root):
    if not root:
        return None
    queue = [root]
    res = []
    while queue:
        res.append(queue[0].val)
        if queue[0].left:
            queue.append(queue[0].left)
        if queue[0].right:
            queue.append(queue[0].right)
        queue.pop(0)
    return res


"""本题"""
def print(pRoot):
    if not pRoot:
        return []
    res = []
    queue = [pRoot]
    while queue:
        temp = []; queue_temp = []
        for i in queue:
            temp.append(i.val)
            if i.left:
                queue_temp.append(i.left)
            if i.right:
                queue_temp.append(i.right)
        queue = queue_temp
        res.append(temp)
    return res
"""24 数据流中位数 ： 大根堆 和小根堆"""

"""26 重建二叉树  先序 中序"""
def buildTree(pre, tin):
    root = pre[0]
    index = tin.index(root)
    ltin = tin[:index]
    rtin = tin[index+1:]
    lpre = pre[1:len(ltin)+1]
    rpre = pre[1+len(ltin):]
    p = TreeNode(root)
    p.left = buildTree(lpre,ltin)
    p.right = buildTree(rpre,rtin)
    return p

"""27 滑动窗口最大"""

"""28 栈实现队列： 根据性质"""

"""29 旋转数组最小值：二分查找"""
def minNumber(rotateArray):
    if not rotateArray:
        return None
    low,high = 0, len(rotateArray)-1
    while low < high:
        mid = (low + high) //2
        if rotateArray[mid] > rotateArray[high]:
            left = mid + 1
        else:
            high = mid
    return rotateArray[left]

"""30 丑数"""
def ugly(index):
    if index ==0:
        return 0
    if index == 1:
        return 1
    dp = [1]
    n1,n2,n3 = 0,0,0
    for i in range(index-1):
        num1,num2,num3 = dp[n1]*2, dp[n2]*3, dp[n3]*5
        Min = min(num1, num2,num3)
        dp.append(Min)
        if num1 == Min:
            n1 += 1
        if num2 == Min:
            n2 += 1
        if num3 == Min:
            n3 += 1
    return dp[-1]

"""31 链表的第一个公共结点"""
def firstCommonNode(pHead1, pHead2):
    if not pHead1 or not pHead2:
        return None
    p1,p2 = pHead1,pHead2
    while p1 != p2:
        if p1:
            p1 = p1.next
        else:
            p1 = pHead2
        if p2:
            p2 = p2.next
        else:
            p2 = pHead1
    return p1

"""32 第一次只出现一次的字符
queue 存储每个字符第一次出现的位置
"""
def firstChar(s):
    dict = {}
    queue = []
    for i in range(len(s)):
        if s[i] not in dict:
            dict[s[i]] = 1
            queue.append(i)
        else:
            dict[s[i]] += 1
    for i in queue:
        if dict[s[i]] == 1:
            return i
    return -1

"""33 数组中逆序对
思路： 先排序  从小到大找 对应 原数组中去
例[2,5,1] -> [1,2,5]  从1开始在原数组找它的索引就是它对应的逆序对数 1:2  2:1  5:0
"""
def inverse(data):
    temp =[]
    res = 0
    for i in data:
        temp.append(i)
    temp = sorted(temp)
    for i in temp:
        res += data.index(i)
        data.remove(i)
    return res

"""34 连续数组的最大和"""
def FindGreatestSumOfSubArray(array):
    # write code here
    for i in range(1, len(array)):
        if array[i - 1] >= 0:
            array[i] = array[i] + array[i - 1]
        else:
            continue
    return max(array)

"""35 最小的k个数
TOPK问题： 一般建立大根堆，  如果是最大的就建立小根堆
快排也可以实现
"""
# 快排
def p( L, l, r):
    temp, i = L[r], l - 1
    for j in range(l, r):
        if L[j] <= temp:
            i += 1
            L[i], L[j] = L[j], L[i]
    L[i + 1], L[r] = L[r], L[i + 1]
    return i + 1

def GetLeastNumbers_Solution( tinput, k):
    if k == 0 or k > len(tinput):
        return []
    else:
        flag = p(tinput, 0, len(tinput) - 1)  #拆分点
        while flag != k - 1:
            if flag > k - 1:
                flag = p(tinput, 0, flag - 1)
            if flag < k - 1:
                flag = p(tinput, flag + 1, len(tinput) - 1)
        return sorted(tinput[:flag + 1])
#堆排序（TOP） 这是找最大的。
class Solution:
    def __init__(self):
        pass
    def Heap(self, L, i, size):  #小根堆维护
        root = i
        left , right = 2*i+1, 2*i+2
        if left < size and L[root]> L[left]:
            root = left
        if right < size and L[root]> L[right]:
            root = right
        if root != i:
            L[root],L[i] = L[i],L[root]
            self.Heap(L,root,size)
        return L
    def buildHeap(self, L):
        for i in range(len(L)//2,-1,-1):
            self.Heap(L,i,len(L))
        return L
    def TopK(self, L, k):
        result = L[:k]
        result = self.buildHeap(result)
        for i in range(k,len(L)):
            if L[i] > result[0]:
                result[0] = L[i]
                self.Heap(result, 0, k)
        return result
""""""


"""36 数组超过一半的数
排序（多余一半的肯定出现在中间）"""
def MoreNum(numbers):
    numbers = sorted(numbers)
    key = numbers[len(numbers) // 2]
    if numbers.count(key) > len(numbers) // 2:
        return key
    else:
        return 0

"""37 1 到n中 1出现的次数
找规律
"""
"""38 数组排成最小的数"""
def minNum(numbers):
    if numbers is None or len(numbers) == 0:
        return ""
    numbers = map(str, numbers)
    numbers.sort(cmp=lambda x, y: cmp(x + y, y + x))
    return "".join(numbers).lstrip()

#错误
def minNum2(numbers):
        numbers = sorted(list(map(str, numbers)))
        res = ""
        for i in numbers:
            print(i)
            if (res + i) >= (i + res):
                res = i+res
            else:
                res = res+i

        return res

"""39 数组中重复的数字"""
def duplicate(numbers, duplication):
    # write code here
    dict = {}
    for i in range(len(numbers)):
        if numbers[i] not in dict:
            dict[numbers[i]] = 1
        else:
            dict[numbers[i]] += 1
    for i in dict:
        if dict[i] > 1:
            duplication[0] = i
            return True
    duplication[0] = -1
    return False

"""40 构造乘积数组
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],
其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。
"""
def mulMatrix(A):
    size = len(A)
    B = [1] * size
    for i in range(1, size):  # 构建下三角矩阵（上 到 下）
        B[i] = A[i - 1] * B[i - 1]
    temp = 1
    for i in range(size - 2, -1, -1):
        temp = temp * A[i + 1]
        B[i] = B[i] * temp
    return B

"""?? 旋转数组的查找：二分查找"""
def findKey(target, array):
    if not array:
        return None
    left, right = 0,len(array)-1
    while left < right:
        mid = (left + right)//2
        if array[mid] == target:
            return True
        if array[mid] < array[right]:  #右侧有序
            if target > array[mid] and target <= array[right]:
                left = mid + 1
            else:
                right = mid -1
        else:
            if target >= array[left] and target < array[mid]:
                right = mid -1
            else:
                left = mid + 1
    return False

"""41 二维数组的查找"""
def findkey(target, array):
    if not array:
        return False
    row ,col = 0, len(array[0])-1
    while row <= len(array) and col>=0:
        if array[row][col] == target:
            return True
        elif array[row][col] > target:
            col -= 1
        else:
            row += 1
    return False