资源简介

(共49张PPT)
课时21 数组
一、数组的概念
1. 数组是由　　　　的变量构成的一个序列。
2. 数组使用一个标识符命名，并用编号区分数组内的各个变量，这个特殊的标识符称为数组名，编号称为下标或索引。由数组名和下标组成数组的各个变量称为数组的分量，也称为　　　。
3. 数组在内存中存储的结构简单，创建数组时系统会分配一块 　　　的存储空间，每个数组元素按照下标顺序依次存储。
4. 计算机中数据的存储结构主要分为顺序存储结构（如数组）和非顺序存储结构（如链表）。
相同类型
连续
数组元素
5.常用的数组类型。
（1）一维数组。
①特征：适合用来表示具有线性特征的数据序列，只需要一个下标来表示数据元素在该序列中的位置。
②数组中的数据在内存中按照下标顺序依次存储，使用数组
名指向第一个数组元素存储的位置，由于每个数组元素的类
型相同，所需的存储空间一致，因此在明确第一个数组元素
的存储位置后，可以利用下标计算出其他数组元素的存储位
置，从而达到快速访问的目的。
③存储结构如图所示，数组元素可表示为a[0]，a[1]，
a[2]…。
（2）二维数组。
①特征：适合用来表示二维空间内既有纵向联系又有　　　　联系的一批数据，二维数组中的数据元素有行、列两个维度的位置信息，需要两个下标。
②一般用第一个下标表示　　　　位置，第二个下标表示　　　　位置，行列下标均从 0 开始。
③有如图所示的二维数组，数组元素可表示为 b[0][0]，b[0][1]，…，b[3][2]，b[3][3]。
横向
行
列
④用二维数组表示的数据在内存中采用顺序存储，有行优先存储和列优先存储两种方式。
⑤以行优先存储为例，首先将第一行（行下标为 0）数组元素按照列下标顺序依次存储，再将下一行（行下标为 1）数组元素按照列下标顺序依次存储，直至所有行存储完毕。
⑥二维数组行优先存储方式如图所示，数组名指向数组中第一行第一个数组元素存储的位置，其他数组元素均可以通过其下标快速得到其存储位置。
1.数组元素的数据类型相同。
数组一般默认指静态数组，即定义一个数组后，系统根据每个数组元素的数据类型和总元素个数，在内存中开辟一批　　　　且空间固定的存储空间。所以数组要求所有数组元素的数据类型是　　　　的。
2.通过数组名和下标对数组元素的值进行访问。
因为系统会根据下标和数据类型计算内存地址访问数组中的数据元素，所以在对数组中的数据元素进行访问时，不能只提供数组名称，而必须同时提供数组名称和数据元素对应的下标。
地址连续
相同
二、数组的特性
3.存储空间　　　　。
（1）静态数组对应的最大元素数量在数组定义时就已经确定，在程序运行期间
　　　　发生改变，即使数组中的某些数据元素已经删除，但其占用的空间会继续保留。
（2）由于静态数组存储空间固定不变，便存在以下两个问题：
①有些问题难以预估需要多少存储空间。
②如果删除了很多数据元素，则不能充分利用空余空间，会导致系统内存的浪费。
（3）为了解决上述问题，可采用 　　　技术，允许数组的元素数量可以根据处理的需要进行增加或减少。
（4）动态数组就是在声明时没有确定数据规模的数组，可以在任何时候改变数据规模。
固定不变
不会
动态数组
1. 当 Python 列表中每个数据元素所含数据项的数量和　　　　均相同时，可以将该列表视为数组，列表　　　　可视为数组的下标。因此在 Python 中可以使用列表来实现数组的基本操作。
2. 静态数组创建需指明数组中数据元素的　　　　和　　　　，系统根据类型和数量计算所需的容量并进行内存分配，同时会根据其类型给数组中的所有元素赋初值。
3. 一维数组的创建。
a=[0]*10
　　创建长度为 10 的静态数组，其中所有数组元素的初始值都为　　　　。
数据类型
索引
三、数组的创建
类型
数量　
0
创建方式 语句代码 含义
直接定义 a=[[0,0,0],[0,0,0],[0,0,0]] 创建3×3的二维数组，所有数组元素的初始值都为0
间接定义 a=[[0 for i in range(3)]for j in range(3)] a=[[0]*3 for i in range(3)]
4.二维数组的创建。
5. 注意不能使用语句 a=[[0]*3]*3 或 a=[[0 for i in range(3)]]*3 来创建，此方法是对一维数组的浅拷贝，当某个元素被修改时，其他行的同一位置元素也会同时被修改。
1. 数组元素的访问：可以通过　　　　和　　　　直接进行访问。
2. 数组元素的插入。
（1）在静态数组中插入新元素时，需要先将某位置及其后的所有元素　　　　一个位置后再插入，否则会导致插入位置的原数据丢失，过程如图所示。
（2）数组中插入数据一方面效率较低，另一方面可能会因超出限定数组长度而导致溢出或数据的丢失。
数组名
四、数组元素的访问、插入和删除
下标
后移
3. 数组元素的删除。
（1）在静态数组中删除元素时，需要将被删除元素位置后的所有元素　　　　一个位置，使它们将前驱元素覆盖，过程如图所示。
（2）数组中删除元素也有时间效率低的问题，而且存储的有效元素减少之后，会造成存储空间的浪费。
前移
典例 1 静态数组的特性不包括（　　）
A. 一个静态数组最多只能包含一种数据类型
B. 一个静态数组所占用的存储空间不随着数组元素的变化而改变
C. 静态数组能够最大限度地利用内存空间
D. 对静态数组的数组元素进行访问需要明确数组名和元素的位置下标
C
√
题型导向一　数组的特性
胜券点拨1
明考向 本题主要考查数组的特性
审关键 静态数组的存储空间、数据元素的特点、数组元素的操作等
考场思维快闪 A 数组元素的数据类型相同
B 静态数组存储空间固定不变
C 当静态数组中删除了大量的数据元素时，其占用的存储空间不会随之释放，故不能够充分地利用存储空间
D 在数组中需要通过数组名和下标来明确和访问唯一的数组元素
典例 2 下列使用 Python 创建二维数组的方法中，不合理的是 （　　）
A.a=[[2,5,7],[0,0,0]]
B.a=[["A"]*3]*3
C.a=[[0]*3 for i in range(5)]
D.a=[[3 for i in range(2)]for j in range(7)]
B
√
题型导向二　数组的创建
胜券点拨2
明考向 本题主要考查二维数组的创建
审关键 创建二维数组的方法
考场思维快闪 A 最普通的二维数组创建方式，该方式不会对数组的后续操作造成影响
B 该方法是使用浅拷贝实现的二维数组，这种情况下，当修改某个元素值时，其所在的同一列的所有元素都会被修改
C 快速方法生成一维数组，之后使用列表生成式生成二维数组，不会对数组的后续操作产生影响
D 使用列表生成式生成二维数组
典例 3 ［2024.1 浙江选考］数组元素 a[0]至 a[n-1]依次存放着 n 个数据，现需要将元素 a[n-1]插入在下标为 x（0≤xtemp=a[n-1]
for i in range(n-2,x-1,-1):
　　　　　　　
a[x]=temp
A.a[i+1]=a[i] B.a[i-1]=a[i]
C.a[i]=a[i+1] D.a[i]=a[i-1]
A
√
题型导向三　数组元素的访问、插入和删除
胜券点拨3
明考向 本题主要考查数组的操作
审关键 数据的插入
考场思维快闪 方框处需要将a[x]及其后面的所有元素都向后移动一位，i的初始值为n-2，故应将a[i]的值赋给a[i+1]
典例 4 有如下 Python 程序段：
a=[3,9,0,2,4,7,1,8,6];i=0
while iif a[i]%2==0:
j=i
while ja[j]=a[j+1]
j=j+1
a[j]=-1
else:
i=i+1
print(a)
执行该程序段后，输出的结果是 （　　）
A.[3,9,-1,-1,-1,7,1,-1,-1] B.[3,9,2,7,1,6,-1,-1,-1]
C.[-1,-1,0,2,4,-1,8,6] D.[3,9,7,1,-1,-1,-1,-1,-1]
D
√
胜券点拨4
明考向 本题主要考查数组的操作
审关键 数组元素的删除
考场思维快闪 该程序段逐个遍历数组中的数据，当元素a[i]的值为偶数时，将a[i]之后的所有元素前移，使得a[i]从数组中被删除，移动元素之后，将末尾元素赋值为-1
典例 5 ［2024.6 浙江选考］有如下 Python 程序段：
for i in range(0,len(a)-1,2):
if i>0 and a[i]a[i],a[i-1]=a[i-1],a[i]
if a[i]a[i],a[i+1]=a[i+1],a[i]
列表a有6个元素，运行该程序段后，
a 可能的值是 （　　）
A.[2,9,8,6,9,3]
B.[9,9,8,6,3,2]
C.[9,3,6,2,8,9]
D.[6,3,9,2,9,8]
D
√
题型导向四　数组与推理
胜券点拨5
明考向 本题主要考查数组与推理
审关键 数组元素的比较与交换
考场思维快闪 根据代码可知，当i的值为0时，a[i]的值比a[i+1]的值大（或相等）；当i的值为2、4时，a[i]的值比a[i-1]和a[i+1]的值都要大（或相等）。选项A中a[0]比a[1]小，故不可能。选项B中a[2]比a[1]小，故不可能。选项C中a[4]比a[5]小，故不可能
典例 6 有如下 Python程序段：
a=[56,174,81,9,213,13]
b=[0,0,0,0,0,0]
for i in range(len(a)):
for j in range(len(a)):
if a[i]>a[j]:
b[i]+=1
print(b)
执行该程序段后，输出的结果是 （　　）
A.[2,4,3,0,5,1] B.[2,4,1,0,3,5]
C.[3,1,4,5,2,0] D.[3,1,2,5,0,4]
A
√
胜券点拨6
明考向 本题主要考查数组与循环结构
审关键 数组b的功能
考场思 维快闪 该程序段遍历数组a的所有元素对（a[i]和a[j]）。对于每一对元素，若a[i]大于a[j]，则计数器b[i]的值增加1，故b[i]表示a[i]大于数组a中其他元素的个数
典例 7 ［2026湖丽衢模拟］有如下Python程序段，map和ker均为二维数组，分别存储如图a和图b所示的数据。
def ct(x,y,m):
s=0
for i in range(x,x+m):
for j in range(y,y+m):
s+=map[i][j]*ker[i-x][j-y]
return s
map=[[3,247,4],[2,180,3],[2,101,1]]
ker=[[-1,1],[-1,1]]
n=len(map);m=len(ker);c=[]
for i in range(n-m+1):
for j in range(n-m+1):
c.append(ct(i,j,m))
运行该程序段后，列表c的值是（　　）
A.[-420,422,-277,277]
B.[422,-420,277,-277]
C.[422,277,-420,-277]
D.[-277,277,-420,422]
题型导向五　二维数组
B
√
胜券点拨7
明考向 本题主要考查二维数组
审关键 函数ct的功能
考场思维快闪 ct函数实现从map中提取所有m×m的子矩阵，与ker进行点积（点积是指对应元素相乘后求和），将所有点积结果存储在列表c中。对于每个(i,j)，子矩阵是map[i:i+m,j:j+m]。对于(i,j)=(0,0)，子矩阵为[[3,247],[2,180]]，点积为3×(-1)+247×1+2×(-1)+180×1=422。对于(i,j)=(0,1)，子矩阵为[[247,4],[180,3]]，点积为247×(-1)+4×1+180×(-1)+3×1=-420。对于(i,j)=(1,0)，子矩阵为[[2,180],[2,101]]，点积为2×(-1)+180×1+2×(-1)+101×1=277。对于(i,j)=(1,1)，子矩阵为[[180,3],[101,1]]，点积为180×(-1)+3×1+101×(-1)+1×1=-277
典例 8 ［2023.6 浙江选考］已排序的列表 a 有 n 个整型元素，现要查找出现次数最多的值并输出。若出现次数最多的值有多个，则输出最前面的一个。实现该功能的程序段如下，方框中应填入的正确代码为 （　　）
c,m,v=1,1,0
for i in range(1,n):
　　　　　　　
print(a[v])
A.if a[i]==a[i-1]: B.if a[i]==a[i-1]:
c+=1 c+=1
if c>m: if c>m:
m=c m=c
v=i v=i
else: else:
c=1 c=1
A
√
C.if a[i]==a[i-1]: D.if a[i]==a[i-1]:
c+=1 c+=1
else: else:
if c>m: if c>m:
m=c m=c
v=i-1 v=i-1
c=1 c=1
题型导向六　数组的综合应用
胜券点拨8
明考向 本题主要考查算法和数组
审关键 代码的层级关系
考场思维快闪 因为列表a为有序列表，所以值相同的数一定是相邻的，因此计算每个数的出现次数，可以通过检查相邻两个数进行统计。变量v为出现次数最多的值在列表a中的索引，变量c为当前数值的出现次数，变量m为已统计次数中的最大值。若相邻两个数相等，则计数器c加1，否则应该将c置为1，重新开始计数。选项B、C逻辑结构错误，选项D未考虑最后一段相同值最多的情况
画线处应填入的正确代码为 （　　）
A.①d[i]>=d[rt] ②i
B.①d[i]>=d[lt] ②i+1
C.①d[i]<=d[rt] ②i
D.①d[i]<=d[lt] ②i+1
典例 9 ［2025 浙江 A9 协作体］用数组模拟区间合并：数组 d 中存放 n 个区间的起点和终点（区间按起点升序排列），对这 n 个区间进行合并操作并输出最终结果。例如，数组 d=[1,5,2,3,3,8,10,12]，其中第 1 个区间为[1,5]，第 2 个区间为[2,3]，以此类推，区间[1,5]和区间[2,3]的合并结果为[1,5]，继续合并剩余区间，最终合并结果为[1,8]和[10,12]。实现上述功能的 Python 程序如下：
lt,rt=0,1
for i in range(2,len(d),2):
if 　　　①　　　:
if d[i+1]>d[rt]:
rt=i+1
else:
print(d[lt],d[rt]) #输出区间
lt=　　　②　　　1
rt=lt+1
print(d[lt],d[rt])
C
√
胜券点拨9
明考向 本题主要考查数组及数组的遍历
审关键 分组遍历数组d中的元素并合并
考场思 维快闪 lt和rt初始表示第1个区间的起点和终点位置，然后从第2个区间的起点位置开始，遍历所有区间的起点，若当前区间的起点小于等于第1个区间的终点（d[i]<=d[rt]）且当前区间的终点大于第1个区间的终点（d[i+1]>d[rt]），则将当前区间合并到第1个区间，即将第1个区间的终点更新为当前区间的终点（rt=i+1）；若当前区间的起点大于第1个区间的终点（d[i]>d[rt]），则无法合并，因此输出第1个区间，然后lt更新为i，rt更新为lt+1，以合并剩余区间
　　　　　　　
else:
break
方框中有如下可选代码：
①ed1=j ②ed1=j-1 ③st2=j ④st2=j-1
方框中应填入的正确代码为 （　　）
A.①③ B.①④
C.②③ D.②④
典例 10 ［2025浙江 Z20联盟］列表 a 有 n 个元素，将列表 a 的前 p 个元素（1≤p≤n）与后 n-p 个元素对调，且不改变这 p 个元素（或 n-p 个元素）之间的相对位置。例如，a=[1,2,3,4,5]，当 p=2 时，对调后的结果为 a=[3,4,5,1,2]。实现上述功能的部分 Python 程序段如下：
p=int(input("p="))
st1=0;ed1=p-1
st2=p;ed2=len(a)-1
while st1<=ed1 and st2<=ed2:
i=st1;j=st2
while i<=ed1 and j<=ed2:
a[i],a[j]=a[j],a[i]
i+=1;j+=1
if i<=ed1:
st1=i
elif j<=ed2:
st1=i
C
√
胜券点拨10
明考向 本题主要考查算法和数组
审关键 不改变对调元素之间的相对位置
考场思 维快闪 该程序段以p为分隔点，将数组分为前后两个区域，第1个区域起点为st1，终点为ed1，第2个区域起点为st2，终点为ed2，用i和j两个指针分别从前向后扫描两个区域，若两个区域都有数据则直接交换a[i]和a[j]，如下图所示。
当其中一个区域遍历完成后，若还有剩余数据，还需要再次调换，此时要重新定义两个区域，如下图所示，第1个区域已遍历完，第2个区域还有数据，则重新定义第1个区域起点st1为i，终点ed1为j-1，第2个区域起点st2为j，终点ed2不变。再次调换数据，直至所有区域数据都调换完成
通法一　Python列表常用函数与方法
函数与方法 描述 实例
len(list) 统计列表list中元素个数 >>>list=[]
>>>print(len(list))
0
list.append(x) 在列表list末尾添加元素x >>>list=[22,33,44]
>>>list.append(55)
>>>print(list)
[22, 33, 44, 55]
list.insert(i,x) 在列表list中下标为i的位置处插入元素x >>>list=["A","B","D"]
>>>list.insert(2,"C")
>>>print(list)
['A', 'B', 'C', 'D']
list.pop(i) 将列表list中下标为i的元素删除，并且返回该元素的值，若i不指定，默认为-1，即最后一个元素 >>>list=["A","B","C","D"]
>>>list.pop(2)
'C'
>>>print(list)
['A', 'B', 'D']
list.count(x) 统计元素x在列表list中出现的次数 >>>list=[1,23,4,4,5,2,1,23,4]
>>>list.count(4)
3
list.index(x) 从列表list中找出元素x第一次出现的索引位置 >>>list=[1,23,4,4,5,2,1,23,4]
>>>list.index(4)
2
list.remove(x) 删除列表list中元素x的第一匹配项 >>>list=[1,23,4,4,5,2,1,23,4]
>>>list.remove(4)
>>>print(list)
[1, 23, 4, 5, 2, 1, 23, 4]
list.sort() 对列表list进行排序，默认升序 >>>list=[1,23,4,4,5,2,1,23,4]
>>>list.sort()
>>>print(list)
[1, 1, 2, 4, 4, 4, 5, 23, 23]
列表的索引（下标）支持负数，如a[-1]指向数组a中最后一个元素。使用上述列表的函数与方法后，可以将由列表模拟实现的数组视为动态数组，其中的增加、删除数组元素的操作由相应的函数实现。
通法二　静态数组与动态数组辨析
异同 静态数组 动态数组
存储空间 元素数量固定不变 元素数量根据数据的处理而改变
数据删除 删除某位置的元素并将后面的数据元素前移，使空位在数组的末尾（元素数量不变，删除的元素用空位表示） 可以使用Python列表的pop()方法，数组长度减1
数据插入 先将要插入位置的元素及其之后的元素后移，再插入新元素（数组元素的数量不变） 可以使用Python列表的append()方法，数组长度加1
通法三　一维数组与二维数组辨析
异同 一维数组 二维数组
数据访问 数组名[元素位置下标] 数组名[行下标][列下标]
数组创建的方法 ①a=[0,0,0] ②a=[0]*3 ③a=[0 for i in range(3)] ①d=[[0,0,0],[0,0,0],[0,0,0]]
②d=[[0,0,0]for i in range(3)]
③d=[[0 for i in range(3)]for j in range(3)]
使用 Python 代码将数组 b 的数据插入数组 a，要求最后得到的数组 a 中的数据仍是升序排列，具体代码如下。
#若数组 b 是无序数组
#数组 a 中要添加数据，需要先分配足够的存储空间a=[2,6,7,9,0,0,0,0]
b=[3,15,8,12] #插入的数组 b 无序
for j in range(len(b)):
i=0
while a[i]!=0:
if a[i]>b[j]: #将 b[j]插入到 a[i]位置
for k in range(len(a)-1,i,-1):
a[k]=a[k-1]
break
else:
i+=1
a[i]=b[j]
print(a) #输出：[2,3,6,7,8,9,12,15]
#若数组 b 是升序数组
#数组 a 中要添加数据，需要先分配足够的存储空间a=[2,6,7,9,0,0,0,0]
b=[3,5,8,12] #插入的数组 b 升序
i=j=0
while a[i]!=0:
if a[i]>b[j]:
for k in range(len(a)-1,i,-1):
a[k]=a[k-1]
a[i]=b[j]
j+=1
i+=1
#将数组 b 中剩余元素直接插入到数组 a 末尾的空位中
while ja[i]=b[j]
i+=1
j+=1
print(a) #输出：[2,3,5,6,7,8,9,12]
通法四　数组合并代码示例
1.下列关于数组特征的说法，不正确的是 （　　）
A.数组中所有元素的数据类型必须全部一致
B.理论上，数组中可以存放无数多个元素
C.数组在内存中占用的存储空间是连续且固定的
D.删除数组中的元素，数组占用的存储空间不会改变
非特别说明时，数组往往指的是静态数组，静态数组中的元素个数在数组定义时就已经确定。
一、数组的特性
B　
√
2.有如下Python程序段：
def re(arr):
　i=0
　for j in range(1,len(arr)):
　　if arr[j]!=arr[i]:
　　　i+=1;arr[i]=arr[j]
　return i+1
print(arr[:re(arr)])
有下列4组arr数据，经上述程序处理后，输出结果仍存在重复元素的是 （　　）
A.[8,9,9,9,8,8] B.[3,3,3,5,5,7] C.[8,8,3,3,3,1] D.[2,2,8,8,6,6]
该程序段只会在每一段连续重复元素中保留一个。当arr=[8,9,9,9,8,8]时，输出的结果是[8,9,8]。
二、数组元素的访问、插入和删除
A
√
3.［2025宁波九校联考］有如下Python程序段：
import random
a=[0]*6;i=0
while i<6:
　a[i]=random.randint(1,10)
　if i%3==0 or a[i]%2==i%2:
　　i+=1
print(a)
执行该程序段后，输出的结果可能是 （　　）
A.[1,7,10,8,6,3] B.[0,1,8,3,4,5] C.[5,3,6,1,1,4] D.[6,8,1,5,8,9]
数组a中的元素为[1,10]的随机整数，故选项B不可能。当i的值为1、5时，a[i]一定是奇数；当i的值为2、4时，a[i]一定是偶数（满足a[i]%2==i%2），故选项C、D不可能。
三、数组与推理
A
√
4.［2026.1浙江选考］有如下Python程序段：
#获取a的初始值，代码略
i=1
for j in range(1,len(a)):
　if a[j]　　a[i],a[j]=a[j],a[i]
　　i+=1
a[0],a[i-1]=a[i-1],a[0]
执行该程序段后，a的值为[2,4,3,5,6,9,7]，则下列选项中不可能为a[0]的初始值的是 （　　）
A.2 B.5 C.6 D.7
D
√
该程序段使用变量j从索引1开始遍历数组a，若当前元素a[j]小于a[0]，则交换a[j]与a[i]，然后i后移1位，因此a[1:i]中的元素一定都小于a[0]。最后交换a[0]与a[i-1]。若a[0]的初始值为2，则交换a[0]与a[i-1]前a=[2,4,3,5,6,9,7]，即a[0]为a中的最小值，i的值始终为1，这是可能的一种情况。若a[0]的初始值为5，则交换a[0]与a[i-1]前a=[5,4,3,2,6,9,7]，易知i=4，a[1:i]中的元素都小于a[0]，符合要求。若a[0]的初始值为6，则交换a[0]与a[i-1]前a=[6,4,3,5,2,9,7]，易知i=5，a[1:i]中的元素都小于a[0]，符合要求。若a[0]的初始值为7，则交换a[0]与a[i-1]前a=[7,4,3,5,6,9,2]，易知i=7，而a[1:i]中的元素9不小于a[0]，因此不可能。
5.有如下Python程序段：
n=3；m=2
dp=[[0 for i in range(n)] for j in range(m)]
dp.append([0,0,n-m])
dp.insert(-1,[n for i in range(n)])
print(dp)
执行该程序段后，下列选项中值为1的是 （　　）
A.dp[m][n] B.dp[n][m]
C.dp[len(dp)-1][0] D.dp[m][0]
程序运行结束后，dp的值为[[0,0,0],[0,0,0],[3,3,3],[0,0,1]]。选项A即dp[2][3]，下标越界报错。选项B即dp[3][2]，值为1。选项C即dp[3][0]，值为0。选项D即dp[2][0]，值为3。
四、二维数组
B
√
6.设数组lst的元素[a,b]表示一个整数序列区间（a、b为整数，且a≤b），如[2,4]表示整数2、3、4。现需要合并数组lst中所有的重叠区间，输出合并结果，例如，数组[[1,5],[9,15],[6,10],[20,25],[12,18]]可以合并为[[1,18],[20,25]]。实现上述功能的Python程序如下：
i=0;j=len(lst)-1
while i<=j:
　p=i+1
　while p<=j:
　　if lst[i][0]<=lst[p][0]:
　　　
　　else:
　　　lst[i],lst[p]=lst[p],lst[i]
　i=i+1
print(lst[0:i])
五、数组的综合应用
方框中应填入的正确代码为 （　　）
A.if lst[i][1]+1>=lst[p][0]:
　　lst[i][1]=max(lst[p][1],lst[i][1])
　　lst[p]=lst[j]
　　j=j-1
　　p=i+1
　else:
　　p=p+1
C.if lst[i][1]+1>=lst[p][0]:
　　lst[i][1]=max(lst[p][1],lst[i][1])
　　lst[p]=lst[j]
　　j=j-1
　else:
　　p=p+1
B.if lst[i][1]+1>=lst[p][0]:
　　lst[i][1]=max(lst[p][1],lst[i][1])
　　lst[p]=lst[j]
　　j=j-1
　　i=p+1
　else:
　　p=p+1
D.if lst[i][1]+1>=lst[p][0]:
　　lst[i][1]=max(lst[p][1],lst[i][1])
　　lst[p]=lst[j]
　　j=j-1
　i=p+1
　p=p+1
当前区间为i，向后查找能与当前区间合并的区间p，若区间p的左边界大于等于区间i的左边界（lst[i][0]<=lst[p][0]），且区间p的左边界小于等于区间i的右边界加1（lst[i][1]+1>=lst[p][0]），则将区间p合并到区间i，将区间i和区间p中较大的右边界作为区间i的右边界（lst[i][1]=max(lst[p][1],lst[i][1])）。然后删除原区间p，做法是用最后面的区间j覆盖原区间p（lst[p]=lst[j]），然后区间数减1（j=j-1），继续从区间i的下一个区间开始查找能与区间i合并的区间（p=i+1）。若区间p的左边界大于区间i的右边界加1，则不能合并，继续向后查找下一个能与区间i合并的区间（p=p+1）。
A
√
7.［2026浙江六校联考］有如下Python程序段：
from random import randint
a=[0]*6
for i in range(len(a)):
　a[i]=randint(1,10)
for i in range(1,len(a)):
　if i%2==1 and a[i]　　a[i],a[i-1]=a[i-1],a[i]
　else:
　　a[i]-=1
运行该程序段后，列表a的值不可能是 (　　)
A.[4,6,2,3,4,5] B.[2,4,0,3,2,2] C.[4,7,6,6,9,7] D.[4,4,2,5,3,5]
列表a中的元素初始都为0，第一个for语句将其赋值为[1,10]范围内的整数。第二个for语句实现：当i为奇数且a[i]小于a[i-1]时，交换两者的位置，否则将a[i]的值减1。选项C中，a[4]的值为9，若发生交换，则原本a[4]为8，a[5]为9，这与交换的条件a[i]=a[i-1]矛盾。
C
√
8.［2025浙南名校联盟］有如下Python程序段：
from random import randint
a=[randint(1,5) for i in range(6)]
i,n=0,len(a)
while i　r=i+1
　for j in range(i+1,n):
　　if a[i]!=a[j]:
　　　a[r]=a[j]
　　　r+=1
　n=r;i+=1
运行该程序段后，a的值可能是 (　　)
A.[3,4,6,5,6,5]　B.[5,4,3,3,5,3]　
C.[1,3,3,5,4,3]　D.[1,2,4,2,5,2]
a初始为含有6个元素的列表，元素为[1,5]范围内的整数。该程序段的功能是对列表a进行处理，使得前n个元素中的每个值都是唯一的，即对于每个a[i]，在a[i+1:n]中没有与之相等的元素。处理过程中，不重复的元素将往前覆盖重复的元素，变量r指向最后一个不重复元素，然后n更新为r。选项A中有元素超出范围，不符合要求。选项C、D中不重复元素没有往前覆盖，不符合要求。若初始列表为[5,4,3,5,5,3]，则可以得到选项B的结果。
B
√
9.某公路绿化带内等间距种了75棵树木，路政部门按种树位置依次从1~75编制路段序号。因台风致使部分树木被吹倒，为了尽快补种树木以恢复道路通行，路政部门决定对部分路段进行管制。现有m对路障标志，每对路障标志管制一组序号连续的路段，请编写Python程序，协助路政部门设计一套路障管制方案，使得被管制的路段序号总个数最少。程序运行效果如图所示。
请回答下列问题：
（1）定义如下process(data)函数，列表data中的元素表示需要补种树木的路段序号，函数功能是将列表data中连续的序号处理成区间形式，例如，data=[2,3,4,7,13,14]，处理后的结果为[[2,4],[7,7],[13,14]]。
def process(data):
n=len(data)
a=[];st=data[0]
for i in range(1,n):
if data[i]!=data[i-1]+1:
a.append([st,data[i-1]])
st=data[i]
a.append([st,data[-1]])
return a
若data为[3,4,5,7,8,9,12,13]，调用process(data)后，函数返回列表a为　　　　　　。
[[3,5],[7,9],[12,13]]
（1）函数process(data)将列表data中连续的序号处理成区间形式并返回。data中的连续序号有3~5、7~9、12~13，故返回列表a为[[3,5],[7,9],[12,13]]。
9.某公路绿化带内等间距种了75棵树木，路政部门按种树位置依次从1~75编制路段序号。因台风致使部分树木被吹倒，为了尽快补种树木以恢复道路通行，路政部门决定对部分路段进行管制。现有m对路障标志，每对路障标志管制一组序号连续的路段，请编写Python程序，协助路政部门设计一套路障管制方案，使得被管制的路段序号总个数最少。程序运行效果如图所示。
请回答下列问题：
（2）定义如下merge(a)函数，函数功能是从列表a中选择两个相邻区间进行合并，使得合并后的路段序号总个数最少，若有多组合并方案，则优先合并路段序号较小的区间。请在画线处填入合适的代码。
def merge(a):
　k=1
　mint= 　
　for i in range(2,len(a)):
　　if a[i][0]-a[i-1][1]　　　mint=a[i][0]-a[i-1][1]
　　　k=i
　a[k-1][1]=a[k][1]
　a.pop(k)　#删除列表a中索引为k的元素
　return a
a[k][0]-a[k-1][1]　或　a[1][0]-a[0][1]
（2）函数merge(a)从列表a中选择两个相邻区间进行合并，使得合并后的路段序号总个数最少，若有多组合并方案，则优先合并路段序号较小的区间，故需要初始化mint，以便在后续比较中找到最小的区间间隔，故填入代码为a[k][0]-a[k-1][1]，即列表a中第一个区间（索引为0）与第二个区间（索引为1）的间隔。
（3）实现上述功能的部分Python程序如下，请在画线处填入合适的代码。
def show(a):
　n=len(a);cnt=0
　for i in range(n):
　　print("第"+str(i+1)+"对路障管制范围：",a[i][0],"~",a[i][1])
　　cnt+=　　　① 　　　
　print("管制路段总个数为"+str(cnt)+"个，使用路障"+str(n)+"个")
#最多可使用m对路障标志
m=int(input("请输入可用的路障标志数量对："))
'''读取待补种的路段序号，路段序号为不重复的整数类型且构成升序，将其存入data，代码略'''
a=process(data)
k=　　　② 　　　
while k>0:
　a=merge(a)
　k-=1
show(a)
①a[i][1]-a[i][0]+1
②len(a)-m
（3）①在show(a)函数中，cnt用于统计管制路段的总个数。对于每个区间a[i]，管制路段的个数即该区间的结束序号减去开始序号再加1，故填入代码为a[i][1]-a[i][0]+1。②经过process(data)函数处理后，列表a中的元素表示需要管制路段的区间，len(a)表示需要管制的路段区间的数量。m表示可用的路障标志数量对，每一对路障标志用于管制一组序号连续的路段，因此，若当前需要管制的路段区间的数量大于m，则需要调用函数merge(a)进行合并区间操作，合并次数为len(a)-m。
9.某公路绿化带内等间距种了75棵树木，路政部门按种树位置依次从1~75编制路段序号。因台风致使部分树木被吹倒，为了尽快补种树木以恢复道路通行，路政部门决定对部分路段进行管制。现有m对路障标志，每对路障标志管制一组序号连续的路段，请编写Python程序，协助路政部门设计一套路障管制方案，使得被管制的路段序号总个数最少。程序运行效果如图所示。
请回答下列问题：
（4）若data为[3,4,5,7,8,9,12,13]，共有2对路障标志，执行上述程序段后，输出管制路段总个数为　　　　　　　个。
9
（4）若data为[3,4,5,7,8,9,12,13]，共有2对路障标志，则程序执行过程如下：首先调用process(data)函数，得到a=[[3,5],[7,9],[12,13]]。然后进入while循环，因为k=3-2=1，所以循环会执行1次。调用merge(a)函数找到相邻区间间隔最小的两个区间进行合并，对于a=[[3,5],[7,9],[12,13]]，计算相邻区间间隔：第一个区间[3,5]和第二个区间[7,9]的间隔为7-5=2。第二个区间[7,9]和第三个区间[12,13]的间隔为12-9=3。所以合并第一个区间和第二个区间，得到a=[[3,9],[12,13]]。最后调用show(a)函数，计算管制路段总个数，对于区间[3,9]，管制路段个数为9-3+1=7；对于区间[12,13]，管制路段个数为13-12+1=2，所以管制路段总个数为7+2=9个。
10.［2024.6浙江选考］某数据序列data中的元素均为小于127的正整数。现要对data进行加密，处理过程分“变换”和“重排”两步。
　　“变换”处理方法是用指定的n组序列R0、R1…Rn-1依次对data进行变换。利用Ri对data进行变换的过程是：在data中查找所有与Ri相同的子序列，将找到的每个子序列中的各元素值加上Ri的长度值Li，并在各子序列前插入一个标记元素（值为127+Li），这些子序列及标记元素不再参与后续的变换。如data为[3,5,1,6,3,8,7,5,1,8,7]，指定的两组序列为[5,1]、[3,8,7]，“变换”处理后的data为[3,129,7,3,6,130,6,11,10,129,7,3,8,7]。
　　对data“重排”处理通过给定的shuff函数实现。
请回答下列问题：
（1）若data为[3,5,1,6,3,8,7,5,1,8,7]，指定的两组序列为[5,1]、[8,7]，经过“变换”处理后，data中插入的标记元素个数为　　　　。
（1）data中有2组子序列与指定序列[5,1]相同，有2组子序列与指定序列[8,7]相同，需要进行“变换”处理，每个变换的子序列前会插入一个标记元素，故插入的标记元素个数为4。
4
（2）“重排”处理的shuff函数如下：
#根据列表c对列表data进行重排
def shuff(data,c):　
　'''若列表data的长度不是列表c长度的整数倍，则用0补足，代码略'''
　m=len(c)
　s=[0]*m
　k=0
　while k　　for i in range(m):
　　　s[i]=data[k+i]
　　for i in range(m):
　　　data[k+i]=s[c[i]]
　　k+=m
若data为[3,129,7,3,130,6,11,10]，c为[1,3,0,2]，调用shuff(data,c)后，data的最后一个元素值为　　　　　　　。
（2）根据代码可知，“重排”处理的过程为：先对列表data分组，以列表c的长度m作为每一组的元素个数，不足的用0补齐；再分别对每组按照列表c的值作为每组索引的顺序进行“重排”。题干所给列表data的长度恰为列表c长度的整数倍，因此“重排”后，data的值为[129,3,3,7,6,10,130,11]。
11
（3）实现加密功能的部分Python程序如下，请在画线处填入合适的代码。
def compare(data,i,r):
　'''函数功能：返回data从索引i位置、r从索引0位置开始的连续相等元素的个　
　数'''
　'''例如r为[7,3,6]，data从索引i位置开始的元素依次为7，6，7，3，…，函
　数返回1'''
　j=0
　while j　　if 　　　①　　　:
　　　break
　　else:
　　　j+=1
　return j
①r[j]!=data[i+j]
def trans(data,r,segs):
　newsegs=[]
　for s in segs:
　　if s[0]==0:
　　　h=i=s[1]
　　　m=len(r)
　　　while i+m<=s[2]+1:
　　　　if compare(data,i,r)==m:
　　　　　if i>h:
　　　　　　'''为newsegs追加一个元素'''
　　　　　　newsegs.append([0,h,i-1])
　　　　　newsegs.append([m,i,i+m-1])
　　　　　i+=m
　　　　　　　　② 　　　
　　　　else:
　　　　　i+=1
　　　if h<=s[2]:
　　　　newsegs.append([0,h,s[2]])
　　else:
　　　newsegs.append(s)
　return newsegs
②h=i
def update(data,segs):
　for s in segs:
　　if s[0]!=0:
　　　data.append(0)
　p=len(data)-1
　for i in range(len(segs)-1,-1,-1):
　　for j in range(segs[i][2],segs[i][1]-1,-1):
　　　　　　③
　　　p-=1
　　if segs[i][0]>0:
　　　data[p]=127+segs[i][0]
　　　p-=1
'''读取待加密数据存入data，读取指定的若干组用于变换的序列存入rs，代码略'''
③data[p]=data[j]+segs[i][0]
'''列表segs用于记录data的变换信息，segs[i]包含三个元素，segs[i][0]、segs[i][1]、segs[i][2]分别表示data中一个子序列的状态、起始位置和结束位置，如果segs[i][0]为0，则表示该子序列未经过变换。'''
segs=[[0,0,len(data)-1]]
for r in rs:
　#根据r更新segs
　segs=trans(data,r,segs)　
#利用segs完成对data的变换操作
update(data,segs)　
c=[1,3,0,2]
shuff(data,c)
#输出加密后的data序列，代码略
①r[j]!=data[i+j]　②h=i　③data[p]=data[j]+segs[i][0]
（3）①compare函数中，j是r的索引，i是data的索引，从列表data的i位置与列表r的0位置开始比较，若元素相等，则j后移一位，比较下一个元素；若不相等，则退出循环，最终函数返回连续相等的元素个数，故填入代码为r[j]!=data[i+j]。②在trans函数中，data表示原始数据，r是当前变换序列，segs记录了当前data的变换信息。对于其中一条变换信息s，s[0]等于0表示对应的子序列未标记，可以参与变换，h表示待处理的子序列的初始位置。若子序列中存在compare(data,i,r)==m，即找到了需要进行变换的子序列data[i:i+m]。若i>h，则需要在newsegs中追加data[h:i]的未标记子序列，并追加data[i:i+m]的已标记子序列，标记元素为r的长度m。此时，该子序列中data[h:i+m]均为已处理状态，在i+=m后，需要更新待处理的子序列的初始位置h为i。③update函数根据变换信息segs处理data中的数据。首先遍历列表segs，若需要变换（s[0]!=0），则在列表data添加0，预留插入标记值的位置。p逆序遍历列表data，i逆序遍历变换信息，j从变换信息的结束索引segs[i][2]逆序遍历到开始索引segs[i][1]，然后使用代码data[p]=data[j]+segs[i][0]进行变换并对应到最终的位置上。若segs[i][0]>0，则需要将原值改为标记元素，即为127+segs[i][0]。

展开更多......

收起↑