剑指offer题解 python_剑指Offer-Python题解（一）

剑指Offer-Python题解(一)

00 目录-按照标签分类

数据结构类题目数组13-调整数组顺序使奇数位于偶数前面

19-顺时针打印矩阵

28-数组中出现次数超过一半的数字

50-数组中重复的数字

51-构建乘积数组

32-把数组排成最小的数

链表03-从尾到头打印链表

14-链表中倒数第k个结点

15-反转链表

16-合并两个或k个有序链表

25-复杂链表的复制

36-两个链表的第一个公共结点

55-链表中环的入口结点

56-删除链表中重复的结点

树04-重建二叉树

17-树的子结构

18-二叉树的镜像

22-从上往下打印二叉树

23-二叉搜索树的后序遍历序列

24-二叉树中和为某一值的路径

26-二叉搜索树与双向链表

38-二叉树的深度

39-平衡二叉树

57-二叉树的下一个结点

58-对称的二叉树

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

60-把二叉树打印成多行

61-序列化二叉树

62-二叉搜索树的第k个结点

63-数据流中的中位数

栈和队列05-用两个栈实现队列

20-包含min函数的栈

21-栈的压入、弹出序列

44-翻转单词顺序列

64-滑动窗口的最大值

堆29-最小的K个数

哈希表34-第一个只出现一次的字符

图65-矩阵中的路径

66-机器人的运动范围

字符串43-左旋转字符串

49-把字符串转换成整数

52-正则表达式匹配

53-表示数值的字符串

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

算法类题目斐波那切数列07-斐波拉契数列

08-跳台阶

09-变态跳台阶

10-矩形覆盖

搜索算法01-二维数组的查找

06-旋转数组的最小数字

37-数字在排序数组中出现的次数

全排列27-字符串的排列

动态规划30-连续子数组的最大和

52-正则表达式匹配

回溯65-矩阵中的路径

66-机器人的运动范围

排序35-数组中的逆序对

29-最小的K个数

位运算11-二进制中1的个数

12-数值的整数次方

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

其他算法02-替换空格

31-整数中1出现的次数(从1到n整数中1出现的次数)

33-丑数

41-和为S的连续正数序列

42-和为S的两个数字

45-扑克牌顺子

46-孩子们的游戏-圆圈中最后剩下的数

47-求1+2+3+...+n

48-不用加减乘除做加法

01 二维数组的查找

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 在一个二维数组中(每个一维数组的长度相同)，

# 每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。

# 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution:

# 从左上角开始，大了往左，小了往下

def Find(self, target, array):

if len(array) == 0 or len(array[0]) == 0:

return False

i = 0

j = len(array[0]) - 1

while i < len(array) and j >= 0:

if array[i][j] == target:

return True

elif array[i][j] > target:

j = j - 1

else:

i = i + 1

return False

if __name__ == '__main__':

S = Solution()

print(S.Find(3, [[1, 2], [3, 4]]))

02 替换空格

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 请实现一个函数，将一个字符串中的每个空格替换成“%20”。

# 例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution:

def replaceSpace(self, s):

return s.replace(' ', '%20')

if __name__ == '__main__':

S = Solution()

print(S.replaceSpace('ji kkkda hj'))

03 从尾到头打印链表

题目描述

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

解题思路

代码

# coding:utf-8

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

class Node(object):

"""节点"""

def __init__(self, elem):

self.elem = elem

self.next = None

class SingleLinkList(object):

"""单链表"""

def __init__(self, node=None):

self.__head = node

def is_empty(self):

"""链表是否为空"""

return self.__head == None

def length(self):

"""链表长度"""

# cur游标，用来移动遍历节点

cur = self.__head

# count记录数量

count = 0

while cur != None:

count += 1

cur = cur.next

return count

def travel(self):

"""遍历整个链表"""

cur = self.__head

while cur != None:

print(cur.elem, end=" ")

cur = cur.next

print("")

def add(self, item):

"""链表头部添加元素, 头插法"""

node = Node(item)

node.next = self.__head

self.__head = node

def append(self, item):

"""链表尾部添加元素, 尾插法"""

node = Node(item)

if self.is_empty():

self.__head = node

else:

cur = self.__head

while cur.next != None:

cur = cur.next

cur.next = node

def insert(self, pos, item):

"""指定位置添加元素, pos 从0开始

"""

if pos <= 0:

self.add(item)

elif pos > (self.length() - 1):

self.append(item)

else:

pre = self.__head

count = 0

while count < (pos - 1):

count += 1

pre = pre.next

# 当循环退出后，pre指向pos-1位置

node = Node(item)

node.next = pre.next

pre.next = node

def remove(self, item):

"""删除节点"""

cur = self.__head

pre = None

while cur != None:

if cur.elem == item:

# 先判断此结点是否是头节点

# 头节点

if cur == self.__head:

self.__head = cur.next

else:

pre.next = cur.next

break

else:

pre = cur

cur = cur.next

def search(self, item):

"""查找节点是否存在"""

cur = self.__head

while cur != None:

if cur.elem == item:

return True

else:

cur = cur.next

return False

def get_head(self):

return self.__head

class Solution:

def printListFromTailToHead(self, listNode):

val_list = []

if listNode == None:

return val_list

while listNode != None:

val_list.append(listNode.elem)

listNode = listNode.next

val_list.reverse()

return val_list

if __name__ == "__main__":

ll = SingleLinkList()

ll.append(1)

ll.append(1)

ll.append(3)

ll.append(4)

ll.append(5)

ll.append(6)

ll.travel()

S = Solution()

print(S.printListFromTailToHead(ll.get_head()))

04 重建二叉树

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。

# 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

# 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，

# 则重建二叉树并返回。

class TreeNode:

def __init__(self, x):

self.val = x

self.left = None

self.right = None

class Solution:

def reConstructBinaryTree(self, pre, tin):

if pre == []:

return

val = pre[0]

idx = tin.index(val)

ltin = tin[0:idx]

rtin = tin[(idx + 1):]

lpre = pre[1:(1 + len(ltin))]

rpre = pre[(1 + len(ltin)):]

root = TreeNode(val)

root.left = self.reConstructBinaryTree(lpre, ltin)

root.right = self.reConstructBinaryTree(rpre, rtin)

return root

def preorder(self, pRoot):

if pRoot is None:

return

print(pRoot.val, end=" ")

self.preorder(pRoot.left)

self.preorder(pRoot.right)

def inorder(self, pRoot):

if pRoot is None:

return

self.inorder(pRoot.left)

print(pRoot.val, end=" ")

self.inorder(pRoot.right)

if __name__ == '__main__':

S = Solution()

pre = [1, 2, 4, 7, 3, 5, 6, 8]

tin = [4, 7, 2, 1, 5, 3, 8, 6]

root = S.reConstructBinaryTree(pre, tin)

S.preorder(root)

print()

S.inorder(root)

05 用两个栈实现队列

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

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

class Solution:

def __init__(self):

self.stack1 = []

self.stack2 = []

def push(self, node):

self.stack1.append(node)

def pop(self):

# stack2非空

if len(self.stack2):

return self.stack2.pop()

# stack2是空的，把stack1中的元素全部压入stack2中

while self.stack1:

self.stack2.append(self.stack1.pop())

# 判断stack2是否是空的，非空则输出，空则return

if self.stack2:

return self.stack2.pop()

else:

return

if __name__ == '__main__':

S = Solution()

S.push(1)

print(S.pop())

print(S.pop())

06 旋转数组的最小数字

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

# 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。

# 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

# NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution:

def MininOrder(self, rotateArray, left, right):

res = rotateArray[left]

for i in range(left, right + 1):

if res > rotateArray[i]:

res = rotateArray[i]

def minNumberInRotateArray(self, rotateArray):

lenArr = len(rotateArray)

left, right = 0, lenArr - 1

while left <= right:

if right - left == 1:

return rotateArray[right] # 下标相差为1时，直接输出右值

mid = (left + right) // 2

if rotateArray[left] == rotateArray[mid] and rotateArray[mid] == rotateArray[right]:

return self.MininOrder(rotateArray, left, right) # 无法判断最小值在那一边，进行暴力查找

if rotateArray[mid] >= rotateArray[left]: # 中间值大于左值，最小值在右边，2345671，5>2

left = mid

elif rotateArray[mid] <= rotateArray[right]: # 中间值小于右值，最小值在左边，5671234，1<4

right = mid

return rotateArray[right]

if __name__ == '__main__':

S = Solution()

list = [5, 6, 7, 1, 2, 3, 4]

print(S.minNumberInRotateArray(list))

07 斐波拉契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项(从0开始，第0项为0)。

n<=39

解题思路

代码

# -*- coding:utf-8 -*-

# 大家都知道斐波那契数列，现在要求输入一个整数n，

# 请你输出斐波那契数列的第n项(从0开始，第0项为0)

class Solution:

def Fibonacci(self, n):

if n == 0:

return 0

if n == 1 or n == 2:

return 1

memories = [1, 1]

for i in range(n - 2):

memories.append(memories[-1] + memories[-2])

return memories[-1]

S = Solution()

print(S.Fibonacci(50))

08 跳台阶

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 一只青蛙一次可以跳上1级台阶，也可以跳上2级。

# 求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。

class Solution:

def jumpFloor(self, number):

if number == 1 or number == 2:

return number

dp = [1, 2]

for i in range(number - 2):

dp.append(dp[-1] + dp[-2])

return dp[-1]

S = Solution()

print(S.jumpFloor(50))

09 变态跳台阶

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 一只青蛙一次可以跳上1级台阶，也可以跳上2级。

# 求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。

class Solution:

def jumpFloor(self, number):

if number == 1 or number == 2:

return number

ret = sum_ = 3

for i in range(number - 2):

ret = sum_ + 1

sum_ += ret

return ret

S = Solution()

print(S.jumpFloor(3))

10 矩形覆盖

题目描述

我们可以用2x1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2x1的小矩形无重叠地覆盖一个2xn的大矩形，总共有多少种方法？

解题思路

代码

# -*- coding:utf-8 -*-

# 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。

# 请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution:

def rectCover(self, number):

if number == 0 or number == 1 or number == 2:

return number

dp = [1, 2]

for i in range(number - 2):

dp.append(dp[-1] + dp[-2])

return dp[-1]

S = Solution()

print(S.rectCover(8))

11 二进制中1的个数

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

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

class Solution:

def NumberOf1(self, n):

return bin(n & 0xffffffff).count('1')

S = Solution()

print(S.NumberOf1(100))

12 数值的整数次方

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 给定一个double类型的浮点数base和int类型的整数exponent。

# 求base的exponent次方。

# 需要注意的地方:

# 当指数为负数的时候

# 当底数为零切指数为负数的情况

# 在判断底数base是不是等于0的时候,不能直接写base==0, 因为计算机内表示小数时有误差,

# 只能判断他们的差的绝对值是不是在一个很小的范围内

# 当n为偶数, a^n = a^(n/2) * a^(n/2)

# 当n为奇数, a^n = a^((n-1)/2) * a^((n-1)/2)) * a

# 利用右移一位运算代替除以2

# 利用位与运算代替了求余运算法%来判断一个数是奇数还是偶数

# 优化代码速度

class Solution:

def Power(self, base, exponent):

if exponent == 0:

return 1

if exponent == 1:

return base

if exponent == -1:

return 1 / base

result = self.Power(base, exponent >> 1)

result *= result

if exponent & 0x1 == 1:

result *= base

return result

if __name__ == '__main__':

S = Solution()

print(S.Power(4.56, 6))

13 调整数组顺序使奇数位于偶数前面

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，

# 使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，

# 并保证奇数和奇数，偶数和偶数之间的相对位置不变。

class Solution:

def reOrderArray(self, array):

even, odd = [], []

for i in array:

if i % 2 == 0:

odd.append(i)

else:

even.append(i)

return even + odd

class Solution1:

def reOrderArray(self, array):

size = len(array)

pos = size - 1

cnt = 0

while cnt < size:

if array[pos] % 2 == 1:

tmp = array[pos]

for i in range(pos - 1, -1, -1):

array[i + 1] = array[i]

array[0] = tmp

else:

pos -= 1

cnt += 1

return array

if __name__ == '__main__':

S = Solution()

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

print(S.reOrderArray(a))

14 链表中倒数第k个结点

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

def FindKthToTail(self, head, k):

if head == None :

return

p1 = p2 = head

for i in range(k):

if p2 == None:

return

p2 = p2.next

while p2:

p2 = p2.next

p1 = p1.next

return p1

if __name__ == '__main__':

n0 = ListNode(0)

n1 = ListNode(1)

n2 = ListNode(2)

n3 = ListNode(3)

n4 = ListNode(4)

n0.next = n1

n1.next = n2

n2.next = n3

n3.next = n4

S = Solution()

print(S.FindKthToTail(n0, 2).val)

15 反转链表

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

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

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

def ReverseList(self, pHead):

head = None

while pHead:

tmp = ListNode(pHead.val)

tmp.next = head

head = tmp

pHead = pHead.next

return head

def ReverseList_r(self, pHead):

if pHead == None or pHead.next == None:

return pHead

p = self.ReverseList_r(pHead.next)

pHead.next.next = pHead

pHead.next = None

return p

def travel_list(self, pHead):

while pHead:

print(pHead.val, end=' ')

pHead = pHead.next

if __name__ == '__main__':

n0 = ListNode(0)

n1 = ListNode(1)

n2 = ListNode(2)

n3 = ListNode(3)

n4 = ListNode(4)

n0.next = n1

n1.next = n2

n2.next = n3

n3.next = n4

S = Solution()

S.travel_list(S.ReverseList(n0))

16 合并两个或k个有序链表

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

def Merge(self, pHead1, pHead2):

res = ListNode(0)

tmp = res

p1 = pHead1

p2 = pHead2

while p1 and p2:

if p1.val < p2.val:

tmp.next = p1

p1 = p1.next

else:

tmp.next = p2

p2 = p2.next

tmp = tmp.next

if p1:

tmp.next = p1

if p2:

tmp.next = p2

return res.next

def travel_list(self, pHead):

while pHead:

print(pHead.val, end=' ')

pHead = pHead.next

if __name__ == '__main__':

n0 = ListNode(0)

n1 = ListNode(1)

n2 = ListNode(2)

n3 = ListNode(3)

n4 = ListNode(4)

n0.next = n1

n1.next = n2

n2.next = n3

n3.next = n4

m0 = ListNode(0)

m1 = ListNode(1)

m2 = ListNode(2)

m3 = ListNode(3)

m4 = ListNode(4)

m0.next = m1

m1.next = m2

m2.next = m3

m3.next = m4

S = Solution()

S.travel_list(n0)

S.travel_list(pHead=S.Merge(n0, m0))

17 树的子结构

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

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

class TreeNode:

def __init__(self, x):

self.val = x

self.left = None

self.right = None

class Solution:

def HasSubtree(self, pRoot1, pRoot2):

def subtree(pRoot1, pRoot2):

if pRoot1 == None and pRoot2 == None:

return True

if pRoot1 == None:

return False

if pRoot2 == None:

return False

if pRoot2.val == pRoot1.val:

if pRoot2.left == None and pRoot2.right == None:

return True

if subtree(pRoot1.left, pRoot2.left) and subtree(pRoot1.right, pRoot2.right):

return True

return subtree(pRoot1.left, pRoot2) or subtree(pRoot1.right, pRoot2)

if pRoot1 == None and pRoot2 == None:

return False

return subtree(pRoot1, pRoot2)

if __name__ == '__main__':

S = Solution()

root = TreeNode(0)

node0 = TreeNode(1)

node1 = TreeNode(2)

node2 = TreeNode(3)

node3 = TreeNode(4)

node4 = TreeNode(5)

node5 = TreeNode(6)

root.left = node0

root.right = node1

node0.left = node2

node0.right = node3

node1.left = node4

node1.right = node5

# subtree

node6 = TreeNode(1)

node7 = TreeNode(3)

node8 = TreeNode(5)

node6.left = node7

node6.right = node8

print(S.HasSubtree(root, node6))

18 二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树

8

/ \

6 10

/ \ / \

5 7 9 11

镜像二叉树

8

/ \

10 6

/ \ / \

11 9 7 5

解题思路

代码

# coding:utf-8

# 操作给定的二叉树，将其变换为源二叉树的镜像

class Node(object):

"""定义节点数据类型"""

def __init__(self, item):

self.elem = item

self.lchild = None

self.rchild = None

class Tree(object):

"""二叉树"""

def __init__(self):

self.root = None

def add(self, item):

node = Node(item)

if self.root is None:

self.root = node

return

queue = [self.root]

while queue:

cur_node = queue.pop(0)

if cur_node.lchild is None:

cur_node.lchild = node

return

else:

queue.append(cur_node.lchild)

if cur_node.rchild is None:

cur_node.rchild = node

return

else:

queue.append(cur_node.rchild)

def breadth_travel(self):

"""广度遍历"""

if self.root is None:

return

queue = [self.root]

while queue:

cur_node = queue.pop(0)

print(cur_node.elem, end=" ")

if cur_node.lchild is not None:

queue.append(cur_node.lchild)

if cur_node.rchild is not None:

queue.append(cur_node.rchild)

def preorder(self, node):

"""先序遍历"""

if node is None:

return

print(node.elem, end=" ")

self.preorder(node.lchild)

self.preorder(node.rchild)

def inorder(self, node):

"""中序遍历"""

if node is None:

return

self.inorder(node.lchild)

print(node.elem, end=" ")

self.inorder(node.rchild)

def postorder(self, node):

"""后序遍历"""

if node is None:

return

self.postorder(node.lchild)

self.postorder(node.rchild)

print(node.elem, end=" ")

def Mirror(self, root):

if root == None:

return

self.Mirror(root.lchild)

self.Mirror(root.rchild)

root.lchild, root.rchild = root.rchild, root.lchild

if __name__ == "__main__":

tree = Tree()

tree.add(0)

tree.add(1)

tree.add(2)

tree.add(3)

tree.add(4)

tree.add(5)

tree.add(6)

tree.add(7)

tree.add(8)

tree.add(9)

tree.breadth_travel()

print(" ")

tree.preorder(tree.root)

print(" ")

tree.inorder(tree.root)

print(" ")

tree.postorder(tree.root)

print(" ")

tree.Mirror(tree.root)

tree.breadth_travel()

19 顺时针打印矩阵

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，

# 例如，如果输入如下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

class Solution:

# matrix类型为二维列表，需要返回列表

def printMatrix(self, matrix):

printArr = []

if matrix == None:

return

if matrix == []:

return []

start = 0 # 每次循环的起点

rows = len(matrix) # 行数

columns = len(matrix[0]) # 列数

while columns > 2 * start and rows > 2 * start:

endX = columns - 1 - start

endY = rows - 1 - start

# 从左到右将数字存入printArr

for i in range(start, endX + 1):

number = matrix[start][i]

printArr.append(number)

# 从上到下将数字存入printArr

if start < endY:

for i in range(start + 1, endY + 1):

number = matrix[i][endX]

printArr.append(number)

# 从右到左将数字存入printArr

if start < endX and start < endY:

for i in range(endX - 1, start - 1, -1):

number = matrix[endY][i]

printArr.append(number)

# 从下到上将数字存入printArr

if start < endX and start < endY - 1:

for i in range(endY - 1, start, -1):

number = matrix[i][start]

printArr.append(number)

start += 1

return printArr

if __name__ == "__main__":

S = Solution()

print(S.printMatrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]))

20 包含min函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数(时间复杂度应为O(1))。

解题思路

代码

# -*- coding:utf-8 -*-

class Solution:

def __init__(self):

self.stack = []

self.minstack = []

self.minm = float('inf')

def push(self, node):

self.stack.append(node)

if node < self.minm:

self.minm = node

self.minstack.append(self.minm)

def pop(self):

if self.stack != []:

if self.stack[-1] == self.minm:

self.minstack.pop()

self.stack.pop()

def top(self):

if self.stack != []:

return self.stack[-1]

else:

return None

def min(self):

return self.minstack[-1]

if __name__ == '__main__':

S = Solution()

S.push(2)

S.push(1)

S.push(3)

S.push(4)

S.push(5)

print(S.top())

print(S.min())

21 栈的压入、弹出序列

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

# 输入两个整数序列，第一个序列表示栈的压入顺序，

# 请判断第二个序列是否可能为该栈的弹出顺序。

# 假设压入栈的所有数字均不相等。

# 例如序列1,2,3,4,5是某栈的压入顺序，

# 序列4,5,3,2,1是该压栈序列对应的一个弹出序列，

# 但4,3,5,1,2就不可能是该压栈序列的弹出序列。

# (注意：这两个序列的长度是相等的)

class Solution:

def IsPopOrder(self, pushV, popV):

stack = []

for i in pushV:

stack.append(i)

while stack and stack[-1] == popV[0]:

stack.pop()

popV.pop(0)

return True if not stack else False

if __name__ == '__main__':

S = Solution()

print(S.IsPopOrder([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]))

22 从上往下打印二叉树

题目描述

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

解题思路

代码

# -*- coding:utf-8 -*-

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

class TreeNode:

def __init__(self, x):

self.val = x

self.left = None

self.right = None

class Solution:

# 返回从上到下每个节点值列表，例：[1,2,3]

def PrintFromTopToBottom(self, root):

# write code here

if root is None:

return []

queue = [root]

res = []

while queue:

cur_node = queue.pop(0)

res.append(cur_node.val)

if cur_node.left is not None:

queue.append(cur_node.left)

if cur_node.right is not None:

queue.append(cur_node.right)

return res

if __name__ == '__main__':

S = Solution()

root = TreeNode(0)

node0 = TreeNode(1)

node1 = TreeNode(2)

node2 = TreeNode(3)

node3 = TreeNode(4)

node4 = TreeNode(5)

node5 = TreeNode(6)

root.left = node0

root.right = node1

node0.left = node2

node0.right = node3

node1.left = node4

node1.right = node5

print(S.PrintFromTopToBottom(root))