《剑指offer》python版

临时的。有时间再仔细整理
一、 二叉树

#coding=utf-8
'''
二叉树
'''
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

# T58
class TreeLinkNode:
    def __init__(self, x):
        self.x = x
        self.left = None
        self.right = None
        self.next = None

class Solution:
    '''
    6 重建二叉树
    输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
    假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
    例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
    '''
    def reConstructBinaryTree(self, pre, tin):
        if not pre or not tin:
            return None

        root = TreeNode(pre[0])
        pos = tin.index(pre[0])
        root.left = self.reConstructBinaryTree(pre[1: pos+1], tin[:pos])
        root.right = self.reConstructBinaryTree(pre[pos+1: ], tin[pos+1: ])
        return root

    '''
    16 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
    递归
    '''
    def hasSubtree(self, pRoot1, pRoot2):
        if not pRoot1 or not pRoot2:
            return False

        result = False

        if(pRoot1.val == pRoot2.val):
            result =  self.isSubtree(pRoot1, pRoot2)

        if not result:
            result = self.isSubtree(pRoot1.left, pRoot2)

        if not result:
            result = self.isSubtree(pRoot1.right, pRoot2)

        return result

    def isSubtree(self, p1, p2):
        if not p2:
            return True
        if not p1:
            return False
        if p1.val != p2.val:
            return False
        return self.isSubtree(p1.left, p2.left) and self.isSubtree(p1.right, p2.right)

    '''
    19：二叉树的镜像
    '''
    def mirror(self, root):
        if not root:
            return root
        root.left, root.right = root.right, root.left
        self.mirror(root.left)
        self.mirror(root.right)

    '''
    23 从上往下打印二叉树
    '''

    '''
    25 二叉树中和为某一值的路径
    输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。
    路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
    (注意: 在返回值的list中，数组长度大的数组靠前)
    '''
    def findPath(self, root, expectNumber):
        if not root:
            return []
        if not root.left and not root.right and root.val == expectNumber:
            return [[root.val]]
        result = []
        left = self.findPath(root.left, expectNumber - root.val)
        right = self.findPath(root.right, expectNumber - root.val)
        # for i in left + right:
        #     result.append([root.val] + i)
        result = [root.val] + left + right
        return result

    '''
    39 二叉树的深度
    输入一棵二叉树，求该树的深度。
    从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
    '''
    def TreeDepth(self, pRoot):
        if not pRoot:
            return 0
        left = self.TreeDepth(pRoot.left)
        right = self.TreeDepth(pRoot.right)
        return max(left+1, right+1)

    '''
    58 二叉树的下一个节点
    给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。
    注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
    '''
    def GetNext(self, pNode):
        if not pNode:
            return None

        # 右节点不为空：返回右节点的最左节点
        if pNode.right:
            tmp = pNode.right
            while tmp.left:
                tmp = tmp.left
            return tmp
        else:
            if not pNode.next:
                return None
            elif pNode.next.left == pNode:
                return pNode.next
            else:
                if pNode.next.next.left == pNode.next:
                    return pNode.next.next
                else:
                    return None

    '''
    59 对称的二叉树
    请实现一个函数，用来判断一颗二叉树是不是对称的。
    注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
    '''
    def isSymmetrical(self, pRoot):
        if not pRoot:
            return True
        else:
            return self.isSameTree(pRoot.left, pRoot.right)

    def isSameTree(self, p, q):
        # 如果两个都空
        if not p and not q:
            return True
        # 如果两个有一个为空
        if not p or not q:
            return False
        if p and q and p.val == q.val:
            l = self.isSubtree(p.left, q.right)
            r = self.isSubtree(p.right, q.left)
            return l and r


    '''
    60 把二叉树打印成多行
    从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
    '''
    # 用一个队列来保存将要打印的结点。为了把二叉树的每一行单独打印到一行里，
    # 我们需要两个变量：一个变量表示在当前的层中还没有打印的结点数，另一个变量表示下一次结点的数目。
    # 队列：
    # 每次打印一个结点的时候，如果该结点有子结点，则把该结点的子结点放到队列末尾。
    # 接下来到队列头部取出最早进入队列的结点，重复前面的打印操作，直至队列中所有结点都被打印出来为止。
    def Print(self, pRoot):
        if not pRoot:
            return []
        res, tree = [], [pRoot]
        while tree:
            row, subTree = [], []
            for item in tree:
                row.append(item.val)
                if item.left:
                    subTree.append(item.left)
                if item.right:
                    subTree.append(item.right)
            res.append(row)
            tree = subTree
        return res


    '''
    61 按之字形顺序打印二叉树
    '''
    # 按之字形顺序打印二叉树需要两个栈。我们在打印某一行结点时，把下一层的子结点保存到相应的栈里。
    # 如果当前打印的是奇数层，则先保存左子结点再保存右子结点到一个栈里；
    # 如果当前打印的是偶数层，则先保存右子结点再保存左子结点到第二个栈里。
    # 分析题意：当打印奇数行时，按照从左到右的顺序打印，当打印偶数行时，要按照从右往左相反的方向打印，
    # 这样的结构很自然想到用栈来实现，但我们需要创建两个栈，来区分偶数行和奇数行的情况。
    # 当为奇数行时，需要从右到左入栈，从左到右出栈，偶数行相反。
    # https: // blog.csdn.net / shizhengxin123 / article / details / 79424034
    def Print(self, pRoot):
        if not pRoot:
            return []
        result, nodeStack = [], [pRoot]
        times = 0
        while nodeStack:
            times += 1
            res, nextStack = [], []
            for item in nodeStack:
                res.append(item.val)
                if item.left:
                    nextStack.append(item.left)
                if item.right:
                    nextStack.append(item.right)
            if times % 2 == 0:
                res = res[::-1]

            nodeStack = nextStack
            result.append(res)
        return result


    '''
    62 序列化二叉树
    请实现两个函数，分别用来序列化和反序列化二叉树
    '''
    # https: // blog.csdn.net / u010005281 / article / details / 79787278
    def Serialize(self, root):
        if not root:
            return '#'
        return str(root.val) + ',' + self.Serialize(root.left) + ',' + self.Serialize(root.right)

    def Deserialize(self, s):
        list = s.split(',')
        return self.deserializeTree(list)

    def deserializeTree(self, list):
        if not list:
            return None
        val = list.pop(0)
        root = None
        if val != '#':
            root = TreeNode(int(val))
            root.left = self.deserializeTree(list)
            root.right = self.deserializeTree(list)
        return root

    '''
    平衡二叉树
    输入一棵二叉树，判断该二叉树是否是平衡二叉树
    '''
    # pdf
    def IsBalanced_Solution(self, pRoot):
        if not pRoot:
            return True
        # 对左右两边同时递归
        if abs(self.treeDepth(pRoot.left) - self.treeDepth(pRoot.right)) > 1:
            return False
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)

    def treeDepth(self, pRoot):
        if not pRoot:
            return 0
        # 二叉树的后序遍历
        left = self.treeDepth(pRoot.left)
        right = self.treeDepth(pRoot.right)
        return max(left+1, right+1)  # 返回当前树深

二、二叉搜索树

#coding=utf-8
'''
二叉搜索树
'''
class Solution:
    '''
    24 二叉搜索树的后序遍历
    输⼊入⼀一个整数数组，判断该数组是不不是某⼆二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输
    出No。假设输⼊入的数组的任意两个数字都互不不相同。
    '''
    def VerifySequenceOfBST(self, sequence):
        if len(sequence) < 1: return False
        root = sequence[-1]
        # 找第一个大于root的 索引位置
        for i in range(len(sequence)):
            if sequence[i] > root:
                break
        for j in range(i, len(sequence)):
            if sequence[j] < root:
                return False
        left = True
        if i > 0:
            left = self.VerifySequenceOfBST(sequence[0:i])
        right = True
        if i < len(sequence) - 1 and left:
            right = self.VerifySequenceOfBST(sequence[i, -1])
        return right

    '''
    27 二叉搜索树与双向链表
    输⼊入⼀一棵⼆二叉搜索树，将该⼆二叉搜索树转换成⼀一个排序的双向链表。要求不不能创建任何新的结点，
    只能调整树中结点指针的指向。
    '''
    # https: // blog.csdn.net / qq_33431368 / article / details / 79299731
    def Convert(self, pRootOfTree):
        re = []
        re = self.NodeList(pRootOfTree)
        length = len(re)
        # 考虑特殊情况，只有一个节点或None的情况
        if(length == 0):
            return None
        if(length == 1):
            return pRootOfTree
        # 第一个节点和最后一个的操作
        re[0].left = None
        re[0].right = re[1]
        re[-1].left = re[-2]
        re[-1].right = None
        #中间各个节点的左右指针的指向的操作
        for i in range(1, length-1):
            re[i].left = re[i-1]
            re[i].right = re[i+1]
        # 返回双向链表的第一个节点
        return re[0]

    # 利用递归 得出树节点的 list
    def NodeList(self, pRoot):
        if not pRoot:
            return []
        return self.NodeList(pRoot.left) + [pRoot] + self.NodeList(pRoot.right)

    '''
    63 二叉搜索树的第k个节点
    给定一棵二叉搜索树，请找出其中的第k小的结点。
    例如， （5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。
    '''
    def KthNode(self, pRoot, k):
        global result
        result = []
        self.MidTravel(pRoot)
        if k <= 0 or len(result) < k:
            return None
        else:
            return result[k-1]

    def MidTravel(self, pRoot):
        if not pRoot:
            return
        self.MidTravel(pRoot.left)
        self.result.append(pRoot.val)
        self.MidTravel(pRoot.right)

三、数组

#coding=utf-8
'''
数组
'''
class Solution:
    '''
    29 数组中出现次数超过一半的数字
    数组中有⼀一个数字出现的次数超过数组⻓长度的⼀一半，请找出这个数字。
    例例如输⼊入⼀一个⻓长度为9的数组{1,2,3,2,2,2,5,4,2}。
    由于数字2在数组中出现了了5次，超过数组⻓长度的⼀一半，因此输出2。如果不不存在则输出0。
    '''
    # https: // blog.csdn.net / u010005281 / article / details / 79921380
    def MoreThanHalfSum_Solution(self, number):
        dict = {}
        for num in number:
            dict[num] = 1 if num not in dict else dict[num] + 1
            if dict[num] > len(number) / 2:
                return num
        return 0

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


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

    '''
    40 数组中只出现一次的数字
    一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
    '''
    def FindNumsAppearOnce(self, array):
        if not array:
            return []
        result_list = []
        for i in array:
            if array.count(i) == 1 and i not in result_list:
                result_list.append(i)
        return result_list

    def FindNumsAppearOnce2(self, array):
        if not array:
            return []
        res_list = []
        dict = {}
        for i in array:
            if i not in dict.keys():
                dict[i] = 1
            else:
                dict[i] += 1
        for i in dict.keys():
            if dict[i] == 1:
                res_list.append(i)
        return res_list

    '''
    51 数组中重复的数字
在一个长度为n的数组⾥里里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不不知道有
⼏几个数字是重复的。也不不知道每个数字重复⼏几次。请找出数组中任意⼀一个重复的数字。 例例如，如果
输⼊入⻓长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
    '''
    # 题目没有说清楚的地方：
    # 1.这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 2.函数返回True / False
    # 3.不是返回任一重复的一个值，而是返回数组中第一个重复的值
    # https: // blog.csdn.net / u010005281 / article / details / 80171726
    def duplicate(self, numbers, duplication):
        if not numbers:
            return False
        dict = {}
        for i in numbers:
            if i not in dict:
                dict[i] = 0
            else:
                duplication[0] = i
                return True
        return False


    # 变态跳台阶
    def jumpFloorII(self, number):
        # write code here
        if number < 3:
            return number
        a = [0, 1, 2]
        for i in range(3, number + 1):
            a.append(sum(a) + 1)
        return a[number]

    # 栈的压入、弹出序列

四、其它

#coding=utf-8

class Solution:

    '''
    28：字符串的排列
    输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串串abc,则打印出由字符
    a,b,c所能排列出来的所有字符串串abc,acb,bac,bca,cab和cba。
    '''
    def Permutation(self, ss):
        if not ss:
            return []
        if len(ss) == 1:
            return [ss]
        res = []
        for i in range(len(ss)):
            ret = self.Permutation(ss[:i] + ss[i+1: ])
            res+= [ss[i] + s for s in ret]
        return sorted(set(res))

    '''
            29：最⼩的K个数
            输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是
            1,2,3,4,。
    '''
    def GetLeastNumbers_Solution(self, tinput, k):
        def quick_sort(lst):
            if not lst:
                return []
            pivot = lst[0]
            left = quick_sort([i for i in lst[1:] if i< pivot ])
            right = quick_sort([j for j in lst[1:] if j >= pivot ])
            return left + [pivot] + right
        if not tinput or k > len(tinput):
            return []
        out = quick_sort(tinput)
        return out[:k]

    '''
    32：整数中1出现的次数（从1到n整数）
    1~13中包含1的数字有1、10、11、12、13因此共出现6次, 求出任意⾮非负整数区间中1出现的次数。
    '''
    # 将1-n全部转换为字符串串
    # 只需要统计每个字符串串中'1'出现的次数并相加即可
    def NumberOf1Between1AndN_Solution(self, n):
        count = 0
        for i in str(n):
            if str(i) == '1':
                count += 1
        return count

    '''
    34：丑数
    把只包含质因子2、3和5的数称作丑数（Ugly Number）。
    例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
    '''
    # https: // blog.csdn.net / qq_20141867 / article / details / 81060581
    # https: // blog.csdn.net / wang454592297 / article / details / 79849374
    def GetUglyNumber_Solution(self, index):
        if index == 0:
            return 0
        baselist = [1]
        min2 = min3 = min5 = 0
        curnum = 1
        while curnum < index:
            minnum = min(baselist[min2] * 2, baselist[min3] * 3, baselist[min5] * 5)
            baselist.append(minnum)
            while baselist[min2] * 2 <= minnum:
                min2 += 1
            while baselist[min3] * 3 <= minnum:
                min3 += 1
            while baselist[min5] * 5 <= minnum:
                min5 += 1
            curnum += 1
        return baselist[-1]

    '''
    35：第一个只出现一次的字符
    在一个字符串串(1<=字符串串⻓长度<=10000，全部由字⺟母组成)中找到第一个只出现一次的字符,并返回它
    的位置
    '''
    def FirstNotRepeatingChar(self, s):
        dct = {}
        for i in s:
            if s not in dct.keys():
                dct[i] = 1
            else:
                dct[i] += 1
            print(dct)
        for j in range(len(s)):
            print j
            if dct[s[j]] == 1:
                return j
        return -1

    '''
    41：和为S的两个数字
    输⼊入一个递增排序的数组和⼀一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对
    数字的和等于S，输出两个数的乘积最⼩小的
    '''
    # https: // blog.csdn.net / fuxuemingzhu / article / details / 79688668
    def FindNumbersWithSum(self, array, tsum):
        couple = [tsum - i for i in array]
        result = [i for i in array if i in couple]
        try:
            return result[0], result[-1]
        except:
            return []

    '''
    41：和为S的连续正数序列列
    小明很喜欢数学,有⼀天他在做数学作业时,要求计算出9~16的和,他马上就写出了了正确答案是100。但
    是他并不满⾜足于此,他在想究竟有多少种连续的正数序列列的和为100(至少包括两个数)。没多久,他就
    得到另⼀组连续正数和为100的序列列:18,19,20,21,22。现在把问题交给你,
    你能不能也很快的找出所有和为S的连续正数序列列? Good Luck!
    '''
    # https: // blog.csdn.net / shizhengxin123 / article / details / 79434991
    def FindContinuousSequence(self, tsum):
        if tsum < 3:  # 因为⾄至少包含两个数，所以最⼩小是1+2 = 3
            return []
        first = 1
        last = 2
        res = []
        mid = (1 + tsum) / 2
        while first < mid:
            cur = (first + last)*(last - first + 1)/2
            if cur < tsum:
                last += 1
            elif cur == tsum:
                res.append(list(range(first, last + 1)))
                first += 1
            else:
                first += 1
        return res

    '''
    42：翻转单词顺序列
    牛客最近来了了⼀个新员工Fish，每天早晨总是会拿着⼀本英文杂志，写些句子在本子上。同事Cat对
    Fish写的内容颇感兴趣，有⼀天他向Fish借来翻看，但却读不不懂它的意思。例如，“student. a am
    I”。后来才意识到，这家伙原来把句⼦单词的顺序翻转了了，正确的句子应该是“I am a student.”。Cat
    对⼀⼀的翻转这些单词顺序可不在行，你能帮助他么
    '''
    # 注意的点是，字符串不能直接修改，需要转成list之后才能直接对每一位修改。
    def ReverseSentence(self, s):
        from collections import deque
        if s.strip() == '':
            return s
        queue = deque()
        string = ''
        for elements in s.split(' '):
            queue.appendleft(elements)
        for i in queue:
            if not string:
                string = i
            else:
                string = string + ' ' + i
        return string

    '''
    42：左旋转字符串串
    对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。
    例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。
    '''
    def LeftRotateString(self, s, n):
        return s[n:] + s[: n]

    '''
    44：扑克牌顺⼦子
    使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 
    如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0
    '''
    # https: // blog.csdn.net / fuxuemingzhu / article / details / 79702017
    def IsContinuous(self, numbers):
        if not numbers:
            return False
        zeros = numbers.count(0)
        total_distance = 0
        numbers.sort()
        for i in range(zeros, len(numbers) - 1):
            gaps = numbers[i+1] - numbers[i] - 1
            if gaps == -1:
                return False
            else:
                total_distance += gaps
        if total_distance <= zeros:
            return True
        else:
            return False

    '''
    45：圆圈中最后剩下的数字（约瑟夫环） (抽象建模能力)
    '''
    def LastRemaining_Solution(self, n, m):
        if n < 1 or m < 1:
            return -1
        child = range(n)
        start = 0
        while(len(child) > 1):
            start = (start + m - 1) % len(child)
            child.pop(start)
        return child[0]

    '''
    46：求1+2+3+...+n
    要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）
    '''
    # 思路路：在Python中， and 和 or 执⾏行行布尔逻辑演算。但是它们并不不返回布尔值，⽽而是返回它们实际
    # 进⾏行行⽐比较的值之⼀一。（类似C + +⾥里里⾯面的 & & 和 | | 的短路路求值
    def Sum_Solution(self, n):
        # def f(x, y):
        #     return x + y
        return reduce(lambda x, y: x +y, range(1, n+1))

    '''
    47：不不⽤用加减乘除做加法
    写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号
    '''
    # 通过异或模拟无进位的加法，通过与运算模拟进位
    # def Add(self, num1, num2):
    #     return self.Add(num1 ^ num2, (num1 & num2) << 1)

    '''
    49：把字符串转换成整数
    将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，
    要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
    '''
    # https: // www.cnblogs.com / minseo / p / 8268825.html
    def StrToInt(self, s):
        if not s:
            return 0
        maps = {'1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        posOrNeg = 1
        neg_map = {'+': 1, '-': -1}
        res = 0
        for i in range(len(s)):
            if i == 0 and s[i] in neg_map:
                posOrNeg = neg_map[s[i]]
            elif s[i] in maps:
                res = res * 10 + maps[s[i]]
            else:
                return 0
        return posOrNeg * res

    '''
    53：正则表达式匹配
    '''
    # https: // blog.csdn.net / qq_20141867 / article / details / 80910724
    # def match(self, s, pattern):

    '''
    54 表示数值的字符串
    请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
    例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是
    '''
    # https: // blog.csdn.net / yurenguowang / article / details / 80588294
    def isNumeric(self, s):
        try:
            p = float(s)
            return True
        except:
            return False

    '''
    55：字符流中第一个不不重复的字符
    请实现一个函数用来找出字符流中第一个只出现一次的字符。
    例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。
    当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"
    输出描述:
    如果当前字符流没有存在出现一次的字符，返回#字符。
    '''
    # 返回对应char
    charDict = {}
    s = ""
    def FirstAppearingOnce(self):
        for key in self.s:
            if self.charDict[key] == 1:
                return key
        return '#'

    def Insert(self, char):
        self.charDict[char] = 1 if char not in self.charDict else self.charDict[char]+1
        self.s += char

    '''
    64：数据流中的中位数
    如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。
    如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
    我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数
    '''
    # 利用存入heapq的数值会被自动排序的特性求解这道题
    def __init__(self):
        self.nums = []
    def Insert(self, num):
        self.nums.append(num)
        self.nums.sort()

    def GetMedian(self, ch):
        length = len(self.nums)
        if length % 2 == 1:
            return self.nums[(length - 1) / 2]
        else:
            return (self.nums[length / 2] + self.nums[length / 2 - 1]) / 2

    '''
    65：滑动窗口的最大值
    给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
    例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，
    他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： 
    {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， 
    {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}
    '''
    # 定长的滑动窗口，这个就很简单了，直接使用切片即可
    def maxInWindows(self, num, size):
        if not num or len(num) < size or not size:
            return []

        _len = len(num)
        res = []
        for i in range(_len - size + 1):
            res.append(max(num[i: i + size]))
        return res

    '''
    请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。
    路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
    如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 
    例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，
    但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子
    '''

# print(2 ^3)
# a = [1, 2, 2, 2]
# a.pop(2)
# print(a[0])
# print(a.count(2))

# print(range(10))

test = Solution()
print(test.isNumeric("1a3.14"))
# print(test.Sum_Solution(4))
# test.FindContinuousSequence(10)
# test.FindNumbersWithSum([1,2,4,7,11,16],10)
# test = Solution()
# print(test.FirstNotRepeatingChar("google"))

# test = Solution()
# test.GetLeastNumbers_Solution([4,5,1,6,2,7,3,8],4)
# a = ['a', 'b', 'c']
# b = ['d', 'e']
# a += b

# print(a)
# a = Solution()
# b = a.Permutation("aa")
# print(b)

# a = "abc"
# print(a[:0] + a[1:])
import itertools
# print(sorted(list(set(map(''.join, itertools.permutations("abc"))))))