C语言

    //使用变量之前，必须对变量进行声明！

    //声明变量的语法格式：

    //数据类型变量名 =初值;

    

    //变量名的命名规则

    /**

     *  1、变量名只能以字母、数字、下划线组成，且数字不能开头。

        2、变量名不能重复命名

        3、变量名不能与系统保留字重名

        4、变量名必须见名知义

     */

    

    

//    3a a3 _a a_ a_b float char return numberOfStudent

//    typeOfHero heroType

    

    //其中常见的数据类型有 char字符型、short短整型、int整型、long长整型、float单精度浮点型、double双精度浮点型。

    //变量代表一块存储区域，程序运行期间可以发生改变。

    //下面这行代码的含义是:声明一个字符型变量c，初值为'A'

//    char c = 'A';

//    c = 'B';

    

    //相同数据类型的变量，可以放到同一行去声明，中间以逗号分隔。

//    int a = 3, b = 5, d = 10;

//    a = 10;

//

//    float f = 3.25;

//    f = 4.5;

    

    /*

    //交换两个整型变量的值

    int a = 10, b = 8, temp = 0;

    

    //将a的值赋值给c

    temp = a;

    

    //将b的值赋值给a

    a = b;

    

    //将c的值赋值给b，完成交换。

    b = temp;

    */

    

//    int a = 10;

//    

//    printf("Hello world!\\%% 123 %d,%c,%f\n",a += 100, 'A', 3.14);

//    printf("%-4d\n",a);

//    

//    

//    

//    

//    //1、

//    int number1 = 1, number2 = 4;

//    

//    float result = 0.0;

//    

//    result = (float)number1 / number2 * 100;

//    

//    printf("1占4的%.0f%%\n",result);

//    

//    //2、

//    //分析思路:

//    /**

//     *  1、怎样得到一个0.25的小数，在声明变量的时候，把其中一个变量声明为浮点数类型

//        2、0.25怎么变成最后打印的25,乘以100

//        3、小数点后的值全部不要，占位符为%.0f

//        4、百分号怎么打印，在格式串中输入两个%

//     */

//    int number3 = 1;

//    float number4 = 4.0, result1 = 0.0;

//    

//    result1 = number3 / number4 * 100;

//    

//    printf("1占4的%.0f%%",result1);

    

//    int a = 0,b = 0;

//    char c = '0';

//    

//    printf("请输入两个整数，一个字符:");

//    

//    scanf("%d%d%c", &a, &b, &c);//and

//    

//    printf("number is %d,%d, char is %c", a, b, c);

    

    //要求用户输入两个整数，计算两个输入的数的和，并且输出结果。

    //1、声明两个变量用来接收，用户从控制台输入的数，再声明一个变量，来保存两个数相加之后的和。

    int number1 =0, number2 =0, result =0;

    

    //2、提醒用户输入两个整型数字

   // printf("请输入两个整型数字:");

    

    //3、接收用户输入的数字

   // scanf("%d%d",&number1, &number2);

    

    //4、计算

   // result = number1 + number2;

    

    //5、输出计算之后的结果

   // printf("您输入的两个数的和为:%d",result);

    

    //BOOL 类型的变量，变量名的命名都有自己的特点。

    /**

     *  1、以is开头。isFat,isTall,isBeautiful.

        2、以can开头。canMove,canFly,canRun.

        3、以has开头。hasMoney,hasGirl,hasGay.

     */

//    BOOL isTure = 5 > 3;

//    printf("isTure is %d\n",isTure);

//    

//    BOOL isYES = 8 != 9 || (9 > 10);

//    printf("isYES is %d",isYES);

    

    /*

    int a = 10, b = 9;

    

    //在使用逻辑运算符(逻辑与、逻辑或)时，一定要注意短路现象

    //逻辑与:同真为真，一假则假，短路现象出在一假则假上面。

    //逻辑或:一真则真，同假为假，短路现象出在一真则真上面。

    BOOL isTure = a > b || a++;

    printf("a = %d,b = %d,isTure = %d",a, b, isTure);

    */

    

    //控制台输入一个字符，如果输入的是m，则输出男性，否则什么都不输出。

    

//    char c = '0';

//    printf("请输入一个字符:");

//    scanf("%c",&c);

//    

//    if ('m' == c) {

//        printf("男性");

//    }

//    

//    if ('m' == c) {

//        printf("男性");

//    } else {

//        printf("女性");

//    }

    

    /*

     输入一个年份，判断该年份是否是闰年？如果是闰年，则输出该年是闰年，否则输出该年不是闰年

     提示：

     闰年：能被400整除或者能被4整除，但是不能被

     100整除。

     */

    

    /*

    int year = 0;

    printf("请输入一个年份:");

    scanf("%d",&year);

    

    BOOL is400 = (0 == year % 400);

    BOOL is4 = (0 == year % 4);

    BOOL is100 = (0 == year % 100);

    

    if (is400 || (is4 && !is100)){

        

        printf("%d年是闰年",year);

    }else{

        

        printf("%d年不是闰年",year);

    }

    */

    

    /*

     从键盘输入一个字符，如果是数字打印 this is digital，如果是大写字母，打印 this is  capital letter，如果是小写字母，打印 this is letter，如果是其他字符，打印 other。

     */

    

    /*

    char c = '0';

    printf("请输入一个字符:");

    scanf("%c",&c);

    

    if (c >= '0' && c <= '9') {

        

        printf("this is digital");

    } else if(c >= 'A' && c <= 'Z'){

        

        printf("this is  capital letter");

    } else if (c >= 'a' && c <= 'z'){

        

        printf("this is letter");

    } else{

        

        printf("other");

    }

    */

    

    //控制台输入整型数字(1~4)，然后对应输出，四个季节。

    

    int number =0;

    printf("请输入一个整型数字(1~4):");

    scanf("%d",&number);

    

    switch (number) {

        case1:{

            int a =10;//如果要在switch语句中的case情况里声明一个变量，必须加大括号，规定变量的作用域，否则会报错！

            

            printf("spring %d",a);

            break;

        }//break在switch语句中的作用是跳出当前的case情况，并且跳出switch语句。

        case2:

            printf("summer");

            break;

        case3:

            printf("autumn");

            break;

        case4:

            printf("winter");

            break;

        default:

            printf("是不是有病？");

            break;

    }

    

    //从控制台输入一个字符(A~E)，根据输入的字符，把对应的分数输出。

    

    char score ='0';

    printf("请输入一个字符(A~E):");

    scanf("%c",&score);

    

    switch (score) {

        case'A':

            printf("90~100");

            break;

        case'B':

            printf("80~90");

            break;

        case'C':

            printf("70~80");

            break;

        case'D':

            printf("60~70");

            break;

        case'E':

            printf("不及格");

            break;

        default:

            printf("你有病吧？");

            break;

    }

    

    //枚举是一种构造类型，系统本身没有，需要我们自己去定义。

    //枚举的目的是提高代码的可读性

    //枚举的作用是将人们能识别的标识符与计算机能识别的数字一一建立对应关系

    //切记一点，枚举值一定要包含所有的情况，也就是说，枚举值的数量要固定。

    //定义枚举的语法格式：enum枚举名 {枚举值1,枚举值2,...枚举值n};

    enum season {

        spring = 1,

        summer,

        autumn,

        winter

    };

    

    //变量类型是 enum season，变量名是currentSeason，变量的初值为spring.

    enumseason currentSeason =spring;

    printf("请输入一个整型数字(1~4):");

    scanf("%d",&currentSeason);

    

    switch (currentSeason) {

        case spring:

            printf("放风筝");

            break;

        case summer:

            printf("游泳");

            break;

        case autumn:

            printf("看枫叶");

            break;

        case winter:

            printf("去三亚堆雪人");

            break;

        default:

            break;

    }

    

    int month =0, day =0;

    scanf("%d",&month);

    

    switch (month) {

        case1:

        case3:

        case5:

        case7:

        case8:

        case10:

        case12:

            day = 31;

            break;

        case4:

        case6:

        case9:

        case11:

            day = 30;

            break;

        case2:

            day = 29;

            break;

        default:

            break;

    }

    

  

    //while语句的语法格式:

    /**

     *  while (条件表达式) {

            语句;

     }

     */

    //当条件表达式为真时，反复执行语句，当条件表达式为假时，跳过语句的执行，执行while语句下面的代码。

    //输出1～100之间7的倍数

    //思路：1、需要一个循环增量，来让数字累加起来，并且作为内容来判断是否是7的倍数。2、采用while循环，来实现整个过程。

    

    /* 用while打印出1~100之间不是7的倍数并且不包含7的数。

    //1、循环增量(循环变量)初始化

    int i = 1;

    

    //2、while语句

    while (i < 101) {

        if (0 != i % 7 && (7 != i / 10) && (7 != i % 10)) {

            printf("%d\t",i);

        }

        

        //不管是否是7的倍数，循环变量肯定要自增1.

        i ++;

    }

    */

    

    //求一个[10, 30]之间的随机数。

    //[a, b]之间的随机数公式 arc4random() % (b - a + 1) + a;

    /*

    int number = arc4random() % (30 - 10 + 1) + 10;

    printf("number is %d",number);

    */

    

    /*

    //打印十个 [30, 70]之间的随机数

    //声明两个变量，一个作为循环增量，一个用来储存生成的随机数

    int i = 0, number = 0, max = 0;

    

    //while 循环

    while (i < 10) {

        number = arc4random() % (70 - 30 + 1) + 30;

        printf("number is %d\n",number);

        

        //1、if语句

        if (max <= number) {

            max = number;

        }

        

        //2、条件运算符

        max = max > number ? max : number;

        

        i ++;

    }

    

    printf("max is %d",max);

    */

    

    

    /*

    //打印1～100之间的数，但是当遇见第一个13的倍数的时候，停止打印。

    //声明一个循环增量

    int i = 1;

    

    //开始循环

    while (i < 101) {

        printf("%d\t",i);

        

        //自增

        i ++;

        if (0 == i % 13) {

            break;

        }

        

    }

    

    printf("i = %d", i);

    */

//    int i = 1;

//    

//    while (i < 101) {

//        BOOL is7 = (0 == i % 7);

//        BOOL is7shi = (7 == i / 10);

//        BOOL is7ge = (7 == i % 10);

//

//        if (!is7 && !is7shi && !is7ge) {

//            printf("i = %d\t",i);

//        }

//        

//        i ++;

//    }

    

    /*

    //打印iOS100次，并且后面跟着打印的次数，当次数为4的倍数的时候，省略次数，只打印iOS。

    

    //声明一个循环增量

    int i = 1;

    

    while (i < 101) {

        printf("iOS ");

        

        if (0 == i % 4) {

            i ++;

            continue;

        }

        

        printf("%d ",i);

        i ++;

    }

    */

    

    //用do while循环打印 1～10之间的所有整数

    //do while循环的语法格式:

    /**

     *  do {

            语句;

     } while (条件表达式);

     */

    /*

    int i = 1;

    

    do {

        printf("%d\t",i);

    } while (++ i < 11);

    */

    

    //循环的组成部分，四部分

    /**

     *  1、循环变量的初始化

        2、循环条件

        3、循环变量自增或者自减

        4、循环语句

     */

    //while、do while、for循环组成部分都是以上四部分，没有任何变化，只不过在语法格式也就是外观上，有一定差别。

    

    //for 循环的语法格式:

    /**

     *  for (循环变量初始化;循环条件;循环增量) {

                语句;(循环体)

        }

     */

    //for循环的执行顺序，与while循环的执行顺序是一样的。

    /**

     *  1、循环变量初始化

        2、循环条件判断

        3、语句(循环体)

        4、循环增量

     */

//    for (int i = 1; i < 101; i ++) {

//        if (0 != i % 7 && (7 != i / 10) && (7 != i % 10)) {

//            printf("%d\t",i);

//        }

//    }

    

    //怎么打印

    /**

     *  1

        1   2

        1   2   3

     */

    //思路:我们需要打印三行数据，这时候我们可以采用for循环控制打印的行数。每一行中打印的数字个数和行数相等，并且每一行中的最大数与行数相等。

//    printf("1\n");

//    printf("1    2\n");

//    printf("1    2    3\n");

    /*

    for (int i = 1; i < 4; i ++) {//用来控制行数

        //打印每一行中的数字

        for (int j = 1; j < i + 1; j ++) {

            printf("%d\t",j);

        }

        printf("\n");

    }

    */

    

    //打印乘法口诀表

    for (int i =1; i <10; i ++) {//外层循环控制打印多少行

        for (int j =1; j < i +1; j ++) {//内存循环控制打印多少个计算公式

            printf("%d * %d = %-2d ",j, i, i * j);

        }

        printf("\n");

    }

    

    //打印100～999之间所有的数字

    for (int i =1; i <10; i ++) {//百位

        for (int j =0; j <10; j ++) {//十位

            for (int k =0; k <10; k ++) {//个位

                printf("%d ",100 * i +10 * j + k);

            }

        }

    }

    

    

    

    //刚开始的序列 18 58 7 37 22

    //第一趟:

    //第一次:18 58 7 37 22

    //第二次:18 7 58 37 22

    //第三次:18 7 37 58 22

    //第四次:18 7 37 22 58第一趟得到了一个最大的数为58

    

    //第二趟:

    //第一次:7 18 37 22

    //第二次:7 18 37 22

    //第三次:7 18 22 37第二趟得到了一个第二大的数37

    

    //第三趟:

    //第一次:7 18 22

    //第二次:7 18 22第三趟得到了一个第三大的数22

    

    //第四趟:

    //第一次:7 18第四趟出结果得到了一个第四大的数，自然而然剩下的那个数就是最小的。排序结束

    //最终的排序结果为 7 18 22 37 58

    

    //冒泡排序的原则是:比较相邻两个数的大小，如果前面的大于后面的，交换位置，否则位置不动，依次比较完成之后，从每一趟中都可以得到这一趟比较的所有数中最大的那个数。

    //count 表示数组容量。array 代表数组名

    //这个是好理解版本

    /*

    for (int i = 1; i < count; i ++) {//控制趟数

        for (int j = 0; j < count - i; j ++) {//控制的是每一趟比较多少次

            if (array[j] > array[j + 1]) {

                int temp = array[j];

                array[j] = array[j + 1];

                array[j + 1] = temp;

            }

        }

    }

    */

    

    /*

    for (int i = 0; i < count - 1; i ++) {//控制趟数

        for (int j = 0; j < count - i - 1; j ++) {//控制的是每一趟比较多少次

            if (array[j] > array[j + 1]) {

                int temp = array[j];

                array[j] = array[j + 1];

                array[j + 1] = temp;

            }

        }

    }

     */

    

    //定义一个具有十个元素的整型数组，随机赋值(范围20～40)，并且按照升序输出 所有的元素。

    /*

    int array[10] = {0};

    //1、通过for循环给数组元素进行随机赋值

    for (int i = 0; i < 10; i ++) {

        array[i] = arc4random() % (40 - 20 + 1) + 20;

        printf("%d\t",array[i]);

    }

    

    printf("\n");

    

    //2、冒泡排序

    for (int i = 0; i < 10 - 1; i ++) {

        for (int j = 0; j < 10 - 1 - i; j ++) {

            if (array[j] > array[j + 1]) {

                int temp = array[j];

                array[j] = array[j + 1];

                array[j + 1] = temp;

            }

        }

    }

    

    //通过for循环将排序好后的数组元素打印出来

    for (int i = 0; i < 10; i ++) {

        printf("%d\t",array[i]);

    }

    */

    

    //字符数组

    //字符数组就是存放 字符类型元素的容器。string

    /*

    char str1[30] = {'i', 'P', 'h', 'o', 'n', 'e'};

    

    char str2[30] = "iPhone";//这种方式是我们以后声明字符数组的常用方式。

    

    char str3[30] = {'i', 'P', 'h', 'o', 'n', 'e', '\0'};

    //C语言中的字符串就是以 '\0'结尾的字符数组。

    

    //打印C语言字符串占位符为 %s

    printf("str1 = %s, str2 = %s, str3 = %s",str1, str2, str3);

    */

    

    //字符串操作函数

    //1、计算字符串长度的函数 strlen();

    char str[30] ="iPhone6sPlus";

    char str1[10] = {'i','P', 'h','o', '\0'};

//    int a = 10;

//    a = 11;

//    

//    const int b = 11;

//    b = 12;

    

    //字符串长度的类型为无符号的长整型，打印占位符为%lu

    unsignedlong strLength = strlen(str);

    printf("strLength is %lu,%lu",strLength,strlen(str1));

    

    //2、字符串拷贝函数 strcpy

    char str2[30] = {0};

    char str3[30] ="i want an iPhone6sPlus";

    strcpy(str2, str3);//将str3里面的内容拷贝到str2里面。

    printf("str2 = %s, str3 = %s",str2, str3);

    

    //3、字符串拼接函数 strcat

    char str4[255] ="marry beautiful girl";

    char str5[30] ="become a boss";

    strcat(str4, str5);

    printf("str4 = %s",str4);

    

    //4、字符串比较函数 strcmp

    char str6[30] ="i want a girlFriend";

    char str7[30] ="i want a boyFriend";

   

    //result的结果为两个字符串首位不相同的字符 ascii码值的差值。

    int result = strcmp(str6, str7);

    printf("result = %d",result);

    

    if (result >0) {

        char strTemp[30] = {0};

        //字符串的交换需要借助拷贝函数，不能直接赋值

        strcpy(strTemp, str6);

        strcpy(str6, str7);

        strcpy(str7, strTemp);

    }

    

    /**

     *  将字符串倒转：

     例如：“afjnpue”

     转变成字符串“eupnjfa”

     （注：是改变字符串本身，不是 反向输出）

     */

    

    char string[30] ="fangyuanbaili";

    

    int length = (int)strlen(string);

    

    printf("\n");

    

    for (int i =0; i < length / 2; i ++) {

        char temp = string[i];

        string[i] = string[length - 1 - i];

        string[length - 1 - i] = temp;

    }

    

    printf("%s",string);

    

//    for (int i = length - 1; i >= 0; i --) {

//        printf("%c",string[i]);

//    }

    

    

    //数组是存放一组 相同数据类型的一种容器，其中数组中存放的内容叫做成员，也可以叫做数组元素。

    //声明数组的语法格式为:

    /**

     *  数据类型数组名[常量表达式] = {值1,值2,...值n};

     */

    //ageArray数组的数据类型是 int[5],代表的是数组内部存放了五个整型元素。如果问的是数组元素的类型，那就是int类型。

    

    //数组是不会直接参与运算的，参与运算的是数组中保存的元素，我们可以通过下标的形式来访问得到数组中某个具体的元素。

    int ageArray[5] = {10,11,12,13,14};

    //访问数组元素的语法格式为数组名 + [下标];

    //使用数组时一定要注意一点！数组的下标是从0开始的，最大值为数组容量 - 1。

//    printf("%d",ageArray[4]);

    

    char genderArray[2] = {'f','m'};

    

    float scoreArray[3] = {98.0,99.5, 85.3};

    

    //数组在定义的时候，一定要确定数组容量

    //我可以不给定全部的值，剩余的值系统默认给的是0.

    int b[5] = {2,7, 4};

    

    //我们可以在定义数组的时候，一个值都不给，全是0，后期根据我们的需求往数组里面存放内容

    int c[5] = {0};

    

    //我可以不写数组容量，数组容量会根据初值的个数确定

    int d[] = {2,7, 4};

    

    //定义一个具有 20个元素的 整型数组，每个元素的取值范围是30-70之间，求数组元素的和。

    

    /*

    int array[20] = {0};

    int sum = 0;//此变量来记录20个元素的和，做累加操作。

    

    for (int i = 0; i < 20; i ++) {

        array[i] = arc4random() % (70 - 30 + 1) + 30;

        

        printf("%d\t",array[i]);

//        sum = sum + array[i];

        sum += array[i];

    }

    

    printf("\nsum is %d",sum);

    */

    

    //复制一个数组，即两个数组容量一样，把其中一个数组中的元素 复制到另外一个数组中。

    

    /*

    int array[5] = {0};

    int arr[5] = {0};

    

    for (int i = 0; i < 5; i ++) {

        array[i] = arc4random() % (20 - 10 + 1) + 10;

        printf("array[%d] = %d\t",i, array[i]);

        arr[i] = array[i];

    }

    

    printf("\n");

    

    for (int i = 0; i < 5; i ++) {

        printf("arr[%d] = %d\t",i, arr[i]);

    }

    */

    

    //生成 2个数组，每个数组都有 10个元素，元素取值范围 20-40之间，数组对应元素相加，放到另外一个数组中。

    

    int arr1[10] = {0};

    int arr2[10] = {0};

    int arr3[10] = {0};

    

    for (int i =0; i < 10; i ++) {

        arr1[i] = arc4random() % (40 -20 + 1) +20;

        printf("arr1[%d] = %d ",i, arr1[i]);

        

        arr2[i] = arc4random() % (40 -20 + 1) +20;

        printf("arr2[%d] = %d ",i, arr2[i]);

        

        arr3[i] = arr1[i] + arr2[i];

        printf("arr3[%d] = %d ",i, arr3[i]);

        

        printf("\n");

    }

    //声明一个整型二维数组

    //二维数组的声明语法与 一维数组没有本质区别，只是多了一个维度而已。

    //数据类型数组名[常量表达式1][常量表达式2] = {初值1,初值2, ..., 初值n};

    //常量表达式1，代表第一维的长度，常量表达式2，代表第二维的长度。通常，第一维长度我们称之为行，第二维长度我们称之为列，以后我们描述二维数组就可以叫做 几行几列的二维数组。

    //二维数组容量(元素个数) =第一维长度(行) *第二维长度(列);

    //二维数组与一维数组一样是不能直接参与运算的，但是我们可以通过下标找到数组中的元素参与运算。二维数组获取元素的语法格式为：数组名 + [第一维下标][第二维下标];

    //只要是数组，不管几维下标，都是从0开始的。

    int array[2][3] = {7,4, 1,2, 3,8};

    int array2[2][3] = {7,4};

    

    printf("%d\n",array[1][0]);

    

    //以下声明的这个二维数组，可以理解为包含两个一维数组的一个大数组。每个一维数组包含三个元素。

    int arr[2][3] = {

        {7,4, 1},//第一行，一维下标为0

        {2,3, 8}//第二行，一维下标为1

    };

    

    //二维数组在定义的时候，需要注意！一维长度可以不给定，但是二维长度必须给定，系统会根据二维长度，决定行的多少，但是通过一维长度，确定不了列的多少。

    //初值个数不够，二维数组与一维数组一样，系统默认给0

    int array3[][3] = {7,4, 4,1};

    

    //二维数组不管是 赋值还是遍历，采用的是双层for循环，外层循环控制行数，内存循环控制列数。

    

    /*

    //将一个二维数组的行和列交换，存储到另外一个数组中去。

    int arr1[3][2] = {0};

    for (int i = 0; i < 2; i ++) {

        for (int j = 0; j < 3; j ++) {

            arr1[j][i] = arr[i][j];

        }

    }

    

    //双层for循环，将三行两列的二维数组中的元素打印出来

    for (int i = 0; i < 3; i ++) {

        for (int j = 0; j < 2; j ++) {

            printf("%d\t",arr1[i][j]);

        }

        printf("\n");

    }

    */

    

    //有一个3行4列的二维数组，要求编程找出最大元素，并输出所在的行和列。

    /*

    int array1[3][4] = {0};

    int max = 0, maxRow = 0, maxColumn = 0;

    

    //给二维数组内部的元素随机赋值

    for (int i = 0; i < 3; i ++) {

        for (int j = 0; j < 4; j ++) {

            array1[i][j] = arc4random() % (30 - 10 + 1) + 10;

            

            max = max > array1[i][j] ? max : array1[i][j];

            

            printf("%d\t",array1[i][j]);

        }

        printf("\n");

    }

    

    for (int i = 0; i < 3; i ++) {

        for (int j = 0; j < 4; j ++) {

            if (max == array1[i][j]) {

                maxRow = i + 1;

                maxColumn = j + 1;

                printf("最大值所在行:%d,列:%d\n",maxRow, maxColumn);

            }

        }

    }

    */

    

    //定义一个拥有三个 字符串的字符串数组

    //字符串数组就是一个容器，里面盛放了 多个字符串。

    //定义字符串数组的语法格式:数据类型数组名[常量表达式1][常量表达式2] = {字符串1,字符串2, ..., 字符串n};

    //其中常量表达式1代表数组中包含多少个字符串，常量表达式2代表每个字符串的容量

    //在实际开发过程中，我们不会通过双下标找到字符串中的某个字符做操作，常用的是数组名 + [一维下标]获取到某个字符串整体，对字符串做操作。

    //注意:字符串长度 <=字符串数组二维长度 - 1，因为字符串最后还有一个标记结束的'\0'。

    

    char str[3][30] = {"iPhone6sPlus","girlFriend", "boyFriend"};

    printf("%c\n",str[0][6]);

    printf("%s\n",str[1]);

    

    //定义一个字符串数组，包含六个人的姓名，编程找出最长的人名，并且输出长度，人名，以及在数组中位置(下标)

    char name[6][20] = {

        "yebingfeng",

        "fangyuan",

        "gujinhua",

        "heqin",

        "wangyuzhu",

        "taozhifu"

    };

    

    /*

    unsigned long maxLength = 0;

//    int maxRow = 0;

    

    //得到字符串中最长字符串的长度

    for (int i = 0; i < 6; i ++) {

        maxLength = maxLength > strlen(name[i]) ? maxLength : strlen(name[i]);

    }

    

    //通过得到的最长长度，遍历字符串数组，判断哪个字符串的长度与最长长度相等，记录下标，并且输出最长字符串。

    for (int i = 0; i < 6; i ++) {

        if (maxLength == strlen(name[i])) {

            printf("最长的字符串为:%s,下标为%d",name[i], i);

        }

    }

    */

    

    for (int i =0; i < 6 -1; i ++) {

        for (int j =0; j < 6 -1 - i; j ++) {

            if (strcmp(name[j], name[j +1]) > 0) {

                char temp[20] = {0};

                strcpy(temp, name[j]);

                strcpy(name[j], name[j + 1]);

                strcpy(name[j + 1], temp);

            }

        }

    }

    

    for (int i =0; i < 6; i ++) {

        printf("%s\n", name[i]);

    }