矩阵分圈处理：在矩阵中用左上角的坐标（tr,tc）和右下角的坐标（dr,dc）就可以表示一个矩阵，然后按行与列分别处理每个坐标，打印完第一圈，循环打印内圈即可
一.转圈打印矩阵
def spiralorderprint(matrix):
# 矩阵左上角坐标（x1,y1）
tr = 0
tc = 0
# 矩阵右下角坐标（x2,y2）
dr = len(matrix) - 1
dc = len(matrix[0]) - 1
while(tr<=dr and tc<=dc):
printEdge(matrix,tr,tc,dr,dc)
tr += 1
tc += 1
dr -= 1
dc -= 1
def printEdge(m,tr,tc,dr,dc):
# 矩阵只有一行时
if tr == dr:
for i in range(tc,dc+tc):
if i <= dc:
i += 1
print(str(m[tr][i])+ ' ')
else:
break
# 矩阵只有一列时
elif tc == dc:
for i in range(tr,tr+dr):
if i<=dr:
i += 1
print(str(m[i][tc]) + ' ')
else:
break
# 一般情况
else:
#设置两个参考值作为游标
cur_c = tc
cur_r = tr
# 当y1列不等于y2列时，打印x1行的元素
while (cur_c != dc):
print(str(m[tr][cur_c]) + ' ')
cur_c += 1
# 当x1行不等于x2行时，打印y2列的元素
while (cur_r != dr):
print(str(m[cur_r][dc]) + ' ')
cur_r += 1
# 当y1列不等于y2列时，打印y1行的元素
while (cur_c != tc):
print(str(m[dr][cur_c]) + ' ')
cur_c -= 1
# 当x1行不等于x2行时，打印x1列的元素
while (cur_r != tr):
print(str(m[cur_r][tc]) + ' ')
cur_r -= 1
# 使用对数器产生一个随机数组来验证结果是否正确
# N = [[i]*5 for i in range(5)]
# print(N)
# spiralorderprint(N)
import random
import numpy as np
# 产生一个随机整数，作为数组的维数
n = random.randint(1,10)
# 产生一个随机二维整数数组
a=np.random.randint(0,10,size=[n,n])
print(a)
# 调用函数
spiralorderprint(a)
二.将正方形矩阵顺时针转动90°
def rotate(matrix):
# 矩阵左上角坐标（x1,y1）
tr = 0
tc = 0
# 矩阵右下角坐标（x2,y2）
dr = len(matrix) - 1
dc = len(matrix[0]) - 1
# 当左上角的坐标小于右下角的坐标时依次打印外圈到内圈
while(tr<=dr and tc<=dc):
# 调用排序函数
rotateedge(matrix,tr,tc,dr,dc)
# 换圈
tr += 1
tc += 1
dr -= 1
dc -= 1
# 否则输出改变后的数组
print(matrix)
def rotateedge(m,tr,tc,dr,dc):
# 定义一个总的组数，也就是在一圈矩阵中要换多少组数
times = dc-tc
for i in range(0,times+1):
if i != times:
# 设置一个变量暂时存放坐标
tep = m[tr][tc+i]
# 依次换每组坐标
m[tr][tc + i] = m[dr-i][tc]
m[dr - i][tc] = m[dr][dc-i]
m[dr][dc-i] = m[tr+i][dc]
m[tr+i][dc] = tep
# 换组
i += 1
else:
break
# 使用numpy产生一个随机数组来验证结果是否正确
# N = [[i]*5 for i in range(5)]
# print(N)
# rotate(N)
import random
import numpy as np
# 产生一个随机整数，作为数组的维数
n = random.randint(1,10)
# 产生一个随机二维整数数组
a=np.random.randint(0,10,size=[n,n])
print(a)
# 调用函数
rotate(a)三.之字形打印矩阵
def printmatrixzigzag(matrix):
# 上坐标初始为(0,0)先沿着矩阵第一行移动（tc++），到达第一行最右边的元素后，再沿着矩阵最后一列移动（tr++）
tr = 0
tc = 0
# 下坐标初始为(0,0)先沿着矩阵第一列移动（dr++），到达第一列最下边的元素后，再沿着矩阵最后一行移动（dc++）
dr = 0
dc = 0
# 行数
end_r = len(matrix)-1
# print(end_r)
# 列数
end_c = len(matrix[0]) - 1
# print(end_c)
# 标志，true表示由上到下
fromup = False
# 当x1不等于行数时，执行函数printlever
while (tr!=end_r+1):
# 调用printlever函数进行取数
printlever(matrix,tr,tc,dr,dc,fromup)
# 判断是否换行换列
# 到达最后一列，换行
if tc == end_c:
tr +=1
tc = tc
# 否则行数不变，列数加一
else:
tr = tr
tc+=1
# 到达最后一行，换列
if dr == end_r:
dc +=1
dr = dr
# 否则列数不变，行数加一
else:
dc = dc
dr +=1
# 标志位取反，表示的是取数的顺序发生变化
fromup = not fromup
# print(matrix)
def printlever(m,tr,tc,dr,dc,fromup):
# 上坐标与下坐标同时移动，每次移动后的上坐标与下坐标的连线就是矩阵的一条斜线，打印斜线上的元素
# 如果上次是从左下到右上，下次一定是右上到左下，因此设置的标志位取反即可
if fromup:
while(tr!=dr+1):#到了最底下停止
# 取上坐标，由右上到左下
print(str(m[tr][tc])+' ')
tr += 1
tc -= 1
else:
while(dr!=tr-1):#到了最顶上停止
# 取下坐标，左下到右上
print(str(m[dr][dc])+' ')
dr -= 1
dc += 1
# 使用numpy产生一个随机数组来验证结果是否正确
# N = [[i]*5 for i in range(5)]
# print(N)
# printmatrixzigzag(N)
import random
import numpy as np
# 产生一个随机整数，作为数组的维数
n = random.randint(1,5)
# 产生一个随机二维整数数组
a=np.random.randint(0,10,size=[n,n])
print(a)
# 调用函数
printmatrixzigzag(a)
四.需要排序的最短数组长度
def getminlenth(arr):
# 如果输入的数组为空或者数组长度小于2，输出0
if arr==[] and len(arr)<2:
return 0
# 暂时设最右边的元素为最小值
min1 = arr[len(arr)-1]
# nominindex记录排序的次数
nominindex = -1
# 从右到左遍历，遍历的过程中记录右侧出现过的最小值，记做是min1
# len(arr)-2表示的是倒数第二个位置
for i in range(len(arr)-2,-2,-1):
if i != -1:
# 如果i位置对应的元素大于最小值时，记录交换元素的位置
if(arr[i]>min1):
nominindex = i
else:
# 找到最小值
min1 = min(min1,arr[i])
# 发现i为-1时，遍历结束，跳出循环
else:
break
# 如果发现仍然为-1，说明数组原本就是有序的，返回0
if nominindex == -1:
return 0
# 同理
max2 = arr[0]
nomaxindex = -1
for i in range(1,len(arr)+1):
if i != len(arr):
if(arr[i]<max2):
nomaxindex = i
else:
max2 = max(max2,arr[i])
else:
break
# 遍历完成后，arr【nominindex,nomaxindex】即是需要排序的数组，记录这个数组的长度即可
return nomaxindex-nominindex+1
# arr = [1,5,3,4,2,6,7]
# print(arr)
# print(getminlenth(arr))
import random
# 定义数组的长度
length = random.randint(1,10)
# 产生一个随机整数数组
ranlist=[random.randint(1,10) for i in range(length)]
print(ranlist)
# 调用函数，判断需要排序的子数组长度是多少
print(getminlenth(ranlist))五.在行列都排好序的矩阵中找数字
def iscontains(matrix,k):
row = 0
col = len(matrix[0])-1
# 从矩阵最右上角的数字开始找
while (row<len(matrix) and col>-1):
# 判断当前数字matrix[row][col]==k？如果是返回true，否则输出false
if (matrix[row][col]==k):
return True
# 如果当前的数字比较大，那么就不用在列数寻找了，因为列的值都有序，直接换行数寻找，然后继续while循环
elif (matrix[row][col]>k):
col-=1
# 如果当前的数字比较小，那么就不用在行数寻找了，因为行的值都有序，直接换列数寻找，然后继续while循环
else:
row+=1
return False
arr=[
[2,4,5,7],
[3,4,5,8],
[5,7,8,9]
]
print(arr)
k = int(input("please input a number；"))
# 调用函数
print(iscontains(arr,k))未完待续