精华内容
下载资源
问答
  • Python编程基础08:循环结构

    千次阅读 多人点赞 2020-11-12 15:50:25
    文章目录一、为什么要用循环(一)老老实实的笨方法(二)采用循环结构的巧方法1、采用计数循环(for循环)(2)采用条件循环(while循环)二、条件循环 - while循环三、计数循环 - for循环 跑道是一圈一圈的,...

    文章目录


    在这里插入图片描述

    • 跑道是一圈一圈的,可以看作是循环的

    一、为什么要用循环

    现在有一个任务,要求你输出一百遍“好好学习,天天向上!”,想一想,你会怎么做?

    (一)老老实实的笨方法

    print("第1遍写:好好学习,天天向上!")
    print("第2遍写:好好学习,天天向上!")
    print("第3遍写:好好学习,天天向上!")
    print("第4遍写:好好学习,天天向上!")
    ……
    print("第100遍写:好好学习,天天向上!")    
    

    采用此方法,当然可以完成任务,但是显然很糟糕,如果要求你输出一万遍,那得有一万行打印语句,那样看起来岂不令人崩溃?

    (二)采用循环结构的巧方法

    1、采用for循环输出百遍口号

    • 编写程序 - 采用for循环输出百遍口号.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 你看,两行代码,就可以输出百行口号,是不是感觉挺爽?

    2、采用while循环输出百遍口号

    • 编写程序 - 采用while循环输出百遍口号.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 你看,殊途同归,不一样的循环语句,一样的输出结果!

    二、条件循环 - while循环

    (一)语法格式

    • 一般格式
    while 条件表达式:
    	循环体
    
    • 具体格式
    初始条件
    while 循环条件:
    	循环体
    	[break|continue]
    	更新条件
    

    (二)执行情况

    在这里插入图片描述

    • 当条件表达式的返回值为真时,则执行循环体中的语句,执行完毕后,重新判断条件表达式的返回值,直到表达式返回的结果为假时,退出循环。
    • 现实生活中的例子来理解while循环的执行流程。在体育课上,体育老师要求同学们沿着环形操场跑圈,要求当听到老师吹的哨子声时就停下来。同学们每跑一圈,可能会请求一次老师吹哨子。如果老师吹哨子,则停下来,即循环结束,否则继续跑步,即执行循环。
    • 好友聚会,开怀畅饮,不醉不休。一杯接着一杯地喝下去,直到喝趴下,喝酒循环才结束。

    (三)案例演示

    任务1、永不消逝的电波 - 死循环

    • 编写程序 - 永不消逝的电波.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 循环永不结束,除非用户强制终止。

    任务2、采用while循环计算1 + 2 + 3 + …… + 100的值

    • 这是一个非常经典的数学计算问题:公差为1的等差数列求和。
    • 编写程序 - 采用while计算1 + 2 + 3 + …… + 100的值.py
      在这里插入图片描述
    • 只要i <= 100成立,循环都会继续,直到i = 101,不满足条件了,循环才终止
    • 运行程序,查看结果
      在这里插入图片描述
    • 修改一下代码,输出循环结束后循环变量i的值
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    课堂练习:采用while循环计算1 + 3 + 5 + …… + 99的值

    • 提示:有三种方法可以解决此问题。
      (1)修改循环的更新条件:i = i + 2
      (2)在循环结构里嵌套一个过滤器:if i % 2 == 1: sum = sum + i
      (3)修改循环条件:i <= 50,修改累加语句 sum = sum + 2 * i - 1
    • 运行程序,查看结果
      在这里插入图片描述

    任务3、采用while循环打印水仙花数

    水仙花数:是指等于其各位数字立方和的三位数。

    153 = 1 3 + 5 3 + 3 3 153=1^3+5^3+3^3 153=13+53+33
    370 = 3 3 + 7 3 + 0 3 370=3^3+7^3+0^3 370=33+73+03
    371 = 3 3 + 7 3 + 1 3 371=3^3+7^3+1^3 371=33+73+13
    407 = 4 3 + 0 3 + 7 3 407=4^3+0^3+7^3 407=43+03+73

    分析问题,首先水仙花数是三位数,那么我们可以确定范围:100~999,这个我们可以通过循环结构来搞定:

    n = 100
    while n <= 999:
        n = n + 1
    

    然后对于这个范围的每个数n,我们要去判断它是否等于其各位数字的立方和,这里的难点或关键在于如何分解一个三位数,得到它的每位数字。

    假设我们已经把三位数n分解成百位数p3,十位数p2,个位数p1,
    这样我们的筛选条件就可以写出来:n == p3 * p3 * p3 + p2 * p2 * p2 + p1 * p1 * p1。

    如何拆分一个三位数n呢?

    首先求n的个位数:n % 10
    然后要将三位数变成两位数:n = n // 10
    对于新的两位数n,又求它的个位数:n % 10
    然后要将两位数变成一位数:n = n // 10

    也就是说我们可以交替使用求余和整除运算将一个三位数拆分,得到它的个位数、十位数和百位数。当然这个分解方法可以推广到任何多位数的拆分。

    • 编写程序 - 采用while循环打印水仙花数.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 优化代码
      在这里插入图片描述

    任务4、采用while循环破解令狐大侠难题

    • 编写程序 - 采用while循环破解令狐大侠难题.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    三、计数循环 - for循环

    (一)语法格式

    for 迭代变量 in 对象:
    	循环体
    
    • for循环是一个依次重复执行的循环。通常适用于枚举或遍历序列,以及迭代对象中的元素。

    (二)执行情况

    在这里插入图片描述

    • 迭代变量用于保存读取出的值;对象为要遍历或迭代的对象,该对象可以是任何有序的序列对象,如字符串、列表和元组等;循环体为一组被重复执行的语句。

    (三)案例演示

    任务1、采用for循环计算1 + 2 + 3 + …… + 100的值

    • 编写程序 - 采用for循环计算1 + 2 + 3 + …… + 100的值.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    课堂练习:采用for循环计算1 + 3 + 5 + …… + 99的值

    在这里插入图片描述

    任务2、采用for循环打印水仙花数

    • 编写程序 - 采用for循环打印水仙花数.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    任务3、采用for循环破解令狐大侠难题

    • 编写程序 - 采用for循环破解令狐大侠难题.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 思考题:令狐大侠喝酒杯数只有一种结果吗?
      在这里插入图片描述
    • 思考题:这个程序无论如何都要循环99次,有必要吗?其实,当找到满足条件的cups值,就应该终止循环,不必再浪费资源继续循环了。此时,就会用到循环的跳转语句。

    任务4:采用for循环遍历序列

    • 编写程序 - 采用for循环遍历序列.py
      在这里插入图片描述

    • 运行程序,查看结果
      在这里插入图片描述

    四、跳转语句

    (一)跳转概述

    当循环条件一直满足时,程序将会一直执行下去。如果希望在中间离开循环,也就是for循环结束重复之前,或者while循环找到结束条件之前。

    • 使用continue语句直奔下次循环
    • 使用break语句完全中止整个循环

    (二)break语句

    1、在while循环中使用break语句

    • 语法格式
    while 条件表达式1:
    	执行代码
    	if 条件表达式2:
    		break
    
    • 执行情况
      在这里插入图片描述

    2、在for循环中使用break语句

    • 语法格式
    for 迭代变量 in 对象:
    	if 条件表达式:
    		break
    
    • 执行情况
      在这里插入图片描述

    3、案例演示

    任务1、采用for循环破解令狐大侠难题 - 完善版

    • 编写程序 - 采用for循环破解令狐大侠难题 - 完善版.py
      在这里插入图片描述
    • 运行程序,查看程序
      在这里插入图片描述
    • 修改程序,计算循环次数
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 修改【采用for循环破解令狐大侠难题.py】
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    任务2、判断一个整数是否是素数

    • 概念:什么叫素数(Prime Number)?一个整数除了1和它本身之外没有其它因子,这个整数就叫素数,否则就叫合数,但是有一个特殊情况,1既不是素数,也不是合数。比如:2、3、5、7都是素数,它们除了1和本身都没有其它因子,但是6就是合数,除了1和6之外,还有2和3都是其因子(6 = 2 * 3)。

    • 方法:判断一个整数是不是素数的方法 - 比如我们考虑一个整数 n ( n ≥ 2 ) n(n\ge2) nn2,就要看从 2 2 2 n − 1 n-1 n1的每个数能否整除 n n n,如果能整除,那么 n n n就不是素数;如果从头到尾都不能整除,那么 n n n就是素数。

    • 编程思路:我们采用一个布尔型的标志变量is_prime_number来表示待判断的整数n是不是素数,如果is_prime_number = True表明是素数,如果is_prime_number = False表明不是素数。先假定待判断的整数n是素数,设置is_prime_number = True,一旦在循环里找到能整除n的真因子,说明n不是素数,立马设置is_prime_number = False,并跳出循环结果。循环之后就根据is_prime_number的真假来输出n是素数还是合数。(这个编程思路,有点类似于法院断案,先假定你是好人,只有找到犯罪证据,才能断定你是罪犯。)

    • 编写程序 - 判断一个整数是否是素数.py
      在这里插入图片描述

    • 运行程序,查看结果
      在这里插入图片描述

    • 其实该程序可以优化的,为了说明方便起见,我们考虑 n = 100 n = 100 n=100的情况:

    2 * 50 = 100
    4 * 25 = 100
    5 * 20 = 100
    10 * 10 = 100
    20 * 5 = 100
    25 * 4 = 100
    50 * 2 = 100
    
    • 因子乘积是以100的平方根10的乘积(10 * 10)为中心对称的。于是循环范围就可以缩小,本来是从 2 2 2 99 99 99,现在可以缩小到从 2 2 2 100 \sqrt{100} 100

    • 根据刚才的分析,代码可以优化如下:
      在这里插入图片描述

    • 循环次数明显减少,因此这是一个更好的算法。

    • 运行程序,查看结果
      在这里插入图片描述

    思考题:实现合数分解

    • 如果一个整数是合数,编程将其分解成素数乘积形式
    • 比如 45 = 3 × 3 × 5 , 24 = 2 × 2 × 2 × 3 … … 45=3×3×5,24=2\times2\times2\times3…… 45=3×3×524=2×2×2×3

    (三)continue语句

    1、在while循环中使用continue语句

    • 语法格式
    while 条件表达式1:
    	执行代码
    	if 条件表达式2:
    		continue
    	执行代码
    
    • 执行情况
      在这里插入图片描述
    • 如果条件表达式2为True,跳过continue之后的执行代码部分,直奔下一次循环
    • 如果条件表达式2为False,执行continue之后的执行代码部分,才进入下一次循环

    2、在for循环中使用continue语句

    • 语法格式
    for 迭代变量 in 对象:
        执行代码
    	if 条件表达式:
    		continue
    	执行代码
    
    • 执行情况
      在这里插入图片描述
    • 如果条件表达式为True,跳过continue之后的执行代码部分,直奔下一次循环
    • 如果条件表达式为False,执行continue之后的执行代码部分,才进入下一次循环

    3、案例演示

    任务1、计算1 + 3 + 5 + …… + 99的值

    • 之前我们已经使用for循环来完成过这个计算任务,步长是2
      在这里插入图片描述
    • 现在我们换种方式来处理,步长依然是1,在循环里嵌套一个选择结构,通过使用continue语句过滤掉偶数,然后累加的就是全部奇数。
    • 修改程序 - 计算1 + 3 + 5 + …… + 99的值.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    任务2、逢七拍腿员工拓展小游戏

    • 场景模拟:宜宾五粮液酒类销售有限公司对2020年度新入职员工进行拓展训练,其中开展的一项小游戏叫做“逢七拍腿游戏”。游戏规则是每个员工从1开始依次数数,当数到尾数是7的数或7的倍数时,则该员工不报出该数,而是拍一下腿。凡是出错的员工将会受到小惩罚——做10个俯卧撑。
    • 假设在一次游戏中,参加活动的员工循环报数,从1数到99,每个人都没有出错,即无人受到惩罚。现在编写程序,在本次游戏中,计算新员工一共要拍多少次腿。
    • 编写程序 - 逢七拍腿员工拓展小游戏.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 不使用continue,代码如下所示
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    五、循环嵌套

    (一)循环嵌套概述

    嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。注意必须是包含关系,不能出现交叉。while循环、for循环语句都可以进行循环嵌套,并且它们之间也可以互相嵌套。在实际开发时,最常用的是for循环嵌套。

    (二)循环嵌套类型

    1、for循环嵌套for循环

    for 迭代变量1 in 对象1:
    	for 迭代变量2 in 对象2:
    		循环体2
    	循环体1
    

    2、while循环嵌套while循环

    while 条件表达式1:
    	while 条件表达式2:
    		循环体2
    	循环体1
    

    3、for循环嵌套while循环

    for 迭代变量 in 对象:	
    	while 条件表达式:
    		循环体2
    	循环体1
    

    4、while循环嵌套for循环

    while 条件表达式1:
    	for 迭代变量 in 对象:
    		循环体2
    	循环体1
    

    (三)执行情况

    • 在双重循环嵌套中,外层循环每执行一轮,都要执行完内层循环中的整个循环,然后执行外层循环第二轮,接着再执行完内层循环中的整个循环,以此类推,直至外层循环的循环条件不成立,才会跳出整个嵌套循环。如果外循环有 m m m次,内循环有 n n n次,那么内循环里的操作会执行 m × n m\times n m×n次。
      在这里插入图片描述

    (四)循环嵌套案例演示

    任务1、打印规则的字符图形

    (1)打印字符矩形

    • 编写程序 - 打印字符矩形.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 修改内循环里的打印语句,设置end属性为空字符串
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 每次内循环完毕都要换行,需要添加一个空打印语句,注意要对齐第二个for
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    (2)打印字符平行四边形

    • 向右倾斜的平行四边形
      在这里插入图片描述
    • 向左倾斜的平行四边形
      在这里插入图片描述
    • 针对向右倾斜的平行四边形,我们来研究一下每行前导空格数与当前行数的关系,这对我们编写程序至关重要。假设总行数 row = 10,我们可以发现一个规律:第i行的前导空格数等于总行数减去当前行数,即 spaces = row - i = 10 - i。
    i = 1    spaces = 9      1 + 9 = 10
    i = 2    spaces = 8      2 + 8 = 10
    ……
    i = i    spaces = 10 - i  i + (10 - i) = 10
    ……
    i = 8    spaces = 2       8 + 2 = 10
    i = 9    spaces = 1       9 + 1 = 10
    i = 10   spaces = 0       10 + 0 = 10
    
    • 编写程序 - 打印字符平行四边形.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    课堂练习:打印字符直角三角形

    在这里插入图片描述

    挑战练习:打印字符实心钻石

    • 实心钻石,其实由一个正立的等腰三角形和一个倒立的等腰三角形组合而成,也就是一个菱形。
      在这里插入图片描述

    挑战练习:打印字符空心钻石

    在这里插入图片描述

    任务2、打印乘法九九表

    • 作为启蒙教材,我们都背过九九乘法表:一一得一、一二得二、……、九九八十一。而古代是从"九九八十一"开始,因此称"九九表"。九九表的使用,对于完成乘法是大有帮助的。齐桓公纳贤的故事说明,到公元前7世纪时,九九歌诀已不稀罕。也许有人认为这种成绩不值一提。但在古代埃及作乘法却要用倍乘的方式呢。举个例子说明:比如计算23×13,就需要从23开始,加倍得到23×2,23×4,23×8,然后注意到13=1+4+8,于是23+23×4+23×8加起来的结果就是23×13。通过对比,不难看出使用九九表的优越性了。
    • 编写程序 - 打印乘法九九表.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 注意,内循环 - for j in range(1, i + 1): 不是 for j in range(1, 10):
      在这里插入图片描述

    任务3、解决百钱买百鸡问题

    我国古代数学家张丘建在《算经》一书中曾提出过著名的“百钱买百鸡”问题,该问题叙述如下:鸡翁一,值钱五;鸡母一,值钱三;鸡雏三,值钱一;百钱买百鸡,则翁、母、雏各几何?

    翻译过来,意思是公鸡一个五块钱,母鸡一个三块钱,小鸡三个一块钱,现在要用一百块钱买一百只鸡,问公鸡、母鸡、小鸡各多少只?

    需要定义三个整型变量cock, hen, chick,分别代表公鸡、母鸡和小鸡的购买数量。
    有两方面的条件:关于钱的条件与关于鸡的条件

    • 钱的条件: c o c k × 5 + h e n × 3 + c h i c k 3 = 100 cock \times5+hen\times3+\displaystyle\frac{chick}{3}=100 cock×5+hen×3+3chick=100
    • 鸡的条件: c o c k + h e n + c h i c k = 100 cock+hen+chick=100 cock+hen+chick=100

    (1)采用三重循环求解百钱买百鸡问题

    cock:0 ~ 20
    hen:0 ~ 34
    chick:0 ~ 100
    
    • 编写程序 - 采用三重循环求解百钱买百鸡问题.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 验证四种购买方案是否正确
      – 方案1: 0 + 25 + 75 = 100 , 0 × 5 + 25 × 3 + 75 3 = 75 + 25 = 100 0+25+75=100, 0\times5+25\times3+\displaystyle\frac{75}{3}=75+25=100 0+25+75=100,0×5+25×3+375=75+25=100
      – 方案2: 4 + 18 + 78 = 100 , 4 × 5 + 18 × 3 + 78 3 = 20 + 54 + 26 = 100 4+18+78=100, 4\times5+18\times3+\displaystyle\frac{78}{3}=20+54+26=100 4+18+78=100,4×5+18×3+378=20+54+26=100
      – 方案3: 8 + 11 + 81 = 100 , 8 × 5 + 11 × 3 + 81 3 = 40 + 33 + 27 = 100 8+11+81=100, 8\times5+11\times3+\displaystyle\frac{81}{3}=40+33+27=100 8+11+81=100,8×5+11×3+381=40+33+27=100
      – 方案4: 12 + 4 + 84 = 100 , 12 × 5 + 4 × 3 + 84 3 = 60 + 12 + 28 = 100 12+4+84=100, 12\times5+4\times3+\displaystyle\frac{84}{3}=60+12+28=100 12+4+84=100,12×5+4×3+384=60+12+28=100
    • 采用三重循环固然可以解决百钱买百鸡问题,但是最内层循环里的基本操作次数 = 21 × 35 × 101 = 74 , 235 21\times 35 \times 101=74,235 21×35×101=74,235,时间复杂度就比较高了,我们应该优化解决问题的算法。下面,我们降维处理,采用双重循环来解决此问题。

    (2)采用双重循环求解百钱买百鸡问题

    • 知道公鸡与母鸡购买数量,那么就可确定小鸡购买数量:chick = 100 - cock - hen
    • 编写程序 - 采用双重循环求解百钱买百鸡问题.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述
    • 采用双重循环解决百钱买百鸡问题,内层循环里的基本操作次数 = 21 × 35 = 735 21\times 35=735 21×35=735,跟三重循环算法相比,时间复杂度就大大降低了,因此双重循环算法是一个更好的算法。

    课堂练习:数字构成

    • 有四个数字:1、2、3、4,能组成多少个互不相同且无重复的三位数?各是多少?
    • 编写程序 - 数字构成.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    六、pass语句

    (一)占位作用

    在Python中还有一个pass语句,表示空语句。它不做任何事情,—般起到占位作用。

    (二)案例演示

    • 在应用for循环输出1〜10之间(不包括10)的偶数时,在不是偶数时,应用pass语句占个位置,方便以后对不是偶数的数进行处理。
    • 编写程序 - 占位语句pass.py
      在这里插入图片描述
    • 运行程序,查看结果
      在这里插入图片描述

    七、课后作业

    任务1、完成猜数游戏

    • 游戏规则:程序产生一个[1, 100]之间的随机整数,用户输入整数进行猜测,如果猜对了,就会循环你是否要继续玩游戏;如果猜错了,程序会提示你是猜高了还是猜低了,然后让你继续输入整数进行猜测。
      在这里插入图片描述

    任务2、计算阶乘之和

    • 计算 1! + 2! + 3! + … + 10! 的值
      在这里插入图片描述

    任务3、用米粒填充国际象棋盘

    国际象棋盘中,第1 格放1 粒米,第2 格放2 粒米,第3格放4 粒米,第4 格放8 粒米,第5 格放16粒米,……问:64个格子总共可以放多少粒米?
    在这里插入图片描述
    在这里插入图片描述

    任务4、求20个学生的平均成绩

    • 要求每个学生成绩在[0, 100]范围内,输入不正确,提示用户重新输入,直到输入正确为止
      在这里插入图片描述
    展开全文
  • 循环链表(Circular Linked List)是一种首尾相接的链表,它与单链表的唯一区别在于对尾结点的处理;因为在单链表中尾结点的指针域NULL改为指向头结点就得到了单循环链表。单循环链表可以用头指针head或尾指针rear表示...

    循环链表(Circular Linked List)是一种首尾相接的链表,它与单链表的唯一区别在于对尾结点的处理;因为在单链表中尾结点的指针域NULL改为指向头结点就得到了单循环链表。单循环链表可以用头指针

    head或尾指针rear表示,用尾指针rear表示的单循环链表查找开始结点a1和尾结点an就很方便;查找时间都是O(1)。

    启动IDE



    我们基于VC++2012创建一个2的工程。


    我们来实现一个单循环链表

    头文件定义如下

    #if !defined(AFX_CIRLINKLIST_H__75DB9F35_938B_47C7_9429_ACE899159C82__INCLUDED_)
    #define AFX_CIRLINKLIST_H__75DB9F35_938B_47C7_9429_ACE899159C82__INCLUDED_
    
    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000
    
    #define LEN 20
    typedef int ElemType;
    //单循环链表中结点的类型
    typedef struct Lnode {
     ElemType data;   //值域
     Lnode* next;     //指针域
    }LNode;
    class cirlinklist
    {private:
    LNode *head;//指向表头的指针
    LNode *curr;//当前结点指针
    int count;// 单循环链表的结点个数
    public:
    	//构造函数
    	cirlinklist();
    	//析构函数
    	~cirlinklist(){delete head;}
    	//创建有序或无序的带头结点的单循环链表
    	LNode *CreateCLinkL(int,int,int mark=0);
    	//清空单循环链表
    	void ClearCList();
    	//求单循环链表长度
    	int CListSize();
    	//检查单循环链表是否为空
    	bool CListEmpty();
    	//返回指向第pos个结点的指针
    	LNode *Index(int pos);
    	//返回单循环链表中指定序号的结点值
    	ElemType GetElem(int pos);
    	//遍历单循环链表
    	LNode *TraverseCList();
    	//当前指针curr指向pos结点并返回curr
    	LNode *Reset(int pos=0);
    	//当前指针curr指向下一结点并返回
    	LNode *Next();
    	// 判单循环链表当前指针curr==head 否
    	bool EndOCList();
    	//判单循环链表当前指针curr->next是否到达表尾
    	bool EndCList();
    	//删除单循环链表当前指针curr->next所指结点并返回其值
    	ElemType DeleteNext();
    	//从单循环链表中查找元素
    	bool FindCList(ElemType& item);
    	//更新单循环链表中的给定元素
    	bool UpdateCList(const ElemType &item,ElemType &e);
    	//向链表中第pos个结点后插入域值为item的新结点
    	void InsertCList(const ElemType& item,int pos);
    	//从链表中删除第pos个结点并返回被删结点的data
    	ElemType DeleteCList(int pos);
    };
    
    
    #endif // !defined(AFX_CIRLINKLIST_H__75DB9F35_938B_47C7_9429_ACE899159C82__INCLUDED_)
    


    类的实现如下

    #include "stdafx.h"
    //单循环链表的实现
    
    #include"cirlinklist.h"
    //构造函数
    cirlinklist::cirlinklist()
    {head=new LNode;
     curr=NULL;
     head->next=head;
     count=0;
    }
    //创建有序或无序的带头结点的单循环链表
    LNode *cirlinklist::CreateCLinkL(int n,int m,int mark)
    {
    ElemType x,a[LEN];
     srand(m);
     for(int i=0;i<n;i++) a[i]=rand()%100;
     for(int i=0;i<n-1;i++)
      {int k=i;
       for(int j=i+1;j<n;j++)
        if(a[k]>a[j]) k=j;
       if(k!=i)
       {x=a[k];a[k]=a[i];a[i]=x;}}
     head=new LNode;
     head->next=curr=new LNode;
     for(int i=0;i<n;i++){
      if(mark==1) curr->data=a[i];//升序
      else
       if(mark==-1) curr->data=a[n-1-i];//降序
       else curr->data=rand()%100;//无序
      if(i<n-1){curr->next=new LNode;
       curr=curr->next;}
      count++;}
     curr->next=head;
     return head;
    }
    //清空单循环链表
    void cirlinklist::ClearCList()
    {LNode *cp,*np;
     cp=head->next;
     while(cp!=head)
     {np=cp->next;delete cp;cp=np;}
     head=NULL;
    }
    //求单循环链表长度
    int cirlinklist::CListSize()
    {LNode* p=head->next;
     int i=0;
     while(p!=head)
      {i++;p=p->next;}
     return i;
    }
    //检查单循环链表是否为空
    bool cirlinklist::CListEmpty()
    {return head->next==head;}
    //返回指向第pos个结点的指针
    LNode *cirlinklist::Index(int pos)
    {if(pos<1)
      {cerr<<"pos is out range!"<<endl;exit(1);}
     LNode* p=head->next;
     int i=0;
     while(p!=head)
      {i++;
       if(i==pos) break;
       p=p->next;}
     if(p!=head) return p;
     else {cerr<<"pos is out range!"<<endl;
      return NULL;}
    }
    //返回单循环链表中指定序号的结点值
    ElemType cirlinklist::GetElem(int pos)
    {if(pos<1)
     {cerr<<"pos is out range!"<<endl;exit(1);}
     LNode* p=head->next;
     int i=0;
     while(p!=head)
      {i++;
       if(i==pos) break;
       p=p->next;}
     if(p!=head) return p->data;
     else {cerr<<"pos is out range!"<<endl;
      return pos;}
    }
    //遍历单循环链表
    LNode *cirlinklist::TraverseCList()
    {LNode *p=head->next;
     while(p!=head)
      {cout<<setw(4)<<p->data;
       p=p->next;}
     cout<<endl;
     return head;
    }
    //当前指针curr指向pos结点并返回curr
    LNode *cirlinklist::Reset(int pos)
    {LNode* p=curr=head->next;
     int i=-1;
     while(p!=head)
      {i++;
       if(i==pos) break;
       p=p->next;curr=curr->next;}
     return curr;
    }
    //当前指针curr指向下一结点并返回
    LNode *cirlinklist::Next()
    {curr=curr->next;
     return curr; 
    }
    // 判单循环链表当前指针curr==head 否
    bool cirlinklist::EndOCList()
    {return curr==head;}
    //判单循环链表当前指针curr->next是否到达表尾
    bool cirlinklist::EndCList()
    {return curr->next==head;}
    //删除单循环链表当前指针curr->next所指结点并返回其值
    ElemType cirlinklist::DeleteNext()
    {LNode *p=curr->next;
     curr->next=p->next;
     ElemType data=p->data;
     delete p;
     count--;
     return data;
    }
    //从单循环链表中查找元素
    bool cirlinklist::FindCList(ElemType& item)
    {LNode* p=head->next;
     while(p!=head)
      if(p->data==item)
       {item=p->data;return true;}
      else p=p->next;
     return false;
    }
    //更新单循环链表中的给定元素
    bool cirlinklist::UpdateCList(const ElemType &item,ElemType &e)
    {LNode* p=head->next;
     while(p!=head)  //查找元素
      if(p->data==item) break;
      else p=p->next;
     if(p==head) return false;
     else {  //更新元素
      p->data=e;return true;}
    }
    //向链表中第pos个结点后插入域值为item的新结点
    void cirlinklist::InsertCList(const ElemType& item,int pos)
    {LNode *newP=new LNode;
     newP->data=item;
     LNode* p=head->next;
     int i=0;
     while(p!=head)
      {i++;
       if(i==pos) break;
       p=p->next;}
     newP->next=p->next;
     p->next=newP;count++;
    }
    //从链表中删除第pos个结点并返回被删结点的data
    ElemType cirlinklist::DeleteCList(int pos)
    {if(pos<1)
      {cerr<<"pos is out range!"<<endl;exit(1);}
     LNode *p=head->next;
     curr=head;
     ElemType data;
     int i=0;
     while(p!=head)
      {i++;
       if(i==pos) break;
       p=p->next;curr=curr->next;}
     if(p!=head)
      {data=p->data;curr->next=p->next;
       delete []p;count--;return data;}
     else return pos;  
    }
    

    我们来演练一下类的操作

    cout<<"运行结果:\n";
    int m=150,i,n=10,x,it;
    cirlinklist p,t,q,mylink;
    p.CreateCLinkL(n,m,1);
    if(p.CListEmpty()) cout<<"单循环链表p空!\n";
    else cout<<"单循环链表p非空!\n";
    cout<<"单循环链表p(升序):\n";
    p.TraverseCList();
    if(p.CListEmpty()) cout<<"单循环链表p空!\n";
    else cout<<"单循环链表p非空!\n";
    if(p.EndCList()) cout<<"单循环链表p满!\n";
    else cout<<"单循环链表p非满!\n";
    cout<<"单循环链表t(无序):\n";
    t.CreateCLinkL(n-2,m);
    t.TraverseCList();
    cout<<"单循环链表t的长度:"<<t.CListSize()<<endl;
    cout<<"单循环链表q(降序):\n";
    q.CreateCLinkL(n,m,-1);
    q.TraverseCList();
    cout<<"单循环链表q的长度:"<<q.CListSize()<<endl;
    cout<<"链表q的第1个元素:"<<q.GetElem(1)<<endl;
    cout<<"链表q的第1个元素地址:"<<q.Index(1)<<endl;
    cout<<"链表q的第5个元素:"<<q.GetElem(5)<<endl;
    cout<<"链表q的第5个元素地址:"<<q.Index(5)<<endl;
    cout<<"链表q的第10个元素:"<<q.GetElem(10)<<endl;
    cout<<"链表q的第10个元素地址:"<<q.Index(10)<<endl;
    cout<<"链表q的curr->next所指元素地址:"<<q.Next()<<endl;
    x=65;it=66;
    if(q.FindCList(x)) cout<<x<<"查找成功!\n";
    else cout<<x<<"查找不成功!\n";
    if(q.UpdateCList(x,it)) cout<<x<<"更新成功!\n";
    else cout<<x<<"更新不成功!\n";
    cout<<"更新后单循环链表q:\n";
    q.TraverseCList();
    cout<<"插入后单循环链表q:\n";
    it=100;q.InsertCList(it,1);
    q.TraverseCList();
    cout<<"插入后单循环链表q:\n";
    it=101;q.InsertCList(it,5);
    q.TraverseCList();
    cout<<"插入后单循环链表q:\n";
    it=102;q.InsertCList(it,12);
    q.TraverseCList();
    cout<<"插入后q表长:"<<q.CListSize()<<endl;
    cout<<"第1个数:"<<q.DeleteCList(1)<<"删除成功!\n";
    cout<<"删除后q表长:"<<q.CListSize()<<endl;
    q.TraverseCList();
    cout<<"第5个数:"<<q.DeleteCList(5)<<"删除成功!\n";
    cout<<"删除后q表长:"<<q.CListSize()<<endl;
    q.TraverseCList();
    cout<<"第11个数:"<<q.DeleteCList(11)<<"删除成功!\n";
    cout<<"删除后q表长:"<<q.CListSize()<<endl;
    q.TraverseCList();
    
     cin.get();







    来解决约瑟夫问题。

    据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从,Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏。
      17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了这样一个故事:15个教徒和15 个非教徒在深海上遇险,必须将一半的人投入海中,其余的人才能幸免于难,于是想了一个办法:30个人围成一圆圈,从第一个人开始依次报数,每数到第九个人就将他扔入大海,如此循环进行直到仅余15个人为止。问怎样排法,才能使每次投入大海的都是非教徒。

    代码实现如下,人数自定义,数量自己定义

    cout<<"约瑟夫(Josephus)问题\n";
    //求解约瑟夫(Josephus)问题
    cout<<"输入人数n:";cin>>n;
    cout<<"输入第次数m:";cin>>m;
    for(i=0;i<n;i++) mylink.InsertCList(i+1,i);
    cout<<"员工编号依次为:";
    LNode *w=mylink.Reset();
    while(!mylink.EndOCList())
    {
    cout<<setw(3)<<w->data;
    w=mylink.Next();}
    cout<<endl;
    cout<<"删除次序依次为:\n";
    mylink.Reset(-1);
    for(i=0;i<n-1;i++)
    {
    	for(int j=0;j<m-1;j++)
    {
    		w=mylink.Next();
    if(mylink.EndOCList())
    {
    	w=mylink.Next();
    }
    	}
    if(mylink.EndCList()) w=mylink.Next();
    cout<<"删除第"<<mylink.DeleteNext()<<"人\n";}
    cout<<"最后剩下的是:第"<<mylink.GetElem(1)<<"个人\n";
     cin.get();
     cin.get();





    代码下载地址


    http://download.csdn.net/detail/yincheng01/4785169


    展开全文
  • 循环链表解决约瑟夫问题

    千次阅读 2018-05-08 10:44:33
    约瑟夫问题: 据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成...

    约瑟夫问题:

    据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人。接着,再越过k-1个人,并杀掉第k个人。这个过程沿着圆圈一直进行,直到最终只剩下一个人留下,这个人就可以继续活着。问题是,给定了和,一开始要站在什么地方才能避免被处决?Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏。

    通俗的说一下规则:

    • 所有的人(包括你自己)围成一个圈并编号
    • 从第一个人开始顺时针报数,报到数字k的人被杀掉并移除圈
    • 从被杀死的下一个人继续报数,报到数字k的人再被杀掉并移除
    • 直到剩下最后一个人

    这个问题的解决方法有很多种,可以用递归,用数学推导,用数组完成,下面介绍一种用链表模拟的方法解决这个问题。

    提供两段实现的代码供参考:

    第一段代码:

    ///在一个主函数中实现
    #include<stdio.h>
    #include<malloc.h>
    
    typedef struct List
    {
        int  data;
        struct List *next;
    }LinkList;
    
    
    int main()
    {
        LinkList *L,*r,*s;
        L = (LinkList *)malloc(sizeof(LinkList));
        r =L;
        int n,i;
        int k;
        printf("Please input the number of people:\n");
        scanf("%d",&n);
        printf("The number to count each round:\n");
        scanf("%d",&k);
    
        for(i = 1;i<=n;i++)               ///尾插法建立循环链表
        {
            s = (LinkList *)malloc(sizeof(LinkList));
            s->data = i;
            r->next = s;
            r= s;
        }
        r->next =L->next;                  //让最后一个链表的下一个节点指向开头
        
    	
        LinkList *p,*q;
        p = L->next;
    
        while(p->next != p)                            //开始模拟(判断条件要注意:因为最后肯定剩下一个人, 所以最后一个数据的next还是他本身)
        {
            for(i = 1;i<k-1;i++)
            {
                p = p->next;                         //从第一个人开始数k-2次
            }
            q = p->next;
            p->next = p->next->next;    //将该节点从链表上删除,第k个人死去
            free(q);
            p = p->next;                  //p指针指向死去的下一个人
        }
        printf("The last one :%d",p->data);
        return 0;
    }
    

    结果展示:

    第二段代码:

    ///用函数实现
    #include <stdio.h>
    #include <malloc.h>
    #define LEN sizeof (LinkList)  //定义struct List这个类型的长度
    
    typedef struct List  //定义结构体
    {
        int num;
        struct List *next;
    }LinkList;
    
    LinkList *create(int m)  //创建循环链表
    {
        LinkList *head,*p1,*p2;
        int i;
        head=p1=(LinkList*)malloc(LEN);
        head->num=1;
        for(i=1,p1->num=1;i<m;i++)
        {
            p2=(LinkList*)malloc(LEN);
            p2->num=i+1;
            p1->next=p2;
            p1=p2;
        }
        p2->next=head;
        return head;
    }
    
    LinkList *findout(LinkList *start,int n)  //找到需要删除结点的前一个结点
    {
        int i;
        LinkList *p;
        p=start;
        for(i=1;i<n-1;i++)
        p=p->next;
        return p;
    }
    
    LinkList *letout(LinkList *last)  //删除下一个结点并返回下下个结点
    {
        LinkList *out,*next;
        out=last->next;
        last->next=out->next;
        next=out->next;
        printf("%d-->",out->num);    //打印死亡顺序
        free(out);
        return next;
    }
    
    int main()
    {
        int m,n,i,king;
        LinkList *p;
        printf("Please input the number of people:\n");
        scanf("%d",&m);
        printf("The number to count each round:\n");
        scanf("%d",&n);
        if(n==1)
        {
            king=m;
        }
        else
        {
            p=create(m);
            for(i=1;i<m;i++)
            {
                p=findout(p,n);
                p=letout(p);
            }
            king=p->num;
            free(p);
        }
        printf("\n");
        printf("The last one is:%d\n",king);
        return 0;
    }
    

    结果展示:

     ===============================================================

    约瑟夫问题的另一种解法:参考 约瑟夫环问题的两种解法(详解):https://blog.csdn.net/okasy/article/details/79503398

    递归实现:参考 https://www.cnblogs.com/Bravewtz/p/10089717.html

    循环链表实现C++代码:

    #include<iostream>
     
    using namespace std;
     
    /************约瑟夫问题****************/
     
    typedef struct CLinkList
    {
        int data;
        struct CLinkList *next;
    }node;
     
     
    int main()
    {
    ///建立循环链表
        node *L,*r,*s;
        L = new node;
        r =L;
        int n = 41,i;
        int k = 3;
        for(i = 1;i<=n;i++)       //尾插法建立链表
        {
            s = new node;
            s->data = i;
            r->next = s;
            r= s;
        }
        r->next =L->next;       //让最后一个结点指向第一个有数据结点
        node *p;
        p = L->next;
        delete L;   //删除第一个空的结点
     
    ///模拟解决约瑟夫问题
        while(p->next != p)                            //判断条件:因为最后肯定剩下一个人, 循环链表的最后一个数据的next还是他本身
        {
            for(i = 1;i<k-1;i++)
            {
                p = p->next;                         //每k个数死一个人
            }
            cout<<p->next->data<<"->";
            p->next = p->next->next;                   //将该节点从链表上删除。
            p = p->next;
        }
        cout<<p->data<<endl;
        return 0;
    }

    运行结果:

     


    附上华为2016研发工程师编程题

    这道题就是一个约瑟夫问题。

    #include <iostream>
    
    using namespace std;
    
    typedef struct CLinList
    {
    	int data;
    	struct CLinList *next;
    }node, *Pnode;
    
    int main()
    {
    	int n;
    	while (cin >> n)
    	{
    		Pnode L, r, s;
    		L = new node;
    		r = L;
    		int i;
    		int k = 3;
    		for (i = 0; i < n; i++)
    		{
    			s = new node;
    			s->data = i;
    			r->next = s;
    			r = s;
    		}
    		r->next = L->next;
    		Pnode P;
    		P = L->next;
    		delete L;
    
    		while (P->next != P)
    		{
    			for (i = 1; i < k - 1; i++)
    			{
    				P = P->next;
    			}
    			//cout << P->next->data << "->";
    			P->next = P->next->next;
    			P = P->next;
    		}
    		cout << P->data << endl;
    		
    	}
    	
    	return 0;
    }

     

    展开全文
  • 章节导学第5章 循环结构

    千次阅读 2012-09-12 12:05:52
    循环是利用计算机解决问题的终极武器,编程实际上就是编写“循环结构”,但是,“循环”来自于“模拟”!首先,程序员必须利用“重复”解决问题;然后,再把“重复”模拟成“循环”。一方面,程序不会“自己”解决...

    日升日落,日复一日,重复是这个世界永恒的主题。现实世界中的许多问题都可以通过“重复”来解决,而C语言中的“循环结构”被用来模拟这一过程中的“重复”。循环是利用计算机解决问题的终极武器,编程实际上就是编写“循环结构”,但是,“循环”来自于“模拟”!首先,程序员必须利用“重复”解决问题;然后,再把“重复”模拟成“循环”。一方面,程序不会“自己”解决问题,它只是程序员解决问题时所用方法的模拟,因此,编程就是“模拟”。另一方面,程序只会“循环”,这就决定了程序员在解决问题时只能考虑利用“重复”来解决问题,因此,“模拟”主要是指用“循环”模拟“重复”。

    循环是迭代,是条件满足时的重复。循环是“波浪式前进,螺旋式上升”,并非简单的重复。只有准确无误地找出了问题解决过程中“什么在重复和怎样重复”,才能正确地构造出循环结构。

    复杂问题的解决还需注意思维的层次性,常用“自顶向下,逐步求精”的方法。“自顶向下”要求从宏观上分析问题忽略细节把握问题的本质;“逐步求精”要求从局部着力从细节入手,分析“原始数据”找到“规律”。只有“自顶向下”和“逐步求精”紧密配合,相得益彰,才能顺利地解决复杂的问题。
    展开全文
  • C++循环结构

    千次阅读 2018-12-08 22:16:14
    一、循环体部分知识点整理 1.for循环 for(表达式1;表达式2;表达式3) { break; //用于跳出当前循环体,结束循环。 continue; //跳过当前循环体continue后面的代码,继续执行下一个循环 return 0; ...
  • 面向过程编程结构编程

    千次阅读 2018-11-28 09:38:54
    也是一种解决问题的思想和方法。它采用子程序、程式码区块 (英语:block structures)、for循环以及while循环结构,来取代传统的 goto。希望借此来改善计算机程序的明晰性、品质以及开发时 间,并且避免写出面条式...
  • C语言之三中循环结构与递归函数的对比 使用循环可以多次执行多条语句(称为循环体语句).在C语言中,有三种循环结构,分别是: while,do-while,for;以及一种有循环作用的函数:递归函数. 所有的循环都可以扩展为具有四种...
  • C语言中常用的编程结构有三种,算法的三种基本结构是顺序结构,分支结构,循环结构。 顺序结构:代码从前往后依次执行,没有任何“拐弯抹角”,不跳过任何一条语句,所有的语句都会被执行到。 选择结构:也叫分支...
  • 当Python程序陷入死循环时有两种解决方案: 方案一:使用Ctrl+C快捷键的方式退出程序 方案二:强制结束Python程序
  • 为了和用户交互,程序设计时经常要捕获用户的行为来触发相应的事件,一般采用的是在循环中嵌入事件结构如下图所示,发现(1)如果一直 没有触发事件,则无法停止循环?(2)按下停止按钮后,在运行完当次循环后还会...
  • 汇编-循环编程

    千次阅读 2017-05-02 00:20:00
    这次老师布置了三个题,都是关于循环编程的,大致写一下实验报告吧。实验一有一个字数组a,编程将其复制到b数据区。这个问题按我想,最快最便捷的方法是按字节硬拷贝一段内存覆盖另一段内存。然而这里让用循环编程,...
  • Java入门 - 循环结构基础

    千次阅读 2021-01-14 11:30:44
    第1关:Java循环结构之while循环 任务描述 本小节需要你完成一个做俯卧撑的小程序,效果如下: 相关知识 Java中常用的循环有三种:while,do…while,for。 本小节我们先来看看while循环。 while循环的特点 循环...
  • 重复执行——循环结构

    千次阅读 2019-12-02 22:57:02
    一、循环语句 1、while语句 (1)格式 while(表达式){ 循环体 ...先计算表达式的值,当...此语句是C++中用于解决至少执行一次重复操作(循环体)的循环语句。 (1)格式 do{ 循环体 }while(表达式); (2)...
  • C语言作业2-循环结构程序设计-1利用三种循环求阶乘累加和 问题描述: 利用while , do while, 和for循环分别编写求 ∑ n! (即1!+2!+3!+…+25!)的程序 代码实现: #include&lt;stdio.h&gt; #include&lt;...
  • MPIOpenMP混合编程解决N-Body问题 实验4

    千次阅读 2016-10-25 21:22:23
    MPIOpenMP混合编程解决N-Body问题 实验4 华南理工大学 高性能云计算 随着国民经济、国防建设和高科技的快速发展,越来愈多的领域对高性能计算有强烈的需求,包括原子能、航空、航天、激光、气象、石油、海洋、天文、...
  • Shell的四种循环结构

    千次阅读 2020-09-05 10:04:37
    1.1.Shell循环-----for 语法结构:for 变量名 [ in 取值列表 ] do 循环体 done 示例如下: ...2.Shell循环----while 循环次数不是... 一、while语句结构(死循环/逐行处理文件) while 条件测试 do 循环体 ...
  • matlab 循环结构设计习题

    千次阅读 2014-04-13 19:46:46
    考虑以下迭代公式: ,其中a、b为正的常数。... 这样就解决了我的疑问,利用数组,当序号在改变的同时,相应的,序号所对应的值根据迭代公式的计算也在不停的变化。完成了一一对应。  
  • 九、Python编程解决组合问题(之一) ----From a high school student's view to learn Python 关键字: python 组合问题 编程 递归 函数 元组 堆栈 列表 combination function recursive tuple list stack ...
  • 九、Python编程解决组合问题(之二) ----From a high school student's view to learn Python   关键字: python 组合问题 编程 递归 函数 元组 堆栈 列表 combination function recursive tuple list stack...
  • 阶乘计算 输入一个正整数n,计算n的阶乘。 求和 计算1 - 1/3 + 1/5 - 1/7+.......... 判断是否为素数 判断一个正整n是否为素数。 打印九九乘法表 九九乘法表相信大家都不陌生吧!利用循环打印出一个九九乘法表。
  • C++ 多线程编程解决CPU占用率高问题

    千次阅读 2014-06-30 23:11:40
    在用C++进行多线程编程的时候,时常需要写一些类似于死循环结构来执行代码,这些死循环如果没有经过处理一直开着,那么CPU的占用率就会居高不下的做着很多无用的操做。为解决这个问题我们可以通过在各线程中的适当...
  • JavaWeb 并发编程 与 高并发解决方案

    万次阅读 多人点赞 2018-09-12 03:41:00
    现在在各大互联网公司中,随着日益增长的互联网服务需求,高并发处理已经是一个非常常见的问题,在这篇文章里面我们重点讨论两个方面的问题,一是并发编程,二是高并发解决方案。   文章中的代码实现详见   ...
  • 第1关:Java循环结构之while循环 1、编程要求: 在start-end区域中填充代码,使程序能输出如下效果: 3、程序设计思路: (1)要使用while循环,需要知道while循环是没有步进语句的,需要自己添加来使变量值可以增加...
  • 循环控制结构

    千次阅读 2014-07-16 19:07:42
    2.结构化程序设计的三种基本结构:顺序结构、选择结构、循环结构 3.循环结构的类型:  1)当型循环结构:for语句(适合循环次数已知,计数控制的循环)  2)直到型循环结构:while语句、do-while语句(适合循环次数...
  • 鑫软Python经典案例分析---循环结构与判断结构问题引入关于判断与循环问题求解(流程图演示)问题解决方式解决代码BMI值计算问题4.1猜数游戏实现代码:4.2统计不同字符个数。4.3最大公约数计算4.4猜数游戏续。4.5...
  • 课程首页在:http://blog.csdn.net/sxhelijian/article/details/11890759【项目1:利用循环... 【项目2-分数的累加】编程序,输出1/3-3/5+5/7-7/9…+19/21的结果提示:如果直接解决上面的问题有困难,可以设计一条
  • ---------------------- Windows Phone 7手机开发、.Net培训、期待与您交流!...b) 使用if结构可以实现上面的问题 c) 法if结构的基本语法 d) if(条件) 语句; if(条件) {语句1; 语句2
  • Step7编程语言&编程概述&结构

    千次阅读 2020-06-05 17:45:54
    Step7编程语言与编程概述&结构
  • 9. C 语言 -- 循环结构:while语句和 do … while语句

    千次阅读 多人点赞 2018-10-19 19:17:45
    本文主要讲述 C 语言循环结构中的 while 和 do while 语句,并且介绍了 scanf, getchar 和 gets三种输入的使用方法及使用情况。
  • (1)清晰的陈述你所解决问题 (2)明确程序的输入与输出及所需的变量 (3)设计解决问题所需的算法 (4)将算法转化成matlab代码 (5)测试代码与调试bug 2.选择结构 (1)~=表示不等于 判断一个数近似于零:如...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,050
精华内容 83,220
关键字:

编程循环结构解决哪些问题