C补习-----＞第四天，循环、break与continue、数组（一维：整形&字符）、冒泡排序、字符串处理相关的函数

本文链接：https://blog.csdn.net/vznsjsbsjjs/article/details/119841790

1,循环
2,break,continue
3,数组（一维：整形 & 字符）
4,冒泡排序
5,字符串处理相关的函数

----------------------------------------------------------------

循环：三大循环---》for while do_while

当需要重复做某件事情时，需要通过循环来做！

（1）for :
格式：
for（表达式1;表达式2;表达式3）
{
循环体//代码的实现过程
}

分析：
表达式1:赋初值，可以省略（基于己经被初始化过了），但是;不可以省略
表达式2:条件判断，不建议省略，（省略之后就会陷入死循环）
表达式3：条件更新，可以省略（放在循环体的内部，一般是最后一句话），但是;不可以省略

执行流程：
先执行表达式1，在执行表达式2，如果表达式2成立，则进入循环体执行循环体中的内容，再去执行表达式3
再次判断表达式2是否成立，成立则继续，否则终止循环。

#include <stdio.h>

int main(int argc, const char *argv[])
{
   //实现1-100之间的累加和
   //定义一个用于循环的变量
   int i;
   //定义一个存放累加和的变量
   int sum = 0;
   //书写for循环
   for(i = 1;i<=100;i++)
   {
       //代码的实现过程
       //sum = sum + i;
       sum += i;
   }

   printf("1-100之间的累加和为: %d\n",sum);
   return 0;
}
（2）while
格式：
while（条件判断）
{
循环体;

条件更新！
}

注意：while循环必须先赋初值方可使用

执行流程：
先进行条件判断，当成立时，进入循环体，执行循环体之后再进行条件更新，再次判断如果成立则继续，否则终止循环。

#include <stdio.h>

int main(int argc, const char *argv[])
{
   //利用while实现1-100之间偶数的累加
   //定义一个循环变量
   int i = 1;
   //定义一个存放偶数和的变量
   int sum = 0;
   while(i<=100)
   {
       //判断i是否为偶数
       if(0 == i%2)
       {
           sum += i;
       }
       //条件更新
       i++;
   }
   printf("1-100之间的偶数的累加和为: %d\n",sum);
   return 0;
}
（3）do_while
格式：
do
{
循环体

条件判断!!!
}while(条件判断);

执行流程：
先进入循环体，执行一边循环体的内容，并且进行条件更新，再进行while判断，如果成立则再次进入循环体，否则终止循环。

#include <stdio.h>

int main(int argc, const char *argv[])
{
   //利用do_while实现累加和
   int i = 1;
   int sum = 0;
   do
   {
       if(0 != i%2)
       {
           sum += i;
       }

       i++;
   }while(i<=100);

   printf("sum = %d\n",sum);

   return 0;
}
思考：
for和while的区别：
for针对的循环次数已经，while针对循环次数未知

while和do_while的区别：
while至少被执行0次
do_while至少被执行1次

-------------------------------------------------------------------------------------------------------------------------------

break:结束本层循环
continue:结束本次循环（本次循环中剩余的语句块不再被执行），继续进入下一次循环。
#include <stdio.h>

int main(int argc, const char *argv[])
{
   int i;
   for(i=0;i<10;i++)
   {
       if(i > 5)
       {
           printf("****i = %d\n",i);
           int a = 1;
           a++;
           printf("a = %d\n",a);
           continue;
//break;
           printf("hahahah!\n");
           printf("xixixixi!\n");
       }
       printf("i = %d\n",i);
   }

   printf("hhhhhhhhhhhhhhhhhhhhhhhhhhhh!\n");

   return 0;
}

书写死循环的方式：
while(1)
{
//循环体
}

for(;1;)
{
//循环体
}

------------------------------------------------------------------------------------------------------------------------------
练习：
1，有一个数字，加上100之后是一个完全平方数，再加上168之后还是一个完全平方数，求该数是谁（10000之内去查）
完全平方数：121 == 11 * 11 -----》开根：sqrt(数字)---> #include<math.h> ---->编译时需要在末尾添加 -lm 的选项

1 #include <stdio.h>
2 #include <math.h>
3
4 int main(int argc, const char *argv[])
5 {
6 //求完全平方数（1-10000）
7 //该数加上100之后，以及加上168均是完全平方数
8 int i;
9 int x,y;
10 for(i=1;i<=10000;i++)
11 {
12 x = sqrt(i+100);
13 y = sqrt(i+268);
14 if((x * x == i+100) && (y * y == i+268))
15 {
16 printf("%d是完全平方数!\n",i);
17 }
18 }
19 return 0;
20 }
--------------------------------------------------------------------------------------------------------------------------

数组：数据元素类型相同的一个集合

数组的特点：
（1）数据类型相同
（2）内存连续

一维整形数组：

定义一个数组？

定义普通变量？
存储类型数据类型变量名;
格式：
存储类型数据类型数组名[元素个数];
分析：
存储类型：数组中元素的存储位置，默认在栈区开辟空间（被auto修饰）
数据类型：数组中每一个元素的类型
数组名：当前该片连续空间的名称,见名知义
元素个数：当前数组中的元素总个数，注意该个数不能写变量。
一般该元素个数用常量代替（宏常量居多）

思考：
定义一个可以存放5个int类型元素的数组出来？
----》
int arr[5]; //在栈区开辟一片含有sizeof(int) * 5个字节的空间给你去使用
如何访问数组中每一个元素？
----》通过数组名[下标] 注意：下标从0开始

#include <stdio.h>

#define N 5

//int brr[5];

int main(int argc, const char *argv[])
{
   //定义一个含有5个整形元素的空间
   int arr[N];//初始化
   //赋值
   //arr[N] = {1,2,3,4,5};错误的
   int i;
   printf("please input arrvalues:\n");
   for(i=0;i<N;i++)
   {
       scanf("%d",&arr[i]);
   }
   //访问数组成员的方式--->arr[下标]
   /*
   printf("%d\n",arr[0]);
   printf("%d\n",arr[1]);
   printf("%d\n",arr[2]);
   printf("%d\n",arr[3]);
   printf("%d\n",arr[4]);
   */
   printf("output is:\n");
   for(i=0;i<N;i++)
   {
       printf("%d ",arr[i]);
   }
   //输出一个换行符
   //printf("\n");
   putchar('\n');
   return 0;
}
总结：
（1）当数组在{}之内定义时，意味着是一个局部数组，当不赋值时，其值为随机值
（2）当数组在{}之外定义时，意味着是一个全局数组，当不赋值时，其值为0
（3）当数组满初始化时，元素会原样输出
（4）当数组部分初始化时，剩余未被赋值的元素默认补0
（5）可以利用（4）点的特性，实现清空一个数组：int arr[5] = {0};
（6）对于整形数组而言：一般通过循环完成元素的赋值以及输出

---------------------------------------------------------------------------------------------

冒泡排序：

做法：从左到右，两两依次进行比较。如果按照升序来排，当左边比右边大时，需要进行交换位置
每一趟执行完之后，可以选出一个最大的数，但是剩余的数的关系不能保证，需要重复以上动作，直到剩余一个人

int arr[5] = {90,23,67,12,82};
--->目的：按照升序进行排列
思想：冒泡排序
原始数据：90,23,67,12,82

第一趟：23,67,12,82,90
第一次：23,90,67,12,82
第二次：23,67,90,12,82
第三次：23,67,12,90,82
第四次：23,67,12,82,90

第二趟：23,12,67,82,90
第一次：23,67,12,82,90
第二次：23,12,67,82,90
第三次：23,12,67,82,90
第三趟：12,23,67,82,90
第一次：12,23,67,82,90
第二次：12,23,67,82,90
第四趟：
第一次：12,23,67,82,90

第一趟：
伪代码：
for(i=0;i<5-1-0;i++)
{
if(arr[i] > arr[i+1])
{
//交换----？借助于一个中间变量
int Temp;
Temp = arr[i];
arr[i] = arr[i+1];
arr[i] = Temp;
}
}

第二趟：
for(i=0;i<5-1-1;i++)
{
if(arr[i] > arr[i+1])
{
//交换----？借助于一个中间变量
int Temp;
Temp = arr[i];
arr[i] = arr[i+1];
arr[i] = Temp;
}
}

第三趟：
for(i=0;i<5-1-2;i++)
{
if(arr[i] > arr[i+1])
{
//交换----？借助于一个中间变量
int Temp;
Temp = arr[i];
arr[i] = arr[i+1];
arr[i] = Temp;
}
}

第四趟：
for(i=0;i<5-1-3;i++)
{
if(arr[i] > arr[i+1])
{
//交换----？借助于一个中间变量
int Temp;
Temp = arr[i];
arr[i] = arr[i+1];
arr[i] = Temp;
}
}

对以上代码进行整合：
//定义一个变量，用来控制趟数
for(i=0;i<5-1;i++)
{
//用来控制每一趟中需要交换的次数
for(j=0;j<5-1-i;j++)
{
if(arr[j] > arr[j+1])
{
int Temp;
Temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = Temp;
}
}
}

#include <stdio.h>

#define N 5
int main(int argc, const char *argv[])
{
   //实现5个元素的排序
   int arr[N] = {0};
   int i,j;
   printf("请输入数组元素的值:\n");
   for(i=0;i<N;i++)
   {
       scanf("%d",&arr[i]);
   }

   printf("排序之前的结果为:\n");
   for(i=0;i<N;i++)
   {
       printf("%d ",arr[i]);
   }
   printf("\n");

   printf("冒泡中.....\n");
   //第一个循环用来控制趟数
   for(i=0;i<N-1;i++)
   {
       //第二个for循环用来控制每一趟中需要交换的次数
       for(j=0;j<N-1-i;j++)
       {
           //判断
           if(arr[j] < arr[j+1])
           {
               int Temp;
               Temp = arr[j];
               arr[j] = arr[j+1];
               arr[j+1] = Temp;
           }
       }
   }
   printf("排序之后的结果为:\n");
   for(i=0;i<N;i++)
   {
       printf("%d ",arr[i]);
   }
   printf("\n");
   return 0;
}

-------------------------------------------------------------------------------------------

一维字符数组：
思考：
定义一个可以存放20个字符的一维字符数组？
----》char str[20];
char str[20] = {'h','e','l','l','o'}; //在栈区开辟了20个字节的空间
char str[20] = {"hello"};
char str[20] = "hello";

char str[20] = {'\0'};
char str[20] = {0};

注意：一维字符数组的本质：---》就是一个字符串

字符串特性函数（只能针对字符串）
gets();
函数原型：
char *gets(char *s);
三步走：
功能：从键盘获得一个字符串
参数：数组名
返回值：首地址（成功之后的字符串）

简易版：
#include <stdio.h>
gets(数组名);

puts();
函数原型：
int puts(const char *s);
简易版：
puts(数组名);

总结：
(1)对于scanf和gets:
scanf：遇到空格，回车，Tab减均代表输入结束
gets:只有遇到回车才代表输入结束

(2)对于printf和puts:
printf:不会添加换行符，需要手动添加'\n'
puts:自动换行

(3)gets是一个非常危险的函数：因为gets没有越界检查的功能，它的获取没有上限，需要注意。

(4)注意：字符串一般都会有一个结束标志：'\0'
如果一个字符串中没有'\0',那么在打印出会无限打印，只有遇到'\0'才会终止打印
故：需要给'\0'留一个字节的空间出来。eg: char str[5] = {'\0'};
此时最对可以输入4个有效字符

(5)一维数组的元素个数可以省略的，当省略之后，则会按照所赋值的元素个数为准来判断当前被省略的数字是多少。

(6)赋值时，直接以"wangjia"这个形式赋值时，默认是自带'\0'这个结束标志
eg:
char str[] = {"wangjia"} --->sizeof(str) = 8 //OK
char str[] = {'w','a','n,'g','j','i','a'};---->sizeof(str) = 7 //不可取

#include <stdio.h>
#include <string.h>

#define N 10
int main(int argc, const char *argv[])
{
   //定义一个可以存放20个字符的数组
   //char str[] = "hello world";
   char str[] = {'h','e','l','l','o','\0'};
   printf("sizeof(str) = %d\n",sizeof(str));
   printf("strlen(str) = %d\n",strlen(str));
   printf("&str[0] = %p\n",&str[0]);
   printf("str = %p\n",str);

   printf("请输入:\n");
   //scanf("%s",&str[0]);
   //scanf("%s",str);
   //gets(str);
   printf("输出为:\n");
   //printf("%s\n",&str[0]);
   printf("%s\n",str);
   //puts(str);
   return 0;
}

--------------------------------------------------------------------------------------------------------
作业：

一，输入年月日，判断这一天是这一年的第几天？（考虑闰年）

#include<stdio.h>
//输入年月日，判断这一天是这一年的第几天（考虑闰年）

int main(int argc, const char *argv[])
{
   int year,month,day; //定义年月日
   int plus,plus1; //定义plus为计算当月天数， plus1为计算总天数
   printf("请输入年月日:\n");
   scanf("%d%d%d",&year,&month,&day);

   switch(month) //由月份计算出前十一个月的天数
   {
   case 1 : plus = 0;
           break;
   case 2 : plus = 31;
           break;
   case 3 : plus = 59;
           break;
   case 4 : plus = 90;
           break;
   case 5 : plus = 120;
           break;
   case 6 : plus = 151;
           break;
   case 7 : plus = 181;
           break;
   case 8 : plus = 212;
           break;
   case 9 : plus = 243;
           break;
   case 10 : plus= 273;
           break;
   case 11 : plus= 304;
           break;
   case 12 : plus= 334;
           break;
   default :
           printf("月份输入错误，请重新输入！！！\n");
           return -1;
   }
   plus1 = plus + day;   //计算总天数
   if(year % 4 == 0 && year % 100 != 0) //除四判断是否闰年，闰年总天数加一
   {
       plus1 = plus1 + 1;
   }
   printf("今天是这年的第几天:%d日\n",plus1);
   return 0;
}
二，求整形数组中的最大值、求数组中的次大值或者次小值

#include <stdio.h>

#define N 5
int main(int argc, const char *argv[])
{
   //求一个数组中的次大值
   int arr[N] = {0};

   int i;
   printf("please input arrvalues:\n");
   for(i=0;i<N;i++)
   {
       scanf("%d",&arr[i]);
   }

   //定义两个变量，分别用来存储最大值和次大值
   int max = 0;
   int cimax = 0;

   //先在数组中前两个元素中决定出最大以及次大
   if(arr[0] > arr[1])
   {
       max = arr[0];
       cimax = arr[1];
   }
   else
   {
       max = arr[1];
       cimax = arr[0];
   }

   //再从下标为2开始进行遍历数组
   for(i=2;i<N;i++)
   {
       //当比max大时
       if(arr[i] > max)
       {
           //先将max赋值给cimax进行保存
           cimax = max;
           max = arr[i];
       }
       //当比max小但是比cmax大
       else if(arr[i] > cimax)
       {
           cimax = arr[i];
       }
   }

   printf("max = %d\tcimax = %d\n",max,cimax);
   return 0;
}
四，打印出如下图案（菱形）
*
***
*****
*******
*****
***
*

#include <stdio.h>

int main(int argc, const char *argv[])
{
   int line;
   printf("请输入需要打印的菱形的上半部分行数:\n");
   scanf("%d",&line);

   printf("打印的%d行的菱形的图案为:\n",line);
   int i,j,k;
   //先打印上半部分
   for(i=0;i<line;i++)
   {
       //打印空格
       for(k=0;k<(line-1-i);k++)
       {
           printf(" ");
       }
       //再打印星星
       for(j=0;j<(2*i)+1;j++)
       {
           printf("*");
       }
       printf("\n");
   }

   //打印下半部分
   for(i=line-2;i>=0;i--)
   {
       //打印空格
       for(j=0;j<(line-1-i);j++)
       {
           printf(" ");
       }
       //再打印星星
       for(k=0;k<(2*i)+1;k++)
       {
           printf("*");
       }
       putchar('\n');
   }
   return 0;
}
五，实现99乘法表

#include<stdio.h>
//九九乘法表

int main(int argc,const char *argv[])
{
   int a,b;   //定义乘数b,被乘数a

   //大循环a嵌套小循环b，随着a的自增，b也随即自增，b超过a就换行
   for(a = 1;a < 10;a++)
   {
       for(b = 1;b < 10;b++)
       {
           if(b <= a)
           {
               printf("%d*%d=%-3d",b,a,b * a);
           }
           else
           {
               break;
           }
       }
   printf("\n");
   }
   return 0;
}
六，求100 - 200之间的所有素数，进行打印
素数：只能被1和其本身整除的数字

#include<stdio.h>
//求出100-200之间的素数，并打印出来

int main (int argc, const char *argv[] )
{
   int n,i;   //定义i为循环数2到n-1，n为范围数100-200
   printf("求出100-200之间的素数\n");

   //给出100-200的数
   for(n = 100;n < 201;n++)
   {
       //素数是除了1之外，仅能被1和其本身整除的数
       for(i = 2;i < n;i++)
       {
           //判断2到n之间的数能否被n整除，能被整除则不是素数，n++
           if(n % i == 0)
           {
               break;
           }
       }
       //需要判断最后一次的i++,是否到达n（能被其本身整除的数）
       if(i == n)
       //else
       {
           printf("此素数为:%-5d\n",n);
       }
   }
   return 0;
}