前言

简单的模拟

一、题目

螺旋矩阵 II

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例

示例 1：
输入：n = 3
在这里插入图片描述

输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：
输入：n = 1
输出：[[1]]

提示

1 <= n <= 20

二、思路

就是简单地模拟，一圈圈转就行了，对转的本圈每行放入个数遍历
一开始用函数写了，但后来觉得没啥用，就换掉了，还能省十行

三、代码

1.函数

python">class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        direction=0 #0/1/2/3分别代表右下左上
        length=n-1 # 每个方向从n-1个数开始，
        i,j,val=0,0,1 #起始下标和初始值
        re_list=[[0 for x in range(n)] for y in range(n)]
        def move_hang_shun(i,start,end,val): #横向移动（行下标，列范围，初始赋值）
            if(start<=end): #正向
                for j in range(start,end):
                    re_list[i][j]=val
                    val+=1
            else: #反向
                for j in range(start,end,-1): 
                    re_list[i][j]=val
                    val+=1
        def move_lie(j,start,end,val): # 纵向移动
            if(start<=end): #正向
                for i in range(start,end):
                    re_list[i][j]=val
                    val+=1
            else: #反向
                for i in range(start,end,-1): 
                    re_list[i][j]=val
                    val+=1
        for k in range(length,-1,-2): #每轮完四个方向递减2，最多可以减到0
            if(k<1):#直至<1时，中间位置填最后一个数
                re_list[n//2][n//2]=n*n
                break
            move_hang(i,j,j+k,val) #右
            j+=k
            val+=k
            move_lie(j,i,i+k,val) #下
            i+=k
            val+=k
            move_hang(i,j,j-k,val) #左
            j-=k
            val+=k
            move_lie(j,i,i-k,val) #上
            i-=k
            val+=k
        return re_list

2.没函数

python">class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        direction=0 #0/1/2/3分别代表右下左上
        length=n-1 # 每个方向从n-1个数开始，
        index,val=[0,0],[1] #起始下标和初始值
        re_list=[[0 for x in range(n)] for y in range(n)]

        for k in range(length,-1,-2): #每轮完四个方向递减2，最多可以减到0
            if(k<1):#直至<1时，中间位置填最后一个数
                re_list[index[0]][index[1]]=val[0]
                break
            for j in range(index[1],index[1]+k):#右
                re_list[index[0]][j]=val[0]
                val[0]+=1 
            index[1]+=k
            for i in range(index[0],index[0]+k): #下
                re_list[i][index[1]]=val[0]
                val[0]+=1
            index[0]+=k
            for j in range(index[1],index[1]-k,-1):#右
                re_list[index[0]][j]=val[0]
                val[0]+=1 
            index[1]-=k
            for i in range(index[0],index[0]-k,-1): #上
                re_list[i][index[1]]=val[0]
                val[0]+=1
            index[0]=index[0]-k+1 #拐弯
            index[1]+=1

        return re_list

在这里插入图片描述

四、题目

旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例

示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]

提示

链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 109

五、思路

两遍遍历，时间复杂度O(n)
第一遍遍历到结尾并把它首尾相接，同时查清楚元素个数，把k化为最简
第二遍指针遍历到位置index处，把其next断开并返回next元素,index=(count-k-1)%count #index小于count,即目标元素的前一个元素

今天早上七点多起来做核酸起太早了，属实神志不清，第一次用p->next的语法写了一篇直到执行才发现语法不对（无语住了）

六、代码

python"># Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:    
        if(head == None): #链表为空
            return head
        count=1 #个数计数器
        Head=p=head #保存头指针和遍历的指针
        while(p and p.next):
            p=p.next
            count+=1
        p.next=Head #接上了，变成循环单链表
        index=(count-k-1)%count #index小于count
        p=Head
        i=0 
        while(i<index): #找第index个
            p=p.next
            i+=1
        head=p.next #保存新头指针
        p.next=None #断开
        return head #返回