探月少儿编程手机版

探月少儿编程手机版是一款实用的在线编程教育应用，它能让每一位少儿用户体验多维度的在线编程学习，助力孩子每天高效掌握编程知识。该应用提供了丰富的优质学习资源，帮助孩子快速获取最新的教学内容，全新的编程课程每日更新，源码课程也能随时开启，让编程学习变得更轻松。

探月少儿编程手机版还提供了丰富且实用的拓展探索功能，学生能够在此一站式体验KIDs图形化编程、NOMO图形化编程、KITTENN图形化编程等多种课程，帮助孩子轻松掌握编程知识。

软件特色

每门课程内容都配备了专业教师进行指导，学习程序编写不再是孤独的事了。

课堂教学的知识要点被融入编程猫原创的动漫故事情节之中，兼具趣味性，nofungodie。

把程序编写的专业知识和Steam等多领域的综合知识相融合，五格数理、历史时间、科学等知识要点全都涵盖在内。

软件亮点

这款软件对孩子培养计算机与编程方面的兴趣爱好很有帮助。

自己家的孩子年纪轻轻就会编程，说出去感觉挺有面子的。

不过还是希望每个孩子学习编程都是源于兴趣，而非为了满足家长的面子需求。

软件优势

Python编程

真Python学习环境，简单易用。

数据科学

解锁更多数据科学功能，培养学生数据思维。

图形化编程

从图形化到代码，一个编程工具就搞定。

机器人编程

支持多种硬件组合用于教学，让舞台角色和机器人之间产生多样且生动的互动。

算法课程

一、冒泡排序

冒泡排序的概念

冒泡排序是最为简单的排序算法之一，它通过在一组数据中逐步将较大（或较小）的数据向右推移来实现排序。

冒泡排序的原理很容易理解，每一轮处理都会把这一轮里最大（或者最小）的数据移到最右边。每个数据就像水里的气泡，小气泡会往上浮，被排到最上面；大气泡则依次沉在下面，这样的过程就可以形象地比作“冒泡”。

冒泡排序的基本思想（以升序为例）

逐一对比相邻的两个数，把数值较小的数置于前，数值较大的数放在后。

第一轮排序从第一个元素开始，先将它与第二个元素比较，要是出现大数在前、小数在后的反序情况就交换两者位置；接着让第二个元素和第三个元素比较，若有反序也交换；就像这样依次进行，直到比较完最后一对元素。第一轮结束后，最后一个元素就是所有元素里的最大值。

接下来开展第二轮比较。依旧从第一个元素开始，先让它与第二个元素进行比较，一旦出现反序的情况就进行交换；接着让第二个元素和第三个元素比较，若有反序则交换；按照这个顺序依次进行，直到完成最后一对元素（也就是倒数第二对元素）的比较。通过这样的操作，倒数第二个数就会成为第二大的数。

依次排序下去，n个数排序共需要进行n-1轮。

示例模拟：

58437

58437将5和8比较，不交换位置

54837将8和4比较，交换位置

54387将8和3比较，交换位置

54378将8和7比较，交换位置，8被移至末尾

冒泡排序算法框架（伪代码）

冒泡排序通过双层嵌套循环来完成，外层循环负责把控排序的轮次，内层循环则负责管理排序元素下标的变动以及数据对的比较操作。

fori(0~n-1)#共进行n-1轮排序

forj(0~n-1-i)#第i轮排序（次数）

if数据对反序，则:

数据交换

冒泡排序程序的实现（升序）

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

count=len(a)

foriinrange(0,count-1):

for j in range(0, count - 1 - i):

ifa[j]>a[j+1]:

a[j],a[j+1]=a[j+1],a[j]

print(a)

运行结果如下：

[1,2,3,5,6,7,8]

思考一下，若要对列表里的元素进行降序排列，该怎么修改程序呢？

是不是只需要将上述代码中的大于号改成小于号即可？

思考题

某书店在5所学校的流动售书量（单位：本）依次为80、125、64、68、46。现运用冒泡排序法对这些数据进行升序排列，当完成第二轮排序后，得到的结果是

有一组初始数据：23、25、18、63、84、77、65、9、33、17。运用冒泡排序算法对其进行升序排列，要完成所有数据的排序，最多需要经过若干轮加工。

A、5B、6C、8D、9

二、选择排序

选择排序的概念

选择排序算法是对冒泡排序算法的改进。

选择排序的操作步骤是：先从所有待排序元素里找出数值最小（或最大）的那个元素，要是它不在最左边的第一个位置，就把它和最左边第一个元素交换位置；接着在剩下的元素中再找出数值最小（或最大）的元素，要是它不在左边的第二个位置，就把它和左边第二个元素交换位置；按照这样的方式依次进行，直到所有元素都排列成一个有序的序列。

选择排序算法符合人们日常的排序习惯。

在对n个元素进行排序时，选择排序与冒泡排序的比较次数是一样的，不过选择排序的交换次数比冒泡排序更少，所以它的效率更高。

选择排序的基本思想

对n个数进行排序，总共要开展n-1轮操作。我们以从小到大的排序方式为例：

在排序的第一轮操作中，我们需要从第1个元素到第n个元素的范围内，找出其中数值最小的那个元素。要是这个最小元素的位置并非第1位，那就把它和第1个元素互换位置。当这一轮排序完成后，第1个元素就会成为整个序列里最小的元素。

第二轮，在第2个到第n个元素的范围内找出最小的那个元素，要是它并非第2个元素，就把它和第2个元素互换位置。当第二轮排序完成后，第2个元素就成为了整个序列里第二小的元素。

以此类推，在第i轮排序时，我们要从第i个元素到第n个元素的范围内找出最小的那个元素，并把这个最小元素的索引标记为k。要是这个最小元素的位置不在第i位（也就是k不等于i），那就把第i个元素和这个最小元素交换位置，具体操作就是：序列[i]和序列[k]的值互相调换，即序列[i], 序列[k] = 序列[k], 序列[i]。

排序过程会持续进行，直到序列中仅剩下最后一个元素时停止。此时，这个最后剩下的元素便是整个序列里最大的那个元素。

选择排序算法框架（伪代码）

选择排序算法同样借助双层嵌套循环来完成，外层循环负责把控排序的轮次，内层循环则用于控制排序元素下标的变动范围。在每一轮的排序进程里，都得用一个临时变量来保存该轮排序里最小元素（或是最大元素）的下标。

foriin(0~n-1)#共进行n-1轮排序

k=i

forjin(i+1,n)#第i轮排序（次数）

if找到一个比k位置更小的元素，则：

用k记录j的位置

ifi!=k，则：

交换i和k位置上的数据

选择排序程序的实现（升序）

a=[3,4,1,2,0,9,10]

count=len(a)

foriinrange(0,count-1):

k=i

forjinrange(i+1,count):

ifa[k]>a[j]:

k=j

ifk!=i:

a[k],a[i]=a[i],a[k]

print(a)

运行结果如下：

[0,1,2,3,4,9,10]

思考一下，如果按照降序排列，该如何修改程序？

体会变量k的用意。

与冒泡排序相比，选择排序的优劣是什么？

思考题

使用选择排序算法对一组学生的身高数据进行升序排列，已知第一轮排序完成后的数据序列是：166、169、177、175、172，那么下列选项里有可能是原始数据序列的是。

A、175、177、169、166、172

B、177、169、166、175、172

C、166、177、169、175、172

D、166、169、172、175、177

某校计划采购一套多媒体教学设备，有5个参考价位，具体如下：23万元、18万元、17万元、16万元、15万元。若运用选择排序算法对这些价格按从高到低的顺序进行排序，那么需要进行数据交换的次数是多少。

A、1B、3C、4D、5

下列关于排序的说法，错误的是。

A、相对来说，选择排序算法的效率要比冒泡排序算法的效率更高一些。

B、冒泡排序算法与选择排序算法均需运用双循环结构。

C、针对n个无序数据，无论是采用冒泡排序还是选择排序的方法，都必须完成n-1轮的处理流程

D、冒泡排序算法的程序实现通常会用到数组变量k，选择排序则一般不需要使用该变量。

三、插入排序

插入排序的概念

插入排序的算法步骤是这样的：首先把待排序数列里的第一个元素当作一个有序的子序列，接着从第二个元素开始，按照从小到大或者从大到小的顺序，把后续元素逐个插入到这个有序子序列里，直到处理完最后一个元素。这和玩扑克牌时边抓牌边整理的过程很相似，每拿到一张新牌，就把它放到合适的位置上。

插入排序的基本思想

先将列表中的前两个元素按顺序排列（以升序为例）。

然后，每次选取下一个待排序的元素，依据它的大小将其插入到前面已经排好序的序列里，让序列保持有序状态，直至所有待排序元素都完成插入操作。

实例演示

已知列表a=[5,3,5,2,8]，需要将该列表按照升序方式进行排列。

第一轮插入（只要将第2个元素与第1个元素比较）

先将待插入的元素a[1]暂存到变量key中；

把key和前面已经排好序的元素进行比较，当key[0]的条件满足时，意味着key需要插入到a[0]的前面，这时要把a[0]向后移动一个位置，存放到a[1]里。

将key放入a[0]中。

第二轮插入操作（把第3个元素插入到前面已经排好序的两个元素组成的序列里）

先将待插入的元素a[2]暂存到变量key中；

把key和前面已经排好序的元素进行比较，key[1]的条件不满足，这意味着key需要插入到a[1]的后面，也就是a[2]这个位置。

将key放入a[2]中。

第三轮插入操作（把第4个元素插入到之前已经排好序的三个元素组成的序列里）

先将待插入的元素a[3]暂存到变量key中；

将key与前面已排好序的序列进行比较，当key[2]的条件满足时，表明key需要插入到a[2]的前面，此时将a[2]向后移动一个位置，存放到a[3]中。

再与前一个元素进行比较，当条件key[1]满足时，意味着key需要插入到a[1]的前面位置，于是将a[1]向后移动一个位置，放置到a[2]当中。

再和前一个元素进行比较，key[0]的条件成立，这表明key需要插入到a[0]的前面，于是把a[0]向后移动一位，将key放到a[0]的位置上。

将key放入a[0]中。

第四轮插入操作（把第5个元素插入到之前已经排好序的4个元素组成的序列里）

与第二次插入的情况类似，这个元素比a[3]要大，所以应当插入到a[3]的后面，也就是它的位置不需要变动。到这里，插入排序就全部完成了。

插入排序程序实现

示例程序（1）

a=[5,3,5,2,8]#初始化一个列表

for i in range(1, len(a)): # 设置插入排序的轮次

key=a[i]#将待排序元素暂存到变量key中

j=i-1#将待比较元素的索引存入变量j中

当j大于等于0且a[j]大于key时：#元素比较

a[j+1]=a[j]#将大元素往后移动

j-=1#更新待比较元素的索引

a[j+1]=key#将待插入元素往前移动

print(a)#打印最终结果

运行结果：

[2,3,5,5,8]

示例程序（2）

a=[5,3,5,2,8]#初始化一个列表

for i in range(1, len(a)): # 设置插入排序的轮次

j=i-1#将待比较元素的索引存入变量j中

当j大于等于0且a[j]大于a[i]时：#元素比较

j-=1

if j == 0: # 若待插入的元素是最小的，就把它插入到最前端

a.insert(0,a[i])

else: # 若待插入的元素并非最小，则把它插入到索引j+1的前面

a.insert(j+1,a[i])

a.pop(i+1)#最后将待插入的原始数据删除

print('a=,a')#打印最终结果

运行结果：

a=[2,3,5,5,8]

四、顺序查找

查找是程序开发与现实生活里频繁运用的方法，同时也是一种查询数据的技术，它的目的是用更少的步骤或者在更短的时间内定位到需要的数据。

这里主要掌握顺序查找和对分查找算法。

顺序查找的概念

假设要从n个元素里查找元素x是否存在，最基础的办法就是从第一个元素开始逐个往后查找，这种查找方式就是顺序查找。

顺序查找的核心思路是：从序列的首个元素起，按照先后次序依次把每个元素和待查找的目标值（即查找键）进行比对。要是其中某个元素与查找键完全一致，就意味着查找成功，此时会返回该元素在序列中的位置；如果遍历完所有元素都没找到匹配项，就输出查找失败的结果。

顺序查找的处理过程

假定列表a包含n个元素，而要查找的键已存储在变量key里。

从列表a中的第1哥元素a[0]开始，依次判断各元素的值是否与key相等，若某个元素a[i]的值等于key，则找到了指定的数据，对应的位置索引为i，停止程序；若找遍了所有的n个元素，没有一个元素的值等于key，输出未找到，停止程序。

顺序查找的程序实现

在列表中查找元素26。

lst = [32, 17, 56, 25, 26, 89, 65, 12] # 对列表进行初始化

key=26#初始化要查找的元素

b=-1#要查找元素的索引

m=len(lst)#列表长度

foriinrange(0,m):

iflst[i]==key:

b=i

break

ifb==-1:#-1表示未找到

print("列表lst中不存在要查找的元素[" + str(key) + "]。")

else:

print("要查找的元素[" + str(key) + "]的索引为：" + str(b))

思考题

想一想，顺序查找与枚举算法的相似之处与不同之处。

为了找到课文里第一次描写景色的自然段，小张同学翻开课本，逐段阅读来进行查找。这种查找方法是**顺序查找法**。

A、无序查找B、顺序查找C、对分查找D、随机查找

在23、41、54、26、84、52、65、21这些数字里找52，按照从后往前的顺序来查找，要查找的次数是多少。

A、2次B、3次C、7次D、1次

五、对分查找

在一堆无序的数列里查找某个特定的数时，我们可以采用顺序查找的方法；而当面对一个已经排好顺序的有序数列时，除了顺序查找之外，是否存在更高效、更简便的查找算法呢？

对分查找的概念

对分查找又称“二分查找”，是一种高效的查找方法。

对分查找的前提条件是：所查找的数据序列必须是有序的，具体可以是升序排列，也可以是降序排列。

对分查找的核心思路是：先把待查找的数据和有序数列中间位置的数据对比，若两者相同，查找就成功了；要是不同，就依据数列的有序特性，判断待查数据该在数列的前半段还是后半段；接着在缩小后的新范围内，重复上述对比步骤继续查找，直到找到目标数据（查找成功），或者确认目标数据不存在（查找失败）。

对分查找的处理过程

当key作为查找键，列表a中存储着n个已按升序排列的元素时，采用对分查找法时，会将查找范围[i,j]中间位置的元素a[m]与key进行比较，此时必然会出现以下三种情况：

若key[m]，查找键key小于中间位置数据a[m]。由于列表a按升序排列，可确定key的值应在列表a的前半段，即在新范围（i,

若key=a[m]，查找成功。

当key大于中间位置的数据a[m]时，说明查找键key的值比a[m]大，由此可以确定key必然处于列表a的后半部分，因此接下来需要在新的查找范围（m+1,j）内继续进行查找操作。

中间位置数据a[m]的下标m的计算方法如下：

m=(i+j)//2或m=int((i+j)/2)

对分查找的程序实现

因为比较次数无法确定，所以采用while语句来实现循环。

在while循环体中用if语句判断查找是否成功。

若查找成功，就输出查找结果，同时使用break语句终止循环。

若查找未成功，需判断查找键位于数组的前半部分还是后半部分，以此缩小查找范围，进而继续进行查找操作。

假设列表lst为[12,17,23,25,26,35,47,68,76,88,96]，现在需要查找其中的元素key=25，对应的对分查找程序如下：

#初始化变量

lst = [12, 17, 23, 25, 26, 35, 47, 68, 76, 88, 96]

key=25

n=len(lst)

#i为左边的索引号，j为右边的索引号

i,j=0,n-1

b=-1

#执行查找操作

whilei

m=(i+j)//2#计算中间索引

ifkey==lst[m]:#恰好找到目标元素

b=m#将目标元素的索引赋值给b

break#找到目标元素，停止查找

elif key > lst[m]: # 说明目标元素位于列表的后半部分

i=m+1#将左边的索引移到中间偏后一位

else:#如果目标元素在前半段

j=m-1#将右边的索引移到中间偏前一位

#查找完成之后，根据索引b的值判断是否查找成功

ifb==-1:#-1表示元素未找到

print("列表lst中不存在要查找的元素[" + str(key) + "]。")

else:

print("要查找的元素[" + str(key) + "]的索引为：" + str(b))

对分查找的查找次数估算

当对元素数量为n的列表执行对分查找时，不管最终有没有找到目标元素，最多只需要进行log₂(n)次查找操作就能得出结果；而采用顺序查找算法的话，在最不利的情况下要进行n次查找，在最理想的情况下仅需查找1次，其平均查找次数则为(n+1)/2。

思考题

下列有关查找的说法，正确的是。

A、顺序查找时，被查找的数据必须有序

B、对分查找时，被查找的数据不一定有序

C、顺序查找总能找到要查找的关键字

D、一般情况下，对分查找的效率较高

某列表包含7个元素，按顺序排列为19、28、30、35、39、42、48。如果使用对分查找算法在这个列表里查找元素48，那么需要查找几次呢？

A、1B、2C、3D、4

六、模拟考题

单选题：

编程大赛的成绩排名，可以采用的算法是。

A、解析算法B、枚举算法C、排序算法D、查找算法

对一组初始时记录无序的数据：7、9、3、2、5，采用选择排序算法，按从小到大的顺序进行排列，那么第一轮排序结束后的结果是。

A、7、9、2、3、5

B、2、9、3、7、5

C、2、7、9、3、5

D、2、3、5、7、9

L=[9,2,8,6,3,4]，运用选择排序法对其进行升序排列，经过第二轮排序后得到的结果为。

A、[2,3,8,6,9,4]

B、[2,8,3,6,4,9]

C、[2,6,3,4,8,9]

D、[2,3,4,6,8,9]

给定初始记录关键字序列为[5,2,6,3,7]，采用插入排序算法对其进行升序排列，那么第二次插入操作完成后的排序结果是。

A、[5,2,3,6,7]

B、[2,5,3,6,7]

C、[2,5,6,3,7]

D、[2,3,5,6,7]

对于n个元素，采用顺序查找算法时，在最坏情况下需要进行n次查找才能结束。

A、n B、n除以2的结果 C、n的平方 D、以2为底(n+1)的对数

对于n个元素，采用对分查找算法时，最坏情况下需要查找的次数才会结束。

A、nB、n/2C、n**1D、log2（n）

编程题

在一个列表中生成n（n≥10）个50以内的数据，去除其中重复的数据后按升序排列输出，并且输出被删除的重复数据的个数。

例如输入：n=10

随机生成列表：a=[1,2,3,7,4,7,3,8,5,7]

输出：a=[1,2,3,4,5,7,8]

输出：共删除数据为3个

请编写程序实现上述功能，或补全代码。

importrandom

maxn = int(input("请输入需要生成的数据数量："))

_____1_____

foriinrange(maxn):

a.end(random.randrange(1, 50, 1))

print("原始数据：",a)

key,n=0,maxn

whilekey

i=n-1

while_____2_____:

i-=1

ifi==key:

key+=1

else:

a.remove(____3____)

n-=1

foriinrange(n):

for j in range(len(a) - 1, i, -1):

ifa[j]

a[j],a[j-1]=_____4_____

print("去重后排序数据：",a)

print("总共删除的数据数量为：",____5____,"个")

针对列表对象a=[7,4,7,3,9]，采用插入排序算法实现升序排列，以下是部分代码，请完成代码补全。

a=[7,4,7,3,9]#初始化列表

______1______

foriinrange(1,count):

key=____2____

j=i-1

whilej>=0anda[j]>key:

a[j+1]=a[j]

_____3_____

a[j+1]=key

print(a)

科技小组的两个小队分别收集了西红柿生长的数据。两队都对各自的数据做了升序排列，其中一队的数据为a=[1,3,4,6,7,13,17,21]，另一队的数据是b=[2,5,6,8,10,12,14,16,18]。现在需要把这两组数据合并起来，形成一个按从小到大顺序排列的新列表。

输入：

3,4,6,7,13,17,21

5,6,8,10,12,14,16,18

输出：

[1,2,3,4,5,6,6,7,8,10,12,13,14,16,17,18,21]

请编写程序实现上述功能，或补全代码。

x=input

s=x.split(',')

a=[]

for i in range(_____1_____):

a.end(int(s[i]))

y=input

s=y._____2_____

b=[]

foriinrange(len(s)):

b.end(int(s[i]))

ret=[]

i=j=0

while len(a) >= i + 1 and _____3_____:

ifa[i]

_____4_____

i+=1

else:

ret.end(b[j])

j+=1

iflen(a)>i:

ret+=a[i:]

iflen(b)>j:

_____5_____

print(ret)

更新日志

品牌更名