剑指offer--时间效率

题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

class Solution:
    def __init__(self):
        self.dict1 = {}
    def MoreThanHalfNum_Solution(self, numbers):
        length = len(numbers)
        max_length = 0
        max_length_number = numbers[0]
        for i in numbers:
            if i not in self.dict1:
                self.dict1[i] = 1
            else:
                self.dict1[i] += 1
            if self.dict1[i] > max_length:
                max_length = self.dict1[i]
                max_length_number = i
                if max_length > length//2:
                    return max_length_number
        return 0

题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

# -*- coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        a = self.Heap(tinput)
        res = []
        if k>len(tinput):
            return res
        while k:
            res.append(a.pop(0))
            k -= 1
        return res
    def Heap(self, arr):
        n = len(arr)
        # 构建大顶堆
        for i in range((n-2)//2, -1, -1):
            self.heapdown(arr, i, n-1)
        # 进行堆排序
        for i in range(n-1, 0, -1):
            # 把堆顶元素与最后一个元素交换
            tmp = arr[i]
            arr[i] = arr[0]
            arr[0] = tmp
            # 把打乱的堆进行调整，恢复堆的特性
            self.heapdown(arr, 0, i-1)
        return arr

    # 下沉操作
    def heapdown(self, arr, parent, n):
        # 临时保存要下沉的元素
        tmp = arr[parent]
        child = 2 * parent + 1
        while child <= n:
            # 如果右节点比左孩子大，则定位到右孩子
            if child+1<=n and arr[child]<arr[child+1]:
                child += 1
            if arr[child]<=tmp:
                break
            arr[parent] = arr[child]
            parent = child
            child = 2* parent +1
        arr[parent] = tmp

题目描述
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

# -*- coding:utf-8 -*-
class Solution:
    def FindGreatestSumOfSubArray(self, array):
        length = len(array)
        max1 = array[0]
        for i in range(1,length):
            tmp = array[i-1] + array[i]
            if tmp > array[i]:
                array[i] = tmp
            max1 = max(array[i], max1)
        return max1

题目描述
求出1_{13的整数中1出现的次数,并算出100}1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1Between1AndN_Solution(self, n):
        # write code here
        if n<=0:
            return 0
        count = 0
        i = 1
        while i <= n:
            count += (n/(i*10))*i
            m = n % (i * 10)
            if m > i * 2 - 1:
                count += i
            elif n%(i*10) < i:
                count += 0
            else:
                count += m - i + 1
            i *= 10
        return count

题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

# -*- coding:utf-8 -*-
class Solution:
    def PrintMinNumber(self, numbers):
        for i in range(len(numbers)):
            for j in range(i+1, len(numbers)):
                sub = int(str(numbers[i])+str(numbers[j])) - int(str(numbers[j])+str(numbers[i]))
                if sub>0:
                    numbers[i], numbers[j] = numbers[j], numbers[i]
        return ''.join(str(x) for x in numbers)