剑指offer算法题python实现

funNLPer

已于 2024-04-10 00:18:50 修改

阅读量539

点赞数 1

分类专栏：数据结构算法文章标签：队列指针数据结构算法

于 2020-05-10 21:17:27 首次发布

本文链接：https://blog.csdn.net/orangerfun/article/details/105872710

版权

数据结构算法专栏收录该内容

13 篇文章 1 订阅

订阅专栏

文章目录

本文题目顺序按照牛客网 | 挑战剑指offer [1]中题目顺序，相关参考资料见文末

1. 二维数组中的查找[Done]

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路1
暴力法，遍历二维数组比较是否有与目标值相等的元素

思路2
将二维数组的左下角作为起始点，如果目标值大于当前元素，就横坐标加一，若目标值小于当前元素，纵坐标减1（当然也可以考虑右上方作为起始点）

思路1暴力法最差的复杂度为 $mn$ ，其中 $m$ ， $n$ 分别为二维矩阵的长宽，而思路而最差的复杂度为 $m + n$

程序(思路2)

class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        rows = len(array)-1
        cols = len(array[0])-1
        i = rows
        j = 0
        while i>=0 and j<=cols:
            if target < array[i][j]:
                i -= 1
            elif target > array[i][j]:
                j += 1
            else:
                return True
        return False

2. 替换空格[Done]

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        temp = s.replace(" ", "%20")
        return temp

# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        result = ""
        for x in s:
            if x == " ":
                result += "%20"
            else:
                result += x
        return result

3. 从尾到头打印链表[Done]

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        stack = []
        while listNode != None:
            stack.append(listNode.val)
            listNode = listNode.next
        stack.reverse()
        return stack

空间复杂度 $O (n)$
方法二：直接在反转的时候打印

class NewNode:
    def __init__(self, val) -> None:
        self. value = val
        self.next = None


def createLink(nums):
    head = NewNode(nums[0])
    ptr = head
    for i in range(1, len(nums)):
        node = NewNode(nums[i])
        ptr.next = node
        ptr = ptr.next
    return head


def reverse(head):
    if head == None or head.next == None:
        print(head.value, end="\t")
        return head
    newhead = reverse(head.next)
    head.next.next = head
    head.next = None
    print(head.value, end="\t")


if __name__ == "__main__":
    nums = [1, 2, 3, 4, 5]
    head = createLink(nums=nums)
    reverse(head)

空间复杂度 $O (1)$

4. 由前序和中序遍历求树结构[***]

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回

第一种递归

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if not pre:
            return None
        rootval = pre[0]
        root = TreeNode(rootval)
        index = tin.index(rootval)
        root.left = self.reConstructBinaryTree(pre[1:index+1], tin[:index])
        root.right = self.reConstructBinaryTree(pre[index+1:], tin[index+1:])
        return root

第二种递归

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def reConstructBinaryTree(pre, tin):
        # write code here
        def helper(left, right):
            nonlocal preidx
            if left == right:
                return None
            rootval = pre[preidx]
            root = TreeNode(rootval)
            idx = tin.index(rootval)
            preidx += 1
            root.left = helper(left, idx)
            root.right = helper(idx+1, right)
            return root
        preidx = 0
        return helper(0, len(tin))

# 以下为测试程序
preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]
root = reConstructBinaryTree(preorder, inorder)
# 前序遍历
def preor(head):
    if head != None:
        print(head.val, end="\t")
        preor(head.left)
        preor(head.right)
# 中序遍历
def inor(head):
    if head != None:
        inor(head.left)
        print(head.val, end="\t")
        inor(head.right)

preor(root)
print()
inor(root)

方法3

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        def recursion(preorder, inorder):
            if not inorder or not preorder:
                return None
            node = preorder.pop(0)
            idx = inorder.index(node)
            left = inorder[:idx]
            right = inorder[idx+1:]
            root = TreeNode(node)
            root.left = recursion(preorder, left)
            root.right = recursion(preorder, right)
            return root
        return recursion(preorder, inorder)

5. 用两个堆栈实现队列[Done]

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型

class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        result = self.stack2.pop()
        while self.stack2:
            self.stack1.append(self.stack2.pop())
        return result

方法2
用stack1专门用于push, stack2专门用于pop

class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        # 如果stack2为空， 将stack1元素放到stack2中
        if not self.stack2:
        	while self.stack1:
            	self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

6. 旋转数组的最小数字[**][Done]

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

注意：
题目描述的并不好，题目实际意思为：一个递增数组，将其按上面题目描述的方式旋转，给出旋转后的数组，求该数组的最小值

思路1：暴力法
由于为旋转前数组是递增的，因此 $a [i] > a [i - 1]$ ；当数组旋转后，即最小值放到了中间某一位置，因此若存在 $a [i] < a [i - 1]$ ，则 $a [i]$ 是最小值

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 0
        for i in range(1, len(rotateArray)):
            if rotateArray[i]<rotateArray[i-1]:
                return rotateArray[i]
        # 若未旋转，返回第一个元素，即最小值
        return rotateArray[0]

时间复杂度： $O (n)$

思路2：二分法
每次都用中间元素与最右边元素相比较，如果中间元素大于最右边元素，则最小值在中间元素的右边，如果中间元素小于最右边元素，最小值在中间元素的左边。
时间复杂度为 $O (l o g n)$

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

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 0
        left = 0
        right = len(rotateArray)-1
        def bisearch(left, right):
            if left == right:
                return rotateArray[left]
            mid = (left+right)//2
            if rotateArray[mid]>rotateArray[right]:
                left = mid+1
            else:
                right = mid
            return bisearch(left,right)
        return bisearch(left, right)

7. 斐波那契数列[Done]

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

提示
斐波那契数列： $F (1) = 1 ， F (2) = 1, F (n) = F (n - 1) + F (n - 2) （ n >= 3 ， n \in N * ）$

代码1：

class Solution:
    def Fibonacci(self, n):
        # write code here
        if n == 0:
            return 0
        if n == 1 or n==2:
            return 1
        dp = [0]*(n+1)
        dp[1] = 1
        dp[2] =1
        for i in range(3, n+1):
            dp[i] = dp[i-2]+dp[i-1]
        return dp[n]

时间复杂度： $O (n)$
空间复杂度： $O (n)$

代码2（对代码1的改进）

class Solution:
    def Fibonacci(self, n):
        # write code here
        if n == 0:
            return 0
        if n == 1 or n==2:
            return 1
        a = b = 1
        for i in range(3, n+1):
            a, b = b, a+b
        return b

时间复杂度 $O (n)$
空间复杂度 $O (1)$

8. 跳台阶[Done]

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路
每次跳都有两种选择，即跳一个台阶和跳两个台阶，则青蛙到第n个台阶的跳法为：从第 $n - 1$ 台阶跳一个台阶和第 $n - 2$ 台阶跳2个台阶，总的跳法个数为 $f (n - 1) + f (n - 2)$ ， $f (n)$ 表示跳到第n个台阶的跳法数。注意 $f (0) = 0, f (1) = 1, f (2) = 2$

class Solution:
    def jumpFloor(self, number):
        # write code here
        if number <= 2:
            return number
        else:
            a, b = 1, 2
            for i in range(3, number+1):
                a, b = b, a+b
            return b

时间复杂度 $O (n)$

9.变态跳台阶[Done]

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路

f(n) = n,    n<=2
f(n) = f(1)+f(2)+...+f(n-1)+1,     n>2

代码1

class Solution:
    def jumpFloorII(self, number):
        # write code here
        if number <= 2:
            return number
        else:
            dp = [0]*(number+1)
            dp[1] = 1
            dp[2] = 2
            for i in range(3, number+1):
                dp[i] = sum(dp[:i])+1
            return dp[number]

代码1改进

f(n) = f(1)+f(2)+...+f(n-1)+1,     n>2

f(n-1) = f(1)+f(2)+...+f(n-2)+1,     n>2

所以

f(n) = f(1)+f(2)+...+f(n-2)+f(n-1)+1 = f(n-1)-1+f(n-1)+1 = 2f(n-1)       n>2
f(n) = 2^2f(n-2) = 2^3f(n-3)= ...= 2^(n-2)f(n-(n-2))=2^(n-2)f(2) = 2^(n-1)

class Solution:
    def jumpFloorII(self, number):
        # write code here
        if number <= 2:
            return number
        else:
            return 2**(number-1)

10. 矩形覆盖[**][Done]

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
比如n=3时，2*3的矩形块有3种覆盖方法：
在这里插入图片描述
思路
n = 1 时，return 1
n = 2时， return 2
当n大于等于3时，假设n = k时，此时覆盖方法可以是n=k-1的覆盖方法后面再加一个竖着放的长方体，也可以是n = k-2时覆盖方法后面横着放2个长方体（不能竖着放两个长方体，因为竖着放一个就和k-1相同了）
因此，当n>2时：
$f (n) = f (n - 1) + f (n - 2)$

class Solution:
    def rectCover(self, number):
        # write code here
        if number <= 2:
            return number
        else:
            a, b = 1, 2
            for i in range(3, number+1):
                a, b = b, a+b
            return b

11. 二进制中1的个数[***][DONE]

题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

思路
如果整数不等于0，那么该整数的二进制表示中至少有1位是1。

先假设这个数的最右边一位是1，那么该数减去1后，最右边一位变成了0，其他位不变。

再假设最后一位不是1而是0，而最右边的1在第m位，那么该数减去1，第m位变成0，m右边的位变成1，m之前的位不变。

上面两种情况总结，一个整数减去1，都是把最右边的1变成0，如果它后面还有0，那么0变成1。那么我们把一个整数减去1,与该整数做位运算，相当于把最右边的1变成了0，比如1100与1011做位与运算，得到1000。那么一个整数中有多少个1就可以做多少次这样的运算。

class Solution:
    def NumberOf1(self, n):
        # write code here
        count = 0
        # 如果n是负数，将其补码变成普通的数（无符号数）
        if n < 0:
            n = n & 0xffffffff
        while n:
            n = (n-1)&n
            count = count + 1
        return count

当n<0时为何要进行n = n & 0xffffffff?
如下python计算结果，而对于java等编程语言会自动去除最高的溢出位，故计算结果正确，而python不会去除最高溢出位，故计算错误
在这里插入图片描述

12. 数的整次方[DONE]

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0

class Solution:
    def Power(self, base, exponent):
        # write code here
        if exponent == 0:
            return 1
        if base == 0:
            return 0
        result = 1
        n = abs(exponent)
        while n:
            result *= base
            n -= 1
        return result if exponent >0 else 1/result

如上时间复杂度为 $O (n)$ ，如果要求时间复杂度为 $O (l o g n)$ ，则使用二分法实现如下

def power(base, exponent):
    if exponent == 0:
        return 1
    if base == 0:
        return 0
    n = abs(exponent)
    result = help(base, n)
    return result if exponent > 0 else 1/result


def help(a, b):
    if b == 1:
        return a
    mid = b//2
    rest = b % 2
    if rest == 1:
        return help(a, mid)*help(a, mid)*a
    else:
        return help(a, mid)*help(a, mid)


if __name__ == "__main__":
    print(power(2, -3))

13. 调整数组顺序使奇数位于偶数前面[**][ Done]

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

程序1：使用两个额外空间

class Solution:
    def reOrderArray(self, array):
        # write code here
        jishu = []
        oushu = []
        for x in array:
            if x%2 == 0:
                oushu.append(x)
            else:
                jishu.append(x)
        return jishu+oushu

程序2：不使用额外空间

class Solution:
    def reOrderArray(self, array):
        # write code here
        p1 = 0
        while p1 < len(array):
            # 从头开始找到第一个偶数
            while p1<len(array) and array[p1]%2 != 0:
                p1 += 1
            p2 = p1 + 1
            # 在偶数后找到第一个奇数
            while p2<len(array) and array[p2]%2 == 0:
                p2 += 1
            # 将第一个奇数查到偶数的位置
            if p2 < len(array):
                array.insert(p1, array.pop(p2))
            else:
                break
        return array

程序3

def resort(data):
	for i in range(1, len(data)):
		if data[i]%2 != 0 and data[i-1]%2==0:
			j = i-1
			temp = data[i]
			while j>=0 and data[j]%2 == 0:
				data[j+1] = data[j]
				j -= 1
			data[j+1] = temp
	return data

data = [1,2,3,4,5,6,7,9]
print(resort(data))

14.输出链表中倒数第K个节点[***][Done]

输入一个链表，输出该链表中倒数第k个结点。

程序1 使用额外空间

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        # 若链表为空链表或k值<=0：返回None
        if head == None or k <= 0:
            return None
        result = []
        ptr = head
        while ptr != None:
            result.append(ptr)
            ptr = ptr.next
        # 若k值超出链表的长度，返回None
        if len(result)<k:
            return None
        return result[-k]

程序2：程序1的改进，不使用额外空间
假设链表中的节点数大于等于k个，那么一定会存在倒数第k个节点，首先使用一个快指针先往前走k步，然后两个指针每次走一步，两个指针之间始终有k的距离，当快指针走到末尾时，慢指针所在的位置就是倒数第k个节点

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        if head == None or k <= 0:
            return None
        p = q = head
        t = 0
        while p!=None and t<k:
            p = p.next
            t += 1
        # 判断k是否超过链表长度
        if t < k:
            return None
        while p!=None:
            p = p.next
            q = q.next
        return q

15. 链表反转[Done]

输入一个链表，反转链表后，输出新链表的表头。

class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if pHead == None:
            return None
        p = pHead
        r = None
        while p!=None:
            q = p
            p = p.next
            q.next = r
            r = q
        return q

递归方法

data = [1,2,3,4,5,6]

class ListNode:
	def __init__(self, val):
		self.val = val
		self.next = None

# 构建链表
head = ListNode(data[0])
ptr = head
for val in data[1:]:
	node = ListNode(val)
	ptr.next = node
	ptr = ptr.next

# 链表反转
def inverse(head):
	if head == None or head.next == None:
		return head
	# 一直循环到链尾
	newHead = inverse(head.next)
	# 翻转链表指向
	head.next.next = head
	head.next = None
	return newHead

# 打印链表
newHead = inverse(head)
while newHead != None:
	print(newHead.val, end="\t")
	newHead = newHead.next

16.合并两个排序的链表[Done]

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

def Merge(self, pHead1, pHead2):
        # write code here
        result = ListNode(0)
        reHead = result
        while pHead1 and pHead2:
            if pHead1.val>pHead2.val:
                result.next = pHead2
                pHead2 = pHead2.next
                result = result.next
            else:
                result.next = pHead1
                pHead1 = pHead1.next
                result = result.next
        if pHead1:
            result.next = pHead1
        elif pHead2:
            result.next = pHead2
        return reHead.next

17. 树的子结构[***]

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路
采用递归的思路，单独定义一个函数判断B是不是从当前A的根节点开始的子树，这里判断是不是子树也需要一个递归的判断。如果是，则返回True，如果不是，再判断B是不是从当前A的根节点的左子节点或右子节点开始的子树

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
	# 判断从当前节点算起，是不是子树
    def isSubtree(self, root1, root2):
    	# 因为是判读root2是不是root1的子结构，因此当root2=None时代表root2已经到遍历到末尾，此时返回True 
        if not root2:
            return True
        # 若root2还没遍历完，root1已经遍历完，直接返回False
        if not root1:
            return False
        if root1.val != root2.val:
            return False
        return self.isSubtree(root1.left, root2.left) and self.isSubtree(root1.right, root2.right)
    
    # 主函数
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if not pRoot1 or not pRoot2:
            return False
        result = False
        # 判断root2是否为root1为开始节点的子树
        if pRoot1.val == pRoot2.val:
            result = self.isSubtree(pRoot1, pRoot2)
         # 若不是以root1为开始节点的子树，接着判断是否为root1.left为开始节点的子树
        if not result:
            result = self.HasSubtree(pRoot1.left, pRoot2)
        # 若上述两个条件都不满足，判断是否为root1.right为开始节点的子树
        if not result:
            result = self.HasSubtree(pRoot1.right, pRoot2)
        return result

18. 二叉树的镜像[***][Done]

操作给定的二叉树，将其变换为源二叉树的镜像
在这里插入图片描述

交换左右节点

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

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root == None:
            return None
        else:
            root.left, root.right = self.Mirror(root.right), self.Mirror(root.left)
        return root

19.顺时针打印矩阵[Done]

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

思路：
每打印matrix一行后就将matrix逆时针旋转90度

class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        if not matrix:
            return None
        result = []
        while matrix:
            result += matrix.pop(0)
            if not matrix:
                break
            matrix = self.turn(matrix)
        return result
    
    def turn(self, matrix):
        result = []
        for i in range(len(matrix[0])):
            temp = []
            for j in range(len(matrix)):
                temp.append(matrix[j][i])
            result.append(temp)
        result.reverse()
        return result

20. 包含min的栈[*]

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

class Solution:
    def __init__(self):
        self.stack = []
        self.minnum = []
    def push(self, node):
        # write code here
        self.stack.append(node)
        if not self.minnum or node<self.minnum[-1]:
            self.minnum.append(node)
        else:
            self.minnum.append(self.minnum[-1])
    def pop(self):
        # write code here
        self.minnum.pop()
        if self.stack:
            return self.stack.pop()
        else:
            return None
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        if self.minnum:
            return self.minnum[-1]
        else:
            return None

21(2). 包含max的队列

使用两个栈来实现

class Queue:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
        self.stack1_max = []
        self.stack2_max = []

    # 入队
    def enqueue(self, val):
        self.stack1.append(val)
        if not self.stack1_max:
            self.stack1_max.append(val)
        else:
            self.stack1_max.append(max(self.stack1_max[-1], val))

    # 出队
    def dequeue(self):
        if self.stack2:
            self.stack2_max.pop()
            return self.stack2.pop()
        else:
            while self.stack1:
                temp = self.stack1.pop()
                self.stack2.append(temp)
                if not self.stack2_max:
                    self.stack2_max.append(temp)
                else:
                    self.stack2_max.append(max(self.stack2_max[-1], temp))
                self.stack1_max.pop()
            self.stack2_max.pop()
            return self.stack2.pop()

    # 最大值
    def maxNum(self):
        if self.stack2 and (not self.stack1):
            return self.stack2_max[-1]
        elif self.stack1 and (not self.stack2):
            return self.stack1_max[-1]
        else:
            return self.stack1_max[-1] if self.stack1_max[-1] > self.stack2_max[-1] else self.stack2_max[-1]

if __name__ == "__main__":
    queue = Queue()
    queue.enqueue(1)
    queue.enqueue(5)
    queue.enqueue(4)
    print(queue.maxNum())

21. 栈的压入弹出顺序[Done]

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

思路1
栈的特点是先进后出，所以只需考虑出栈元素的顺序是否先进后出；当然存在一些小细节，以实际例子讲解：设pushV = [1,2,3,4,5], popV = [4,5,3,2,1], 那么popV[0] = 4, 我们只需考虑pushV中[1,2,3,4]这几个数字的出栈顺序，而popV[1]=5>4, 而4前面的数字顺序都考虑过了，我们只需考虑（4， 5]，即只有一个数字5的顺序，再往后，3，2，1 都比5小我们已经考虑过其出栈顺序，故不需再考虑。

class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        maxnum = -float("inf")
        # 遍历popV的每个元素
        for i in range(len(popV)):
            # 如果popV中元素在pushV中不存在，直接False
            if popV[i] not in pushV:
                return False
            # 该步骤是用于提前结束循环
            if popV[i] < maxnum:
                continue
            else:
                maxnum = popV[i]
            # 记录起始索引
            idx1 = 0 if i ==0 else pushV.index(popV[i-1])+1
            index = pushV.index(popV[i])
            
            temp = pushV[idx1:index+1]
            # 检查出栈顺序
            for i in range(len(temp)-1):
                if popV.index(temp[i])<popV.index(temp[i+1]):
                    return False
        return True

思路2：使用辅助栈

class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        help = []
        for x in pushV:
            help.append(x)
            while help and help[-1] == popV[0]:
                help.pop()
                popV.pop(0)
        if help:
            return False
        else:
            return True

22.从上往下打印二叉树[Done]

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

思路：二叉树的层序遍历

class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        if not root:
            return []
        # write code here
        nodes = [root]
        result = []
        while nodes:
            node = nodes.pop()
            result.append(node.val)
            if node.left:
                nodes.insert(0, node.left)
            if node.right:
                nodes.insert(0, node.right)
        return result

23. 二叉搜索树的后序遍历序列[***]

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

思路：
如果序列的长度小于2，那一定是后序遍历的结果。根据BST和后序遍历的性质，遍历结果的最后一个一定是根节点，那么序列中前面一部分小于根节点的数是左子树，后一部分是右子树，递归进行判断。

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if len(sequence) == 0:
            return False
        return self.help(sequence)
    def help(self, sequence):
        if len(sequence) <=2:
            return True
        flag = sequence[-1]
        i = 0
        while sequence[i]<flag:
            i += 1
        index = i
        while i<len(sequence)-1:
            if sequence[i]<flag:
                return False
            else:
                i+=1
        return self.help(sequence[:index]) and self.help(sequence[index:-1])

24. 二叉树中和为某一值得路径[***]

题目描述
输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    def FindPath(self, root, expectNumber):
        if not root:
            return []
        # write code here
        self.result = []
        self.help(root, expectNumber,[])
        return self.result
    def help(self, root, number, res):
        if not root.left and not root.right:
            if root.val == number:
                res += [root.val]
                self.result.append(res)
        if root.left:
            self.help(root.left, number-root.val, res+[root.val])
        if root.right:
            self.help(root.right, number-root.val, res+[root.val])

# -*- 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):
        # write code here
        self.result = []
        self.temp = []
        if not root:
            return []
        self.help(root, expectNumber)
        return self.result
    
    def help(self, root, num):
        if not root.left and not root.right:
            self.temp.append(root.val)
            if sum(self.temp) == num:
                self.result.append(self.temp[:])
            return
        self.temp.append(root.val)
        if root.left:
            self.help(root.left, num)
            self.temp.pop()
        if root.right:
            self.help(root.right, num)
            self.temp.pop()

使用广度优先bfs
总体思想：每pop出一个node后记录到当前node为止路径和并加入到acc中，使用字典记录每个节点的父节点

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

import collections
class Solution:
    def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        acc, nodes = [0], [root]
        result = []
        parent = collections.defaultdict(lambda: None)

        if not root:
            return []
		
		# 使用字典来记录路径
        def findPath(node):
            temp = []
            while node:
                temp.append(node.val)
                node = parent[node]
            temp = temp[::-1]
            return temp
        
        while nodes:
            node = nodes.pop(0)
            rec = acc.pop(0)
            if node.left == None and node.right == None and node.val == target-rec:
                path = findPath(node)
                result.append(path)
            else:
            	# 记录截止到当前节点，路径累加和
                rec += node.val
                if node.left:
                    parent[node.left] = node
                    acc.append(rec)
                    nodes.append(node.left)
                if node.right:
                    parent[node.right] = node
                    acc.append(rec)
                    nodes.append(node.right)
        return result

25. 复杂链表的复制[*]

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

# -*- 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):
        # write code here
        if pHead == None:
            return None
        newhead = RandomListNode(pHead.label)
        newhead.random = pHead.random
        newhead.next = self.Clone(pHead.next)
        return newhead

26. 二叉树搜索和双向链表[***]

题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路1：暴力法，中序遍历取出所有的节点，然后将各个节点连接

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        if not pRootOfTree:
            return None
        # write code here
        self.nodes = []
        self.inorder(pRootOfTree)
        print(self.nodes)
        i, j = 0, 1
        while j < len(self.nodes):
            self.nodes[j].left = self.nodes[i]
            self.nodes[i].right = self.nodes[j]
            i += 1
            j += 1
        self.nodes[0].left = None
        self.nodes[-1].right = None
        return self.nodes[0]
            
    def inorder(self, pRootOfTree):
        if pRootOfTree != None:
            self.inorder(pRootOfTree.left)
            self.nodes.append(pRootOfTree)
            self.inorder(pRootOfTree.right)

思路2：对思路1的改进
从中序遍历得到的第一个节点开始构造链表，定义两个辅助节点listHead(链表头节点)、listTail(链表尾节点)。listHead用于记录链表的头节点，用于最后算法的返回；listTail用于定位当前需要更改指向的节点

class Solution:
    def Convert(self, pRootOfTree):
        if not pRootOfTree:
            return None
        # write code here
        self.listhead = None
        self.listtail = None
        self.inorder(pRootOfTree)
        return self.listhead
            
    def inorder(self, pRootOfTree):
        if pRootOfTree == None:
            return None
        self.inorder(pRootOfTree.left)
        if not self.listhead:
            self.listhead = pRootOfTree
            self.listtail = pRootOfTree
        else:
            self.listtail.right = pRootOfTree
            pRootOfTree.left = self.listtail
            self.listtail = pRootOfTree
        self.inorder(pRootOfTree.right)

27. 字符串排列[***]

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

class Solution:
    def Permutation(self, ss):
        if not ss:
            return []
        # write code here
        length = len(ss)
        isused = [False]*len(ss)
        temp = []
        result = []
        self.help(ss, isused, temp, result)
        return result
    
    def help(self, ss, isused, temp, result):
        if len(temp) == len(ss):
            te = "".join(temp)
            if te not in result:
                result.append("".join(temp))
        for i in range(len(ss)):
            if isused[i]:
                continue
            else:
                temp.append(ss[i])
                isused[i] = True
            self.help(ss, isused, temp, result)
            temp.pop()
            isused[i] = False

def digui(s, res, result, isused):
	if len(res)==len(s):
		result.append(res.copy())

	for i in range(len(s)):
		if not isused[i]:
			res += s[i]
			isused[i] = True
			digui(s, res, result, isused)
			isused[i] = False
			res.pop()

result = []
s = "abc"
isused = [False]*len(s)
digui(s, [], result, isused)
print(result)

思路2：
把字符串分为两个部分：字符串的第一个字符，第一个字符后面的所有字符。1.求所有可能出现在第一个位置的字符，用索引遍历。2.求第一个字符以后的所有字符的全排列。将后面的字符又分成第一个字符以及剩余字符。

class Solution:
    def Permutation(self, ss):
        if not ss:
            return []
        if len(ss) == 1:
            return [ss]
        path = ""
        result = []
        self.helper(ss, path, result)
        return sorted(list(set(result)))
    
    def helper(self, ss, path, result):
        if not ss:
            result.append(path)
        for i in range(len(ss)):
            self.helper(ss[:i]+ss[i+1:], path+ss[i], result)

28. 数组中出现次数超过一半的数字[Done]

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

思路1：暴力法

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        num = len(numbers)/2
        for x in set(numbers):
            if numbers.count(x)>num:
                return x
        else:
            return 0

时间复杂度： $O (n)$
空间复杂度： $O (n)$
思路二：中位数法
如果存在一个数的出现次数大于数组长度的一半，那么经过排序后，数组的中位数必定是该数

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        numbers.sort()
        temp = numbers[len(numbers)//2]
        if numbers.count(temp)>len(numbers)//2:
            return temp
        else:
            return 0

时间复杂度 $O (n l o g n)$
空间复杂度 $O (1)$
摩尔投票法
我们来看一种现实中的投票场景：班级要开始选班长，要求半数以上通过，选出来的就是班长，我们先来看一种简单的情况：假如只有2个人A和B竞争班长这一职位。那么，在大家投票后，我们从投票箱中取数后，可以这样统计：
先抽一张票，如果是A，则记录当前胜利者为A，票数:1
再抽一张票，如果是A，则记录当前胜利者为A，票数:2
再抽一张票，如果是B，则抵消，记录当前胜利者为A，票数:1
再抽一张票，如果是B，则抵消，记录无当前胜利者
再抽一张票，如果是A，则记录当前胜利者为A，票数:1

如上只是两方进行PK, 那么，当候选人为多人时，也可以使用类似的思路，这里的前提条件就是：一定存在多余半数票的候选人。当多方进行PK时，占据着半数以上票数的班长，可以任性地抵消任何人的票，而且其他人之间的相互抵消也不会撼动班长的位置。

def solution(nums):
    length, count = len(nums), 0
    for i in range(length):
        if count == 0:
            value = nums[i]
        if value == nums[i]:
            count += 1
        else:
            count -= 1
    return value

print(solution([1,1,1,2,2,3,3,1, 1]))

时间复杂度: $O (n)$
空间复杂度: $O (1)$

29. 最小的K个数[***][Done]

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

思路
先使用堆排序对给定数据的前k个数进行排序（使用最大堆），然后遍历data[k:]，如果data[j]小于堆根，将该数替换成堆根。最后得到的堆就是最小的K个数

class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        if k<=0 or len(tinput)<k:
            return []
        temp = tinput[:k]
        self.buildMaxHeap(temp)
        for i in range(k, len(tinput)):
            if tinput[i]<temp[0]:
                temp[0]=tinput[i]
                self.heapify(temp, 0)
        return sorted(temp)
    # 建立堆排序
    def buildMaxHeap(self, data):
        global length
        length = len(data)
        for i in range(len(data)//2, -1, -1):
            self.heapify(data, i)
            
    def heapify(self, data, i):
        left = 2*i+1
        right = 2*i+2
        largest = i
        if left < length and data[left]>data[largest]:
            largest = left
        if right < length and data[right]>data[largest]:
            largest = right
        if largest != i:
            data[largest], data[i] = data[i], data[largest]
            self.heapify(data, largest)

拓展

# 1. 求第k小的数：利用buildmaxheap构建最小堆，主函数如下：
def stackSort(data, k):
    builMaxheap(data)
    global length
    count = 0
    for i in range(len(data)-1, 0, -1):
    	# 通过count来取第k小的数
        count += 1
        if count == k:
            break
        data[0], data[i] = data[i], data[0]
        length -= 1
        heapfy(data, 0)
    return data[0]

30. 连续子数组最大和[***][Done]

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

思路
如果数组里所有的整数都是负数，那么选择最大的数即可，因为越累加越小。
正负数都有的情况，需要两个变量，一个是global_max,从全局来看，每次最大的是什么组合，另一个是local_max，和global_max相比，更新global_max。

class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        if max(array)<0:
            return max(array)
        local_max, global_max = 0, 0
        for x in array:
        	# local_max每次都从一个正数开始加直到加到小于零，再从另外一个正数加
            local_max = max(0, local_max+x)
            global_max = max(global_max, local_max)
        return global_max

动态规划
dp[i]表示以索引i结尾的连续数组的最大和，那么

dp[i] = max(dp[i-1]+nums[i], nums[i])

动态规划需要 $O (n)$ 的空间复杂度，将程序稍作更改可以变成如下形式

def solution(nums):
    local_max = nums[0]    # local_max记录已当前nums[i]结尾的连续数组的最大和
    maxsum = nums[0]
    for i in range(1, len(nums)):
        local_max = max(local_max+nums[i], nums[i])
        maxsum = max(maxsum, local_max)
    return maxsum

print(solution([-1, 2, 3, -4, 5]))

31.从1到n的整数中1出现的次数

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

思路1：暴力法

class Solution:
    def NumberOf1Between1AndN_Solution(self, n):
        # write code here
        result = 0
        for x in range(1, n+1):
            result += self.helper(x)
        return result
            
    
    def helper(self, x):
        count = 0
        while x>0:
            if x%10 == 1:
                count += 1
            x = x//10
        return count

解释：leetcode

总体方法是：计算每一位出现一的次数，最后总和；将 1 ~ n 的个位、十位、百位、…的 1 出现次数相加，即为 1 出现的总次数

在这里插入图片描述

cur = 0
此时该位1 的出现次数只由高位 high决定，如以 n = 2304为例，此时十位出现一的情况为：高位0～22（共23个数字）低位0～9（共10个数字）组合：共计230种情况，也即 $hi g h * d i g i t$
cur = 1
此位 1 的出现次数由高位 high 和低位 low 共同决定，以2314为例，此时十位出现一的情况为：（1）高位0～22（共23种选择），低位0～9（10种选择）组合共230种情况；（2）高位23一种选择，低位0～4（5种选择）组合共5种情况；两者加起来共235种情况，就是 $hi g h * d i g i t + l o w + 1$
cur > 1
此时该位 1 的出现次数只由高位 high 决定，以2354为例，此时十位出现一的情况为：（1）高位取值0～23（共24种选择），低位取值0～9，共10种选择，总共240种，即 $(hi g h + 1) * d i g i t$

class Solution:
    def countDigitOne(self, n: int) -> int:
        high, cur, low, res, digit = n//10, n%10, 0, 0, 1
        while high != 0 or cur != 0:
            if cur == 0:
                res += high*digit
            elif cur == 1:
                res += high*digit+low+1
            else:
                res += (high+1)*digit
            
            low = low+cur*digit
            cur = high%10
            high = high//10
            digit = digit*10
        return res

时间复杂度：循环次数为遍历所有位数即 $l o g n$

32. 把数组排成最小的数[***]

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

from functools import cmp_to_key
def PrintMinNumber(numbers):
    if not len(numbers):
        return ""
    arr = [str(x) for x in numbers]
    arr.sort(key = cmp_to_key(lambda x,y:int(x+y)-int(y+x)))
    return int("".join(arr))
numbers = [3,32,321]
print(PrintMinNumber(numbers))

注意：上述代码基于python3实现，python3中sort()方法与python2中不一样，区别见python中sort函数;python2实现如下：

class Solution:
    def PrintMinNumber(self, numbers):
        if not len(numbers):
            return ""
        arr = [str(x) for x in numbers]
        arr.sort(lambda x,y:cmp(x+y,y+x))
        return int("".join(arr))

总而言之，此题就是一个排序问题，只是在两个数大小方面需要重新定义

若拼接字符串 x + y > y + x ，则 x “大于” y ；
反之，若 x + y < y + x ，则 x “小于” y

# 小于
def less(x, y):
    if x+y<y+x:
        return True
    return False

# 大于
def great(x, y):
    if x+y > y+x:
        return True
    return False

# 快速排序
def quickSort(data, left, right):
    if left<right:
        left_index = left+1
        while left_index<right and less(data[left_index], data[left]):
            left_index += 1
        
        right_index = right-1
        while right_index>=0 and great(data[right_index], data[left]):
            right_index -= 1
        
        while left_index<right_index:
            data[left_index], data[right_index] = data[right_index], data[left_index]

            left_index += 1
            while left_index<right and less(data[left_index], data[left]):
                left_index += 1
            
            right_index -= 1
            while right_index>=0 and great(data[right_index], data[left]):
                right_index -= 1
        
        data[left], data[right_index] = data[right_index], data[left]
        quickSort(data, left, right_index)
        quickSort(data, right_index+1, right)
    return data

data = ["3", "32", "321"]
data = quickSort(data, 0, len(data))
print("".join(data))

33. 丑数

题目描述
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路
因为丑数只包含质因子2，3，5；因此我们只需将2，3，5两两相乘，并将相乘的结果再与2，3，5相乘，这些乘法结果都是丑数。关键问题就是如何按从小到大的顺序写出丑数，我们可以这样做，每次都用2，3，5来乘结果res中的数，每次只选择最小的数加入res中，具体做法见程序。

class Solution:
    def GetUglyNumber_Solution(self, index):
        # write code here
        if index <=0:
            return 0
        res = [1]
        a,b,c = 0, 0, 0
        while len(res)<index:
            minNext = min(res[a]*2, res[b]*3, res[c]*5)
            res.append(minNext)
            while res[a]*2 <= minNext:
                a += 1
            while res[b]*3 <= minNext:
                b += 1
            while res[c]*5 <= minNext:
                c += 1
        return res[-1]

34. 第一个只出现一次的字符

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        for x in s:
            if s.count(x)==1:
                return s.index(x)
        return -1

方法二：利用ascii码构建数组

def solution(string):
    dp = [0]*58      # 58 = 122-65+1
    for x in string:
        index = ord(x)-65     # A-Z对应的ASCII码为65-90，a-z对应的ASCII码值为97-122
        dp[index] += 1
    
    for i in range(len(dp)):
        if dp[i] == 1:
            asc = i+65
            char = chr(asc)
            return char
    return None

print(solution("ababccdede"))

35. 数组中的逆序对[][**]

题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

思路
使用二分法；详见剑指offer学习

class Solution:
    def InversePairs(self, data):
        # write code here
        if len(data)>1:
            mid = len(data)//2
            left = data[:mid]
            right = data[mid:]
            left_count = self.InversePairs(left)%1000000007
            right_count = self.InversePairs(right)%1000000007
            i , j, k, count = len(left)-1, len(right)-1, len(data)-1, 0
            while i>=0 and j>=0:
                if left[i] <= right[j]:
                    data[k] = right[j]
                    j -= 1
                    k -= 1
                else:
                    data[k] = left[i]
                    count += (j+1)
                    i -= 1
                    k -= 1
            if i>=0:
                data[:i+1] = left[:i+1]
            if j >= 0:
                data[:j+1] = right[:j+1]
            return (count + left_count + right_count)%1000000007
        else:
            return 0

36. 两个链表的第一个公共节点

题目描述
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

思路
设置两个指针，一个从headA开始遍历，遍历完headA再遍历headB，另一个从headB开始遍历，遍历完headB再遍历headA，如果有交点，两个指针会同时遍历到交点处。

class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        ptr1 = pHead1
        ptr2 = pHead2
        while ptr1 != ptr2:
            if ptr1 == None:
                ptr1 = pHead2
            else:
                ptr1 = ptr1.next
            if ptr2 == None:
                ptr2 = pHead1
            else:
                ptr2 = ptr2.next
        return ptr2

37. 数字在排序数组中的次数

统计一个数字在排序数组中出现的次数

思路1：暴力法

class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        count = 0
        for i in range(len(data)):
            if data[i] == k:
                count += 1
        return count

思路2：双指针法


class Solution:
    def GetNumberOfK(self, data, k):
        if not data:
            return 0
        # write code here
        i, j = 0, len(data)-1
        while i < j and data[i]!=data[j]:
            if data[i]<k:
                i += 1
            if data[j]>k:
                j -= 1
        if data[i] != k:
            return 0
        else:
            return j-i+1

时间复杂度O(n)

二分法
分别通过二分法获取左右两个边界

class Solution:
    def GetNumberOfK(self , nums: List[int], k: int) -> int:
        # write code here
        if not nums:
            return 0
        left = self.get_boundary_index(nums, k, "left")
        right = self.get_boundary_index(nums, k, "right")
        if left == right == -1:
            return 0
        else:
            return right-left+1

    def get_boundary_index(self, nums, k, task):
        left, right = 0, len(nums)-1
        if len(nums) == 1 and nums[0] == k:
            return 0
        while left < right:
            mid = (left+right)//2
            if nums[mid] < k:
                left = mid+1
            elif nums[mid] > k:
                right = mid-1
            else:
                if task == "left":
                    right = mid
                else:
                    left = mid
            
            if nums[left] == k and task == "left":
                return left

            if nums[right] == k and task == "right":
                return right
            
        return -1

38. 二叉树的深度

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路1：递归

class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        res = []
        self.deep(pRoot, 0, res)
        return max(res)
    def deep(self, root, count, res):
        if root != None:
            count += 1
            self.deep(root.left, count, res)
            self.deep(root.right, count, res)
        if root == None:
            res.append(count)

思路2

class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        if pRoot == None:
            return 0
        else:
            return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right))+1

39.平衡二叉树[Done]

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code her
        if pRoot == None:
            return True
        else:
            if abs(self.height(pRoot.left)-self.height(pRoot.right))>1:
                return False
            return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
    def height(self, root):
        if root == None:
            return 0
        else:
            return max(self.height(root.left), self.height(root.right))+1

40. 数组中只出现一次的数字

题目描述
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

方法1：暴力法

class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        res = []
        for x in set(array):
            if array.count(x) == 1:
                res.append(x)
        return res

方法2

这个问题可以可以使用用异或的性质解决。异或的性质：对于整数a,有

                     （1） a^a=0

                     （2）a^0=a

                     （2）a^b^c=a^(b^c)=(a^c)^b

  利用以上的性质，上面的题目的解法为：

(1)对于出现两次的元素，使用“异或”操作后结果肯定为0，那么我们就可以遍历一遍数组，对所有元素使用异或操作，那么得到的结果就是两个出现一次的元素的异或结果
(2)因为这两个元素不相等，所以异或的结果肯定不是0，也就是可以再异或的结果中找到1位不为0的位，例如异或结果的最后一位不为0。
(3)这样我们就可以最后一位将原数组元素分为两组，一组该位全为1，另一组该位全为0。
(4)再次遍历原数组，最后一位为0的一起异或，最后一位为1的一起异或，两组异或的结果分别对应着两个结果。

# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        res = 0
        for i in array:
            res = res^i
        flag = 1
        while flag & res == 0:
            flag = flag<< 1
        res1 = 0
        res2 = 0
        for x in array:
            if flag&x == 0:
                res1 = res1^x
            else:
                res2 = res2^x
        return [res1, res2]

41. 和为s的连续正数序列

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

思路
使用双指针，初始化 i= 1， j = 2；然后当将 i 到 j 的数求和，若小于 tsum, 将 j加1，直到大于 tsum ，然后改变 i 指针值，将其加1；

class Solution:
    def FindContinuousSequence(self, tsum):
        # write code here
        i = 1
        j = 2
        cursum = i + j
        res = []
        while i <= tsum//2:
            if cursum == tsum:
                res.append(range(i, j+1))
                j += 1
                cursum += j
            elif cursum > tsum :
                cursum -= i
                i += 1
            else:
                j += 1
                cursum += j
        return res

42. 和为S的两个数字[Done]

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

思路1
暴力法： $O(N^2)$

class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        result = []
        maxsum = float("inf")
        for i in range(len(array)):
            for j in range(i, len(array)):
                if array[i] + array[j] == tsum:
                    if array[i]*array[j] < maxsum:
                        maxsum = array[i]*array[j]
                        result = [array[i], array[j]]
        return result

思路2：双指针法

class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        i = 0
        j = len(array)-1
        while i<j:
            if array[i]+array[j] < tsum:
                i += 1
            elif array[i]+array[j] > tsum:
                j -= 1
            else:
                return [array[i], array[j]]
        return []

43. 左旋转字符串[Done]

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

class Solution:
    def LeftRotateString(self, s, n):
        if not s:
            return s
        # write code here
        slen = len(s)
        temp = n%slen
        if temp == 0:
            return s
        else:
            return s[temp:]+s[:temp]

44. 反转字符串[Done]

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

class Solution:
    def ReverseSentence(self, s):
        if s is None or len(s) == 0:
            return s
        stack = []
        for i in s.split(' '): #split()通过指定分隔符对字符串进行切片
            stack.append(i)
        res = ""
        while len(stack) > 0:
            res += stack.pop() + " "
        res = res[:-1]
        return res

注意：
也可以用堆栈，先逐个入栈，再逐个出栈

45. 扑克牌顺子

一副扑克牌,里面有2个大王，2个小王，从中随机抽出5张牌，如果牌能组成顺子就输出true，否则就输出false。为了方便起见，大小王是0，大小王可以当作任何数字。其中J,Q,K,A分别用11， 12， 13， 1 表示

思路：
1、将数组排序；2、统计数组中0的个数，即判断大小王的个数；3、统计数组中相邻数字之间的空缺总数，如果空缺数小于等于大小王的个数，可以组成顺子，否则不行。如果数组中出现了对子，那么一定是不可以组成顺子的。

class Solution:
    def IsContinuous(self, numbers):
        if not numbers:
            return False
        # write code here
        numbers.sort()
        zero_count = numbers.count(0)
        numbers = numbers[zero_count:]
        count = 0
        for i in range(len(numbers)-1):
            if numbers[i+1]==numbers[i]:
                return False
            count += (numbers[i+1]-numbers[i]-1)
        if count <= zero_count:
            return True
        else:
            return False

46.圆圈中剩下的数

让小朋友们围成一个大圈。然后，他随机指定一个数m，让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列，不再回到圈中，从他的下一个小朋友开始，继续0…m-1报数…这样下去…直到剩下最后一个小朋友获胜，获胜的小朋友编号多少？(注：小朋友的编号是从0到n-1)

class Solution:
    def LastRemaining_Solution(self, n, m):
        # write code here
        if not n or not m:
            return -1
        res = range(n)
        i = 0
        while len(res)>1:
            i = (m+i-1)%len(res)
            res.pop(i)
        return res[0]

def solution(n, m):
    nums = list(range(n))
    while len(nums)>1:
        temp = m%len(nums)
        if temp == 0:
            nums = nums[:-1]
        else:
            nums = nums[temp:] + nums[:temp-1]
    return nums[0]

47. 求1+2+…+n

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

短路求值

class Solution:
    def __init__(self):
        self.result = 0
    def Sum_Solution(self, n):
        self.add(n)
        return self.result
    def add(self, x):
        self.result += x
        return x-1 and self.add(x-1)

python中执行a and b操作时，如果a=True 则执行b的表达式，然后在执行与操作，如果a=False则不执行b表达式操作，直接返回False

res = 0
def add(x):
    global res
    res += x
    return x-1 and add(x-1)

add(5)
print(res)

48. 不用加减乘除做加法

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

思路
（1）不考虑进位对每一位相加，0加0、1加1的结果都是0，1加0、0加1的结果都是1。这和异或运算相同。
（2）考虑进位，只有1加1的时候产生进位。位与运算只有两个数都是1的时候结果为1。考虑成两个数都做位与运算，然后向左移一位。
（3）相加的过程依然重复前面两步，直到不产生进位为止。

java程序

public class Solution {
    public int Add(int num1,int num2) {
        while(num2 != 0){
            int temp = num2^num1;
            int flag = (num2&num1)<<1;
            num1 = temp;
            num2 = flag;
        }
        return num1;
    }
}

python程序
在进行负数的按位加法时，有可能发生在最高位还要向前进一位的情形，正常来说，这种进位因为超出了一个int可以表示的最大位数，应该舍去才能得到正确的结果。因此，对于Java，c，c++这样写是正确的。而对于Python，却有点不同。

class Solution:
    def Add(self, num1, num2):
        while num2!=0:
            sum = num1^num2
            carry = 0xFFFFFFFF&((num1&num2)<<1)
            carry = -(~(carry-1)&0xFFFFFFFF) if carry > 0x7fffffff else carry
            num1 = sum
            num2 = carry
        return num1

49.字符串转换成整数

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0

class Solution:
    def StrToInt(self, s):
        # write code here
        if not s:
            return 0
        res = 0
        flag = 1
        if s[0] == "-":
            flag = -1
            s = s[1:]
        elif s[0] == "+":
            s = s[1:]
        for x in s:
            if x>="0" and x<="9":
                res = res*10+(ord(x)-ord("0"))
            else:
                return 0
        return res*flag

50.数组中重复的数字

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

思路1：暴力法

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

思路2：
注意到数组中的数字都在0~n-1范围内，如果这个数组中没有重复的数字，那么当数组排序后数字i在下标i的位置，由于数组中有重复的数字，有些位置可能存在多个数字，同时有些位置可能没有数字。遍历数组，当扫描到下标为i 的数字m时，首先看这个数字是否等于i，如果是，继续扫描，如果不是，拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字，如果不相等，就交换两个数字。继续比较

class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        for i in range(len(numbers)):
            while numbers[i] != i:
                m = numbers[i]
                if numbers[m] == m:
                    duplication[0] = m
                    return True
                else:
                    numbers[i], numbers[m] = numbers[m], m
        return False

class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        i = 0
        while i<len(nums):
            if nums[i] == i:
                i += 1
                continue
            temp = nums[i]
            if nums[temp] == temp:
                return temp
            nums[temp], nums[i] = nums[i], nums[temp]
        return None

51. 构建乘积数组

给定一个数组 $A [0, 1, ..., n - 1]$ ,请构建一个数组 $B [0, 1, ..., n - 1]$ ,其中B中的元素 $B [i] = A [0] * A [1] * ... * A [i - 1] * A [i + 1] * ... * A [n - 1]$ 。不能使用除法。（注意：规定 $B [0] = A [1] * A [2] * ... * A [n - 1] ， B [n - 1] = A [0] * A [1] * ... * A [n - 2]$ ;）

class Solution:
    def multiply(self, A):
        # write code here
        C, D = [], []
        for i in range(len(A)):
            if i == 0:
                C.append(1)
            else:
                C.append(C[i-1]*A[i-1])
        for i in range(len(A)):
            if i == 0:
                D.append(1)
            else:
                D.append(D[i-1]*A[len(A)-i])
        result = []
        D = D[::-1]
        for i in range(len(A)):
            result.append(C[i]*D[i])
        return result

52. 正则表达式匹配

请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配

动态规划

class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        # write code here
        p = pattern
        dp = [[False]*(len(pattern)+1) for _ in range(len(s)+1)]
        dp[0][0] = True
        for j in range(1, len(pattern)+1):
            if p[j-1] == "*" and j>=2:
                dp[0][j] = dp[0][j-2]
            elif j == 1 and p[j-1]=="*":
                dp[0][j] = True
        for i in range(1, len(s)+1):
            for j in range(1, len(pattern)+1):
                if s[i-1]==p[j-1] or p[j-1]==".":
                    dp[i][j] = dp[i-1][j-1]
                elif p[j-1] == "*" and (s[i-1] == p[j-2] or p[j-2]=="."):
                    dp[i][j] = dp[i-1][j-1] or dp[i-1][j] or dp[i][j-2]
                else :
                    dp[i][j] = dp[i][j-2]
        return dp[-1][-1]

53. 表示数值的字符串

题目描述
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

思路
如果遍历到e或E，那么之前不能有e或E，并且e或E不能在末尾；
如果遍历到小数点,那么之前不能有小数点，并且之前不能有e或E；
如果遍历到正负号，那么如果之前有正负号，只能够出现在e或E的后面，如果之前没符号，那么符号只能出现在第一位，或者出现在e或E的后面；
如果遍历到不是上面所有的符号和0~9，返回False

# -*- coding:utf-8 -*-
class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        hassign = False
        hase = False
        hasdot = False
        for i in range(len(s)):
            if s[i] == "+" or s[i]=="-":
                if hassign and s[i-1]!="e" and s[i-1]!="E":
                    return False
                if not hassign and s[i-1]!="e" and s[i-1]!="E" and i!=0:
                    return False
                hassign = True
            elif s[i] == "e" or s[i] == "E":
                if hase or i == (len(s)-1):
                    return False
                hase = True
            elif s[i] == ".":
                if hasdot or hase:
                    return False
                hasdot = True
            elif s[i]<"0" or s[i]>"9":
                return False
        return True

54. 字符流中第一个不重复的字符

题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

用例:
"google"
对应输出应该为:
"ggg#ll"

class Solution:
    # 返回对应char
    def __init__(self):
        self.s = ""
        self.dic = {}
    def FirstAppearingOnce(self):
    # 返回结果
        for x in self.s:
            if self.dic[x]== 1:
                return x
        return "#"

    def Insert(self, char):
        # 读入数据
        for x in char:
            self.s = self.s + x
            if x in self.dic:
                self.dic[x] = self.dic[x]+1
            else:
                self.dic[x] = 1

55. 链表中环的入口节点

题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        ptr = pHead
        nodes = []
        while ptr != None:
            if ptr in nodes:
                return ptr
            else:
                nodes.append(ptr)
                ptr = ptr.next
        return None

思路2：
设置快慢指针，都从链表头出发，快指针每次走两步，慢指针一次走一步，假如有环，一定相遇于环中某点(结论1)。接着让两个指针分别从相遇点和链表头出发，两者都改为每次走一步，最终相遇于环入口(结论2)。以下是两个结论证明：
两个结论：
1、设置快慢指针，假如有环，他们最后一定相遇。
2、两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇与环入口。
证明结论1：设置快慢指针fast和low，fast每次走两步，low每次走一步。假如有环，两者一定会相遇（因为low一旦进环，可看作fast在后面追赶low的过程，每次两者都接近一步，最后一定能追上）。
证明结论2：
设：
链表头到环入口长度为–a
环入口到相遇点长度为–b
相遇点到环入口长度为–c
在这里插入图片描述
则：相遇时
快指针路程=a+(b+c)k+b ，k>=1 其中b+c为环的长度，k为绕环的圈数（k>=1,即最少一圈，不能是0圈，不然和慢指针走的一样长，矛盾）。
慢指针路程=a+b
快指针走的路程是慢指针的两倍，所以：
（a+b）*2=a+(b+c)k+b
化简可得：
a=(k-1)(b+c)+c 这个式子的意思是：链表头到环入口的距离=相遇点到环入口的距离+（k-1）圈环长度。其中k>=1,所以k-1>=0圈。所以两个指针分别从链表头和相遇点出发，最后一定相遇于环入口。

class Solution:
    def EntryNodeOfLoop(self, pHead):
        if pHead == None or pHead.next == None or pHead.next.next == None:
            return None
        low = pHead.next
        fast = pHead.next.next
        while low != fast:
        	if fast.next == None or fast.next.next == None:
        		return None
            low = low.next
            fast = fast.next.next
        fast = pHead
        while low != fast:
            low = low.next
            fast = fast.next
        return fast

56. 删除列表中的重复节点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        first = ListNode(-1)
        first.next = pHead
        pre = first
        cur = pHead
        while cur:
            while cur.next and cur.next.val == cur.val:
                cur = cur.next
            # 判读中间有无跳过重复值
            if pre.next == cur:
                pre = pre.next
            # 若有重复值则跳过
            else:
                pre.next = cur.next
            cur = cur.next
        return first.next

57. 二叉树下一个节点

题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

思路：

如果该节点有右子树，那么它的下一个节点就是它的右子树的最左侧子节点；
如果该节点没有右子树且是父节点的左子树，那么下一节点就是父节点；
如果该节点没有右子树且是父节点的右子树，比如i节点，那么我们往上找父节点，找到一个节点满足：它是它的父节点的左子树的节点。

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

    def GetNext(self, pNode):
        # write code here
        if not pNode:
            return None
            # 该节点有右子树
        if pNode.right != None:
            temp = pNode.right
            while temp.left != None:
                temp = temp.left
            return temp
            # 没有右子树
        else:
            while pNode.next:
                temp = pNode.next
                # 该节点是父节点的左子树
                if temp.left == pNode:
                # 返回父节点
                    return temp
                pNode = temp
            return None

58. 对称二叉树

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

递归：

class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot:
            return True
        else:
            return self.helper(pRoot.left, pRoot.right)
    def helper(self, left, right):
        if left == None and right == None:
            return True
        elif left == None or right == None or left.val != right.val:
            return False
        else:
            return self.helper(left.left, right.right) and self.helper(left.right, right.left)

59.按之字形顺序打印二叉树

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

class Solution:
    def Print(self, pRoot):
        if not pRoot:
            return []
        # write code here
        nodes, flag, result = [[pRoot]], True, []
        while nodes:
            node = nodes.pop()
            flag = not flag
            res, temp = [], []
            while node:
                no = node.pop()
                res.append(no.val)
                if flag:
                    if no.right:
                        temp.append(no.right)
                    if no.left:
                        temp.append(no.left)
                else:
                    if no.left:
                        temp.append(no.left)
                    if no.right:
                        temp.append(no.right)
            if temp:
                nodes.insert(0, temp)
            result.append(res)
        return result

way2
每次节点还是按从左到右加入，在加入结果时进行判断是否需要翻转

# -*- 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 not pRoot:
            return []
        all_nodes = [[pRoot]]
        flag = False
        result = []
        while all_nodes:
            node_list = all_nodes.pop(0)
            nodes = []
            res = []
            for node in node_list:
                if node.left:
                    nodes.append(node.left)
                if node.right:
                    nodes.append(node.right)
                res.append(node.val)
            if nodes:
                all_nodes.append(nodes)
            if not flag:
                result.append(res)
            else:
                result.append(res[::-1])
            flag = not flag
        return result

60. 将二叉树打印成多行

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

注意：
本题和上一题很相似，但是两个题目用了不一样的方法，两个方法都可用于两个题目

class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot:
            return []
        nodes, result = [pRoot], []
        while nodes:
            res = []
            for i in range(len(nodes)):
                node = nodes.pop()
                res.append(node.val)
                if node.left:
                    nodes.insert(0, node.left)
                if node.right:
                    nodes.insert(0, node.right)
            result.append(res)
        return result

# -*- 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 not pRoot:
            return []
        result = []
        all_nodes = [[pRoot]]
        while all_nodes:
            res, temp_node = [], []
            nodes_list = all_nodes.pop(0)
            for node in nodes_list:
                res.append(node.val)
                if node.left:
                    temp_node.append(node.left)
                if node.right:
                    temp_node.append(node.right)
            if temp_node:
                all_nodes.append(temp_node)
            result.append(res)
        return result

61. 序列化二叉树

题目描述
请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以！表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树

注意：题目描述不清楚，题目的意思是先将树序列化，然后再恢复成树，最后返回的是恢复的树的根，因此在第一步将树序列化的时候可以将树序列化成字符串也可以列表。

思路：
使用前序遍历序列化，然后用前序遍历恢复，因为前序遍历根在最前面，比较好返回

class Solution:
    def __init__(self):
        self.temp = []
    def Serialize(self, root):
        # write code here
        if root == None:
            return "# "
        else:
            return str(root.val)+" "+self.Serialize(root.left)+self.Serialize(root.right)
        return self.result
    
    def Deserialize(self, s):
        # write code here
        temp = s.strip().split(" ")
        return self.helper(temp)
    
    def helper(self, temp):
        if not temp:
            return
        char = temp.pop(0)
        if char == "#":
            return None
        root = TreeNode(int(char))
        root.left = self.helper(temp)
        root.right = self.helper(temp)
        return root

62. 二叉搜索树的第K个节点

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

思路：
中序遍历二叉搜索树，结果就是从小到大排序，然后返回第K个即可

class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if k==0:
            return None
        res = []
        self.mid(pRoot, res)
        if k>len(res):
            return None
        return res[k-1]

    def mid(self, root, res):
        if root != None:
            self.mid(root.left, res)
            res.append(root)
            self.mid(root.right, res)

63. 数据流中的中位数

题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

思路：
每接受一个数进行插入排序，然后对排序后的列表求中位数;注意python2.x和python3.x中的/操作符区别。

class Solution:
    def __init__(self):
        self.res = []
    def Insert(self, num):
        # write code here
        if self.res == []:
            self.res.append(num)
        else:
            i = len(self.res)-1
            while i>=0:
                if self.res[i]>num:
                    i -= 1
                else:
                    break
            self.res.insert(i+1, num)
    def GetMedian(self, data):
        # write code here
        length = len(self.res)
        if length%2 == 0:
            return (self.res[length//2]+self.res[(length//2)-1])/2.0
        else:
            return self.res[length//2]

64. 滑动窗口中的最大值

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

思路一：求每次窗口的最大值，时间复杂度O(n*size)

class Solution:
    def maxInWindows(self, num, size):
        # write code here
        if size ==0:
            return []
        res = []
        i, j = 0, size
        while j<=len(num):
            res.append(max(num[i:j]))
            i += 1
            j += 1
        return res

思路2：
用一个双端队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次
1.判断当前最大值是否过期，即当前最大值是否属于当前窗口中的数
2.新增加的值从队尾开始比较，把所有比他小的值丢掉（这样后面加入第二大的值，当最大值过期后，第二大的值成为最大值）
注意：queue中保存的是索引

class Solution:
    def maxInWindows(self, num, size):
        # write code here
        if not num or not size:
            return []
        queue = []
        res = []
        i = 0
        while i < len(num):
        	# 判断最大值是否过期      
            if len(queue)>0 and i-size+1>queue[0]:
                queue.pop(0)
            # 将小于当前值的元素全都pop掉
            while len(queue)>0 and num[queue[-1]]<num[i]:
                queue.pop()
            queue.append(i)
            # 加入前两个元素时不需要保存结果
            if i-size+1>=0:
                res.append(num[queue[0]])
            i += 1
        return res

65. 矩阵中的路径

题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。例如 $\left[\begin{array}{llll}a & b & c & e \\ s & f & c & s \\ a & d & e & e\end{array}\right]$ 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

回溯算法

class Solution:
    def hasPath(self, matrix, rows, cols, path):
        if path == "":
            return True
        # write code here
        flag = [[True]*cols for _ in range(rows)]
        # 此处循环定义起点
        for i in range(rows):
            for j in range(cols):
                if matrix[i*cols+j] == path[0]:
                    flag[i][j] = False
                    if self.go(i, j, rows, cols, path[1:], matrix, flag[:]):
                        return True
                    flag[i][j]= True
         # 遍历所有起点都没有成功，返回False
        return False
                    
    def go(self, r, c, rows, cols, path, matrix, flag):
        if path == "":
            return True
        dx = [1, -1, 0, 0]
        dy = [0, 0, 1, -1]
        # 定义前进方向
        for k in range(4):
            x = r+dx[k]
            y = c+dy[k]
            if x>=0 and x<rows and y>=0 and y<cols and matrix[x*cols+y]==path[0] and flag[x][y]:
                flag[x][y]=False
                if self.go(x, y, rows, cols, path[1:], matrix, flag[:]):
                    return True
                flag[x][y]=True
         # 四个方向都不能走通，返回False
        return False

res = False
def hasPath(matrix, isused, s):
    if s == "":
        return True
    for i in range(len(matrix)):
        for j in range(len(matrix[0])):
            reuslt = help(matrix, isused, i, j, s)
    return reuslt

def help(matrix, isused, i, j, s):
    global res
    if s == "":
        return True
    if i<len(matrix) and j<len(matrix[0]) and i>=0 and j>= 0:
        if matrix[i][j] == s[0] and isused[i][j] == False:
            isused[i][j] = True
            res = help(matrix, isused, i+1, j, s[1:]) or help(matrix, isused, i-1, j, s[1:]) or help(matrix, isused, i, j+1, s[1:]) or help(matrix, isused, i, j-1, s[1:])
            isused[i][j] = False
    return res

matrix = [["a", "b", "c"],["a", "b", "c"],["a", "b", "c"]]
isused = [[False]*len(matrix[0]) for i in range(len(matrix))]
res = hasPath(matrix, isused, "caabbbccc")
print(res)

66.机器人运动范围

题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

注意：本题并不是求最长路径，而是求出可到达的方格个数


class Solution:
    def __init__(self):
        self.count = 0
    def movingCount(self, threshold, rows, cols):
        flag = [[True]*cols for _ in range(rows)]
        self.go(0, 0, threshold, rows, cols, flag)
        return self.count
        # write code here
    def go(self, x, y, threshold, rows, cols, flag):
        if x>=0 and y>=0 and x<rows and y<cols and sum(map(int, str(x)))+sum(map(int, str(y)))<=threshold and flag[x][y]:
            flag[x][y] = False
            self.count += 1
            self.go(x+1, y, threshold, rows, cols, flag)
            self.go(x-1, y, threshold, rows, cols, flag)
            self.go(x, y+1, threshold, rows, cols, flag)
            self.go(x, y-1, threshold, rows, cols, flag)

67. 剪绳子

题目描述
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]*k[1]*...*k[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

思路：
由经验得知，乘积最大往往在有很多段都集中在一个较大的数时，因此，将每段的长度从1遍历到num-1;然后计算出这种长度有多少段，最后余数另成一段

class Solution:
    def cutRope(self, number):
        # write code here
        if number == 2:
            return 1
        if number == 3:
            return 2
        maxnum = 0
        # i表示长度
        for i in range(1, number):
        	# 计算长度为i的段数
            x = number//i
            # 计算余数
            y = number-x*i
            if y!=0:
                maxnum = max(maxnum,i**x*y)
            else:
                maxnum = max(maxnum, i**x)
        return maxnum

参考

[1]. 牛客网 | 挑战剑指offer
[2].剑指offer python版

funNLPer

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
剑指offer算法题python实现

1. 二维数组中的查找在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。思路TODO…程序class Solution: # array 二维列表 def Find(self, target, array): # w...
复制链接

扫一扫