python 剑指offer 学习之路(三）

和为S的两个数字

题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        head = 0
        last = len(array)-1
        result = []
        while head < last:
            two_sum = array[head] + array[last]
            if two_sum < tsum:
                head += 1
            elif two_sum > tsum:
                last -= 1
            else:
                result.append([head,last])
                head += 1
        product = []
        if not result:
            return []
        for a,b in result:
            product.append(a*b)
        index = product.index(min(product))
        return [array[result[index][0]],array[result[index][1]]]

左旋转字符串

题目描述
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s:
            return ""
        s = list(s)
        for i in range(n):
            temp = s.pop(0)
            s.append(temp)
        return "".join(s)

翻转单词顺序列

题目描述
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        s = s.split(" ")
        new_s = []
        for i in range(len(s)):
            new_s.append(s[abs(i-len(s)+1)])
            new_s.append(" ")
        new_s.pop()
        return "".join(new_s)

扑克牌顺子

题目描述
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers)<5:
            return False
        zero_num = numbers.count(0)
        sum_step = 0
        numbers = sorted(numbers)
        for i in range(zero_num,len(numbers)-1):
            if numbers[i]==numbers[i+1]:
                return False
            else:
                # 计算间隙
                if (numbers[i+1] - numbers[i]) > 1:
                    sum_step = sum_step + numbers[i+1] - numbers[i] - 1
        # 间隙小于零的个数是顺子
        if sum_step <= zero_num:
            return True
        else:
            return False

不用加减乘除做加法

题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

# -*- coding:utf-8 -*-
class Solution:
    def Add(self, num1, num2):
        # write code here
        while num2 != 0:
            result = (num1 ^ num2) & 0xffffffff
            carry = ((num1 & num2) << 1) & 0xffffffff
            num2 = carry
            num1 = result
        if num1 <= 0x7fffffff:
            result = num1
        else:
            result = ~(num1^0xffffffff)
        return result

把字符串转换成整数

题目描述
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
输入描述:
输入一个字符串,包括数字字母符号,可以为空
输出描述:
如果是合法的数值表达则返回该数字，否则返回0
示例1
输入
复制
+2147483647
1a33
输出
复制
2147483647
0

# -*- coding:utf-8 -*-
class Solution:
    def StrToInt(self, s):
        # write code here
        negative = False
        if len(s)==0:
            return 0
        if s[0] == '+':
            if len(s) == 1:
                return 0
            s = s.split("+")[1]
        if s[0] == '-':
            if len(s) == 1:
                return 0
            s = s.split("-")[1]
            negative = True
        array = ['0','1','2','3','4','5','6','7','8','9']                
        if s.isdigit():
            num = 0
            for i in s:
                 num = num*10 + array.index(i)
            if negative:
                return -num
            else:
                return num
        else:
            return 0

数组中重复的数字

题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

# -*- coding:utf-8 -*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        if len(numbers) < 1:
            return False
        max_number = max(numbers)
        for i in range(max_number+1):
            if numbers.count(i) > 1:
                duplication[0] = i
                return True
        return False

二叉搜索树的第k个结点

题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def __init__(self):
        self.list_val = []
    def KthNode(self, pRoot, k):
        # write code here
        if k == 0:
            return None
        self.middle_digui(pRoot)
        if len(self.list_val)<k:
            return None
        return self.list_val[k-1] 
        
    def middle_digui(self, root):
        if root == None:
            return
        print(root.val)
        
        self.front_digui(root.left)
        self.list_val.append(root)
        self.front_digui(root.right)

滑动窗口的最大值

题目描述
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{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]}。

# -*- coding:utf-8 -*-
class Solution:
    def maxInWindows(self, num, size):
        # write code here
        if len(num)<size:
            return []
        if size == 0:
            return []
        array = []
        while len(num)>=size:
            array.append(max(num[0:size]))
            num.pop(0)
        return array

对称的二叉树

题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot:
            return True
        return self.campare(pRoot.left,pRoot.right)
    def campare(self,pRoot1,pRoot2):
        if not pRoot1 and not pRoot2:
            return True
        if not pRoot1 or not pRoot2:
            return False
        if pRoot1.val == pRoot2.val:
            if self.campare(pRoot1.left,pRoot2.right) and self.campare(pRoot1.right,pRoot2.left):
                return True
        return False

把二叉树打印成多行

题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if pRoot is None:
            return []
        queue = []
        
        result = []
        queue.append(pRoot)
        while queue:
            array = []
            chlid_list = []
            for i in queue:
                array.append(i.val)
                if i.left:
                    chlid_list.append(i.left)
                if i.right:
                    chlid_list.append(i.right) 
            queue = chlid_list
            result.append(array)
        return result

按之字形顺序打印二叉树

题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Print(self, pRoot):
        # write code here
        if pRoot is None:
            return []
        queue = []
        result = []
        queue.append(pRoot)
        while queue:
            array = []
            chlid_list = []
            for i in queue:
                array.append(i.val)
                if i.left:
                    chlid_list.append(i.left)
                if i.right:
                    chlid_list.append(i.right) 
            queue = chlid_list
            result.append(array)
        return_result = []
        for i in range(len(result)):
            if i % 2 == 0:
                return_result.append(result[i])
            else:
                return_result.append(result[i][::-1])
        return return_result