剑指offer【6-30题】python【旋转数组最小数字--最小的k个数】

1.【题目描述】把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

遍历

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        if len(rotateArray) == 0:
            return 0
        a = rotateArray[0]
        for i in rotateArray:
            if a > i:
                a = i
        return a
        # write code here

优化 //（利用函数也行   min）

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        if len(rotateArray) == 0:
            return 0
        if len(rotateArray) == 1:
            return rotateArray[0]
        for i in range(0,len(rotateArray)):
            if rotateArray[i] > rotateArray[i+1]:
                return rotateArray[i+1]
        return rotateArray[0] 

二分法 

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        if len(rotateArray) == 0:
            return 0
        if len(rotateArray) == 1:
            return rotateArray[0]
        left, right = 0, len(rotateArray) - 1
        while left <= right:
            mid = (left + right)/2
            if rotateArray[right] < rotateArray[mid]:
                left = mid+1
            elif rotateArray[right] > rotateArray[mid]:
                right = mid
            else:
                right -=1
            if left >= right:
                break
        return rotateArray[left]
            
        # write code here

2. 【题目描述】大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

# -*- coding:utf-8 -*-
class Solution:
    def Fibonacci(self, n):
        # write code here
        if n == 1 or n == 0:
            return n
        s = [0,1]
        for i in range(n-1):
            s.append(s[-1]+s[-2])##利用了python的切片
        return s[-1]

'''class Solution:
    def Fibonacci(self, n):
        # write code here
        if n < 2:
            return n
        if n == 2:
            return 1
        s = [1,1]
        for i in range(2,n):##2,3,4......n-1
            s.append(s[i-1]+s[i-2])
        return s[n-1]'''

3. 【题目描述】一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。(变相的斐波那契数列)

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        if number < 3:
            return number
        else:
            s = [1,2]
            for i in range(2,number):
                s.append(s[-1]+s[-2])
            return s[-1]
        
        # write code here
###递归会运行超时

4.【题目描述】变态跳台阶。一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。(另一种解法：pow（2，number-1)//pow() 方法返回 xy（x的y次方） 的值。）

              | 1       ,(n=0 ) 

f(n) =     | 1       ,(n=1 )

              | 2*f(n-1),(n>=2)

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        if number == 0 or number == 1:
            return number
        a = [1]
        for i in range(1,number):
            a.append(2*a[-1])
        return a[-1]
        # write code here

5.【题目描述】矩形覆盖 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？（暴力破解f(n)= f(n-1) + f(n-2)）

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        if number < 3:
            return number
        a = [1,2]
        for i in range(number-2):
            a.append(a[-1] + a[-2])
        return a[-1]
        # write code here

 6.【题目描述】输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。【昨个携程校招有个类似的题-------sad】

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        count = 0
        if n <= 0:
            n = n & 0xFFFFFFFF
        for i in range(0,32):
            if ((n&1) == 1):
                count +=1
            n = n >>1
        return count
        '''return sum([(n>>i &1) for i in range(0,32)])'''
        # write code here

【与运算】0&0=0;   0&1=0;    1&0=0;     1&1=1; 例如：3&5  即 0000 0011 & 0000 0101 = 0000 0001   因此，3&5的值得1。

【或运算】0|0=0；   0|1=1；   1|0=1；    1|1=1； 例如:3|5　即 0000 0011 | 0000 0101 = 0000 0111   因此，3|5的值得7。

【异或运算】0^0=0；   0^1=1；   1^0=1；   1^1=0；如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

【取反运算】~1=0；   ~0=1；

【左移运算】<< 左边的二进制位丢弃，右边补0,若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。

【右移运算】>>正数左补0，负数左补1，右边丢弃。左补0 or 补1 得看被移数是正还是负。,相当于该数除以2。

【不同长度数据进行位运算】系统会将二者按右端对齐，然后进行位运算。

（1）如果整型数据为正数，左边补16个0。（2）如果整型数据为负数，左边补16个1。（3）如果整形数据为无符号数，左边也补16个0。

【负数补码】0xffffffff  代表-1 

7.【题目描述】给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

##python大发好！
# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        '''return pow(base,exponent)'''
        a = 1
        if (base == 0 & exponent < 0):
            return False
        if exponent == 0:
            return 1
        else:
            for i in range(abs(exponent)):
                a = a * base
        if exponent > 0:
            return a
        if exponent < 0:
            return 1/a

8.【题目描述】 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        if len(array) == 0 or len(array) == 1:
            return array
        for i in range(len(array)):
            for j in range(len(array)-1):
                if (array[j]%2==0 and array[j+1]%2==1):
                    array[j],array[j+1] = array[j+1],array[j]
        return array
        #return sorted(array,key=lambda c:c%2,reverse=True)
        # write code here

9.【题目描述】 输入一个链表，输出该链表中倒数第k个结点。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        a = []
        while head:
            a.append(head)
            head = head.next
        if k < 1 or k > len(a):
            return 
        return a[-k]
        #count = 0
        #p = head
        #while p:
            #count +=1
            #p = p.next
        #if k == 0 or k > count:
            #return 
        #q = count - k
        #for i in range(q):
            #head = head.next
        #return head
        # write code here

10.【题目描述】 输入一个链表，反转链表后，输出新链表的表头。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:####返回的一直是int 直接调用ListNode函数就行，在这个问题上浪费很长时间
    # 返回ListNode
    def ReverseList(self, pHead):
        if not pHead or not pHead.next:
            return pHead
        b = []
        p = pHead
        while pHead:
            b.append(pHead)###[{1,2,3,4,5},{2,3,4,5},{3,4,5},{4,5},{5}]
            pHead = pHead.next
        b.reverse()###[ListNode(5),ListNode(4),ListNode(3),ListNode(2),ListNode(1)]
        for idx, node in enumerate(b):
            if idx < len(b)-1:
                node.next = b[idx+1]
            else:
                node.next = None
        return b[0]

 11.【题目描述】 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        tmp = ListNode(5)
        p = tmp
        while pHead2 and pHead1:
            if pHead1.val <= pHead2.val:      ###tmp.next = None 不给tmp.next 赋值 它不会有指向性
                tmp.next = pHead1
                pHead1 = pHead1.next
                tmp = tmp.next
            else:
                tmp.next = pHead2
                pHead2 = pHead2.next
                tmp = tmp.next
        if pHead2:
            tmp.next = pHead2
        if pHead1:
            tmp.next = pHead1
        return p.next

 12.【题目描述】 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）这里看到一个很厉害的程序,将两个遍历，看子结构是否相等，编程的思想就是将问题简单化

def rever(p): if p: return str(p.val) + rever(p.left) +rever(p.right) else: return ''

return  rever(pRoot2) in rever(pRoot1) if pRoot2 else False

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        if not pRoot2 or not pRoot1:
            return False
        return self.li(pRoot1,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2)
        # write code here
    def li(self,a,b):##调用子树
        if not b:
            return True
        if not a or a.val != b.val:
            return False
        return self.li(a.left,b.left) and self.li(a.right,b.right)

 13.【题目描述】 操作给定的二叉树，将其变换为源二叉树的镜像。这里传给p的是地址，当改变p时，root也会跟着改变。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        if root:
            root.left,root.right = root.right,root.left
            self.Mirror(root.left)
            self.Mirror(root.right)
        # write code here

14.【题目描述】 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

*zip函数

a = [1,2,3]  b = [4,5,6]   c = [4,5,6,7,8]   

zipped = zip(a,b)     # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)]

zip(a,c)              # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)]

zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    #先读取第一行 然后将列表反转 再读取第一行
    def printMatrix(self, matrix):
        a = []
        while matrix:
            a +=matrix.pop(0) #第一行
            if not matrix:
                break
            else:   ##反转
                matrix = zip(*matrix)[::-1] ##[::-1]和reverse()等同
        return a
        # write code here

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    #先读取第一行 然后将列表反转 再读取第一行
    ##读取第一行 读取下面每行最后一个数 读取最后一行 从下往上读取 循环结束
    def printMatrix(self, matrix):
        a = []
        while matrix:##因为随时可能中断，要每一步都判断一下
            a +=matrix.pop(0) #第一行
            if matrix and matrix[0]: ##上一步取的是一行 判断matrix是否有下一行
                for i in matrix:
                    a.append(i.pop(-1))  #i行最后一个数
            if matrix:
                a +=matrix.pop(-1)[::-1]  ##最后一行逆序
            if matrix and matrix[0]:  ##上一步取的是一行 判断matrix是否有下一行
                for i in matrix[::-1]:
                    a.append(i.pop(0)) #i行第一个数
        return a
        # write code here

15.【题目描述】定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。 

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack = []
        self.min_stack = []
    def push(self, node):
        self.stack.append(node)
        if not self.min_stack or node <= self.min_stack[-1]:
            self.min_stack.append(node)
        # write code here
    def pop(self):
        if self.stack[-1] == self.min_stack[-1]:
            self.min_stack.pop(-1)
        self.stack.pop(-1)
        # write code here
    def top(self):
        return self.stack[-1]
        # write code here
    def min(self):
        return self.min_stack[-1]
        # write code here

16.【题目描述】输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的） 

# -*- coding:utf-8 -*-
class Solution:
    '''判断栈顶元素和第一个元素是否相等，相等则出栈，不等则入栈,最后判断列表是否大小相等'''
    def IsPopOrder(self, pushV, popV):
        stack = []
        for i in pushV:
            stack.append(i)
            while len(stack) and stack[-1] == popV[0]:
                stack.pop()
                popV.pop(0)
        if len(stack):
            return False
        return True

 17.【题目描述】从上往下打印出二叉树的每个节点，同层节点从左至右打印。目的返回值是列表，必须返回值

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        stack = []
        q = [root]
        if not root:
            return []
        while q:
            a = q.pop(0)
            stack.append(a.val)
            if a.left:
                q.append(a.left)
            if a.right:
                q.append(a.right)
    return stack

18.【题目描述】输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        ##后序遍历最后一个是根节点，搜索树可以根据节点大小排序
        if not sequence:
            return False
        a = sequence[-1]
        for i in range(len(sequence)):
            if sequence[i] > a:
                break
        for j in range(i,len(sequence)):
            if sequence[j] < a:
                return False
        left = True
        right = True
        if i > 0 :#循环终止条件
            left = self.VerifySquenceOfBST(sequence[:i])
        if left and i < len(sequence) - 1:
            right = self.VerifySquenceOfBST(sequence[i+1:])
        return (right and left)
        # write code here

19.【题目描述】输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    #递归，返回叶子节点
    def FindPath(self, root, expectNumber):
        if not root:#叶子节点的空分支，递归终止点
            return []
        if root and not root.left and not root.right and expectNumber == root.val:
            return [[root.val]]#叶子节点
        a = []
        left = self.FindPath(root.left, expectNumber-root.val)
        right = self.FindPath(root.right, expectNumber-root.val)
        for i in (left+right):#非叶子节点递归
            a.append([root.val] + i)
        return a
        # write code here

 20.【题目描述】输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

# -*- coding:utf-8 -*-
# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        if not pHead:##调用到链表最后指针为空时，返回空
            return 
        p = RandomListNode(pHead.label)
        p.next = self.Clone( pHead.next)##return false 是返回没有这个类型，表明递归调用有问题
        p.random = pHead.random
        return p
        # write code here

21.【题目描述】输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。中序遍历加双向链表(将左子树最大值和根相连，右子树最小值和根相连再对左右子树进行递归调用)

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, Root):
        if not Root:
            return Root
        if not Root.left and not Root.right:
            return Root
##处理左子树
        self.Convert(Root.left)
        left = Root.left
##将左子树最大值和根连接（双向）
        if left:
            while(left.right):
                left = left.right
            Root.left,left.right = left,Root
##处理右子树
        self.Convert(Root.right)
        right = Root.right
##将右子树最小值和根连接（双向）
        if right:
            while(right.left):
                right = right.left
            Root.right,right.left = right,Root
        while Root.left:
            Root = Root.left
        return Root
        # write code here

22.【题目描述】输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。迭代，1.选取可能的一个值，2.固定这个值，后面排列（递归）

# -*- coding:utf-8 -*-
import itertools
class Solution:
    def Permutation(self, ss):
        if not ss:
            return []
        return sorted(list(set(map("".join,itertools.permutations(ss)))))
        # sorted排序 list列表 set集合去重  map函数指定函数做映射 .join字符串连接 #itertools.permutations 元组迭代器，将字符串做排列
################################################################################
另一种方法
# -*- coding:utf-8 -*-
class Solution:
    def Permutation(self, ss):
        if not ss:
            return []
        if len(ss) == 1:
            return list(ss)
        a = []
        r = list(ss)#"abc" ["a","b","c"]
        for i in set(r):##排序
            p = list(ss)
            p.pop(p.index(i))##去掉目标
            b = [i+j for j in self.Permutation(p)]##ss[i]舍去
            a.extend(b)
        return sorted(a)
        # write code here

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

优秀解法1：遍历数组，后一个值和前一个相同，次数加一，不同次数减一，次数为0时再比较下一个数。此解法前提是必须存在一个数出现次数超过数组长度一半，不然无解。

优秀解法2：因为一个数字出现次数一定是超过数组长度一半，将数组排序，若存在，则中间那个数一定是解

# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        if  not numbers:
            return 0
        a = len(numbers)
        b = a/2
        c = [i for i in set(numbers)]##去重
        count = 0
        for i in c:
            for j in numbers:
                if i == j:
                    count += 1
            if count > b:
                return i
            else:
                count = 0
        if count > b:
            return c[-1]
        else:
            return 0
        # write code here
###########################################################
# -*- coding:utf-8 -*-
import collections
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        tmp = collections.Counter(numbers)
        a = len(numbers)/2
        for k,v in tmp.items():
            if v > a:
                return k
        return 0
        # write code here
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
##还有一种不想写了，实现方法很简单
# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        if not numbers:
            return 0
        count = 1
        a = numbers[0]
        for i in numbers[1:]:
            if a == i:
                count += 1
            elif count:
                count -=1
            else:
                count = 1
                a = i
        n = len([i for i in numbers if a == i])
        if n > len(numbers)/2:
                return a
        return 0
        # write code here

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

基于堆排序算法，构建最大堆。时间复杂度为O(nlogk);如果用快速排序，递归。时间复杂度为O(nlogn);如果用冒泡排序，时间复杂度为O(n*k)

##排序 输出 a[-k] or a[k]
###@@@@@@@@@@@@@@@@@@冒泡 一趟固定一个最小值
# -*- coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        if not tinput or len(tinput) < k:
            return []
        for i in range(len(tinput)):
            for j in range(i+1,len(tinput)):
                if tinput[i]>tinput[j]:
                    tinput[i],tinput[j] = tinput[j],tinput[i]
        return tinput[:k]
        # write code here
#################################
# -*- coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        if not tinput:
            return []
        if len(tinput) <k:
            return []
        a = sorted(tinput)
        return a[:k]
        # write code here