剑指offer 19-1018

数组中出现超过一半的数字

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

#比较笨的方法，计数比较
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        half=len(numbers)/2
        count=dict()
        for i in numbers:
            if i in count:
                count[i]+=1
            else:
                count[i]=1
        for key,val in count.items():
            if val > half:
                return key
        return 0

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        if not numbers:
            return 0
        #nums=numbers[0]
        count=0
        #该循环选出最大数量的数字
        for i in range(len(numbers)):
            if count==0:
                nums=numbers[i]
            if numbers[i]==nums:
                count+=1
            else:
                count-=1
        count=0
        #统计是否超过一半
        for i in numbers:
            if i == nums:
                count+=1
        return nums if count>len(numbers)/2 else 0

最小的k个数

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

class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        # write code here
        stack=[]
        if k<=0 or k>len(tinput):
            return []
        for i in range(k):
            stack.append(tinput[i])
        stack=self.adjust(stack)
        for j in range(k,len(tinput)):
            if tinput[j]<stack[-1]:
                stack[-1]=tinput[j]
                stack=self.adjust(stack)
        return stack
    def adjust(self,input):
        if len(input)<=1:
            return input
        mid=input.pop(len(input)//2)
        left,right=[],[]
        for i in range(len(input)):
            if input[i]<=mid:
                left.append(input[i])
            else:
                right.append(input[i])
        return self.adjust(left)+[mid]+self.adjust(right)

连续子数组的最大和

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

• 动态规划问题 dp[i]=max[dp[i-1]+nums[i],nums[i]]保存已nums[i]为末尾元素的最大序列和，然后用res来保存历遍过程中的所有子序列最大和

class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        dp=[0 for i in range(len(array))]
        #if array[0]>0:
        dp[0]=array[0]
        res=-999
        for i in range(1,len(array)):
            dp[i]=max(dp[i-1]+array[i],array[i])
            res=max(res,dp[i])
        return res

整数中1出现的次数

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

• 通过归纳个位，十位，百位数字1的规律，进而得到不同数字各位上1的出现次数

class Solution:
    def NumberOf1Between1AndN_Solution(self, n):
        # write code here
            leng=len(str(n))-1
            count=0
            while leng>=0:
                bit=10**(leng)
                k=n%(bit*10)
                count+=(n//(bit*10))*bit+min(max(0,k-bit+1),bit)
                leng-=1
            return count

把数组排成最小的数

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

• 重新定义大小比较，然后套用排序算法即可

class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        if not numbers:
            return ''
        numbers=self.sort(numbers)
        out=''
        for i in numbers:
            out=out+str(i)
        return int(out)
    
    def sort(self,nums):
        if len(nums)<=1:
            return nums
        left,right=[],[]
        mid=nums.pop(len(nums)//2)
        for i in range(len(nums)):
            if self.compare(nums[i],mid):
                left.append(nums[i])
            else:
                right.append(nums[i])
        return self.sort(left)+[mid]+self.sort(right)
        
    def compare(self,num1,num2):
        if int(str(num1)+str(num2))<int(str(num2)+str(num1)):
            return True
        else:
            return False

数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

class Solution(object):
    def findKthLargest(self, nums, k):
        # partition函数用来进行排序操作
        def partition(left,right,pivot_index):
            pivot=nums[pivot_index]
            nums[right],nums[pivot_index]=nums[pivot_index],nums[right]
            store_left=left
            for i in range(left,right):
                if nums[i]<pivot:
                    nums[i],nums[store_left]=nums[store_left],nums[i]
                    store_left+=1
            nums[right],nums[store_left]=nums[store_left],nums[right]
            return store_left
        #进行下一步的操作
        def select(left,right,k_smallest):
            if left==right:
                return nums[left]
            pivot_ind=random.randint(left,right)
            pivot_ind=partition(left,right,pivot_ind)
            if pivot_ind == k_smallest:
                return nums[pivot_ind]
            elif pivot_ind > k_smallest:
                return select(left,pivot_ind-1,k_smallest)
            else:
                return select(pivot_ind+1,right,k_smallest)
        return select(0,len(nums)-1,len(nums)-k)

丑数

编写一个程序判断给定的数是否为丑数。

丑数就是只包含质因数 2, 3, 5 的正整数。

class Solution(object):
    def isUgly(self, num):
        """
        :type num: int
        :rtype: bool
        """
        if num<=0:
            return False
        while True:
            cur=num
            if not num%2 :
                num //=2
            if not num%3 :
                num //=3
            if not num%5 :
                num //=5
            if num == 1:
                return True
            if cur==num:
                return False