对多少个国家的称号进行排序详细分析,选取排序

从小到大的选料排序 是从2个数组中逐条选出 最小数值 输出,第3小的数值输出,第1小的数值输出…
…直到最终三个数组中最终三个数遍历实现,则 整个排序输出完毕。

0一奇数求和演练

  • A: 奇数求和练习

    • a: 标题分析

      • 为了记录累加和的值,大家须求定义一个储存累加和的变量
      • 作者们要博取到一-100限制内的数
      • 判断当前数是还是不是为奇数,是奇数,完毕拉长和操作
      • 丰裕完结后,最终展现下累加和的值
    • b: 解题步骤

      • 概念三个用来记录累加和的变量
      • 动用for循环语句,马克down Preview Enhanced: Toggle Scroll
        Sync完结一-十0之内每一个数的获得
      • 利用if条件语句,判断当前数是或不是是奇数,是奇数,进行添加和操作
      • 行使输出语句,打字与印刷累加和变量的值
    • c: 案例代码

        public class Test01 {
            public static void main(String[] args) {
                int sum = 0;
                for (int i = 0; i < 100; i++) {
                    if (i%2==1) {
                        sum += i;
                    }
                }
                System.out.println("累加和的值 " + sum);
            }
        }
    

 

采纳法排序指每一回接纳所要排序的数组中的最大值(由小到大排序则接纳最小值)的数组元素,将那么些数组成分的值与最前方未有展开排序的数组元素的值互换。以数字九、六、一伍、四、2为例,选择选取法贯彻数字按从小到大进展排序,每一回交流的顺序如图8.一柒所示。

 美高梅开户网址 1

图⑧.1七 
选取法排序示意图

从图八.1柒能够窥见,在第二回排序过程中校第2个数字和微小的数字进行了岗位沟通;而第三回排序进程中,将第3个数字和剩余的数字中型小型小的的数字实行了地方交流;依此类推,每一次都将下贰个数字和剩余的数字中小小的的数字举办岗位沟通,直到将一组数字按从小到大排序。

上面通过实例来看一下哪些通进程序行使选用法贯彻数组成分从小到大的排序。 

注:代码通过TDM-GCC四.九.二编写翻译通过

 int[] sort = new int[13] { 1, 4, 89, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 };  // 输入一个数组
            for (int i = 0; i < sort.Length; i++)
            {
                int min = sort[i];  // 初始化(以第i个数为初始值)最小值
                for (int j = i+1; j < sort.Length; j++)   // 从第i+1个开始遍历数组,与第i个数对比,找到最小值
                {
                    if (sort[j] < min)
                    {
                        int temp = sort[j];
                        sort[j] = min;
                        min = temp;
                    }     // 找到最小值赋值给min
                }
                Console.Write(min + " ");  // 输出min 值
            }

0二天葱练习功用完结

  • A: 水仙花演练作用完成

    • a: 标题分析

      • 鲜明如何的数正是天葱数。金盏银台数是指1个几人数(十0-99九以内),其每位数字立方之和相当该4人数自个儿。
        如153 = 111 + 333 + 55五,即 三个人数本身 = 百位数立方 +
        十个人数立方 + 个位数立方;
      • 获取姚女子花剑范围内的装有二位数(十0-99九之内的各类二人数)
      • 认清该三人数是还是不是知足金盏银台数,满意,打字与印刷该几个人数
    • b: 解题步骤

      • 动用for循环,获得100-999之内的各个四位数
      • 赢得4个人数中国百货公司位数字、十一位数字、个位数字
      • 行使if条件语句,判断该几个人数是或不是满足姚女花数,满足,使用输出语句,打字与印刷该四位数
    • c: 案例代码

       public class Test02 {
           public static void main(String[] args) {
               for (int i = 100; i < 1000; i++) {
                   int bai = i/100%10;
                   int shi = i/10%10;
                   int ge = i%10;
                   if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
                       System.out.println(i);
                   }
               }
           }
       }           
    
实例 利用选取排序将学员成绩进行排序

在本实例中,注明了二个整型数组和四个整型变量,在那之中整型数组用于存储用户输入的数字,而整型变量用于存款和储蓄数值最小的数组成分的数值和该因素的任务,然后经过双层循环举办精选法排序,最后将排好序的数组进行输出。具体代码如下:

01   #include<stdio.h>/*包含头文件*/

02  int main()                   /*主函数main*/

03  {

04           int i,j;                             /*定义变量*/

05           int a[10];

06           int iTemp;

07           int iPos;

08           printf("为数组元素赋值:\n");

09           /*从键盘为数组元素赋值(成绩)*/

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

11           {

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

13                  scanf("%d", &a[i]); 

14           }

15           /*从高到低排序*/

16           for(i=0;i<9;i++)                                 /*设置外层循环为下标0~8的元素*/

17           {

18                  iTemp = a[i];                       /*设置当前元素为最大值*/

19                  iPos = i;                              /*记录元素位置*/

20                  for(j=i+1;j<10;j++)                     /*内层循环i+1到9*/

21                  {

22                         if(a[j]>iTemp)                      /*如果当前元素比最高值还高*/

23                         {

24                                iTemp = a[j];          /*重新设置最高值*/

25                                iPos = j;                /*记录元素位置*/

26                         }

27                  }

28                  /*交换两个元素值*/

29                  a[iPos] = a[i];

30                  a[i] = iTemp;

31           }

32   

33           /*输出数组*/

34           for(i=0;i<10;i++)

35           {

36                  printf("%d\t",a[i]);                /*输出制表位*/

37                  if(i == 4)                             /*如果是第5个元素*/

38                         printf("\n");            /*输出换行*/

39           }

40   

41           return 0;                                     /*程序结束*/

42  }

 

运作程序,显示结果如图八.1捌所示。

 美高梅开户网址 2

图捌.1八 
选取排序运营图

从该实例代码和平运动行结果能够看到:

(1)声美素佳儿(Friso)(Nutrilon)个整型数组a,并通过键盘为数组成分赋值。

(二)设置1个嵌套循环,第2层循环为前七个数组成分,并在历次循环时将对相应前次数的数组成分设置为最小值(借使当前是第二遍巡回,那么将数组中第三个因素(也正是下标为二的要素)设置为近年来的最小值);在其次层循环中,循环相比较该因素之后的种种数组成分,并将每一趟相比较结实中较小的数设置为最小值,在第3层循环甘休时,将最小值与开首时设置为最小值的数组成分实行交流。当全数循环都形成之后,就将数组成分根据从小到大的相继重新排列了。

(三)循环输出数组中的成分,并在出口陆个因素之后实行换行,在下壹行输出后边的伍个要素。

 

本文章摘要自前天科学技术出版的《零基础学C语言》,转发请注解出处!!!

原题:有”China”,”America”,”Australia”,”France”,”德文y”四个国名。设计一个顺序使其按字母逐一进行排序并出口结果。

  

03ASCII编码表

  • A: ASCII编码表
    • a: 英文全称
      • American 斯坦dard Code for Information
        Interchange,U.S.专业音讯调换代码
    • b: ASCII编码表由来
      • 微型总括机中,全体的多少在蕴藏和平运动算时都要动用二进制数表示
      • a、b、c、d那样的53个字母(包含大写)、以及0、一等数字还有局地常用的号子,
        在微型总计机中存储时也要采纳2进制数来代表
      • 现实用哪些贰进制数字代表哪个符号,当然各种人都能够预约自身的壹套(那就叫编码)
      • 世家倘使要想相互通讯而不造成混乱,那么大家就不能不运用同样的编码规则,于是美国有关的基准协会就出台了ASCII编码,
        集合规定了上述常用符号用哪些2进制数来代表。
    • c: 汉语编码表
      • GB2312
      • UNICODE
    • d: 字符中首要的ASCII码对应关系
      • a : 97
      • A : 65
      • 0 : 48

思路:应用传统的排序方法,将字符串保存在字符数组中开始展览置换,将使得程序变得复杂,难于编写检查。能够将其都保留在字符串指针数组中。排序时只要套用原来1维数组的排序方法,将三个字符串指针在指针数组中的顺序举行置换,程序就变得至极简便。

0肆char类型的囤积

  • 对多少个国家的称号进行排序详细分析,选取排序。A: char类型的蕴藏

    • a: 取值范围

      • short:占四个字节,是有标志数据,取值范围-3276八-327陆7
      • char: 占多少个字节,是无符号数据,取值范围0-6553陆
    • b: 类型转换

      • char类型的数码参预运算时要线程程int数据类型
    • c: 案例代码

        /*  ASCII编码表演示
            字符Java 数据类型,char
            整数Java 数据类型,int

            int 类型和 char 数据类型转换
            char  两个字节, int 四个字节

            char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
            int转成char类型的时候,强制转换,会查询编码表

            char存储汉字,查询Unicode编码表

            char可以和int计算,提示为int类型, 内存中两个字节
            char取值范围是0-65535, 无符号的数据类型
        */
        public class ASCIIDemo{
            public static void main(String[] args){
                char c = 'a';
                int i = c + 1;
                System.out.println(i);

                int j = 90;
                char h = (char)j;
                System.out.println(h);

                System.out.println( (char)6 );

                char k = '你';
                System.out.println(k);


                char m = -1;
            }
        }   

规划:编写一个自定义函数:void sort(char *name[])用于排序,void
prins(char
*put[])用于出口。在main()函数中对字符串实行赋值,并且逐一调用多个自定义函数,完毕布置。

05出口所有英文字母

  • A: 输出全部英文字母

    • a: 标题分析

      • 合计23个大大小小写字母,那么,能够挂念循环二十五回。在每便循环中,完毕钦赐字母的轻重写打字与印刷
      • 找出ABCDEFG…XYZ那个假名之间的变化规律
        通过ASCII表发现,前边的字母比它面前的假名,ASCII值大一
        下二个字母 = 上二个假名 + 一
        如: A B C D
        65 66 67 68
      • 在历次循环中打字与印刷上四个字母大小写,并钦赐下四个假名
    • b: 解题步骤

      • 概念开始化大写变量,值为’A’; 早先化小写变量,值为’a’
      • 使用for循环,进行26次循环
      • 在历次循环中,打字与印刷大写字母、小写字母。
        老是打字与印刷实现后,更新大写字母值、小写字母值
    • c: 案例代码

        public class Test04 {
            public static void main(String[] args) {
                char da = 'A';
                char xiao = 'a';
                for (int i = 0; i < 26; i++) {
                    System.out.println("大写字母 "+da+" ,小写字母 "+xiao);
                    da++; //更新大写字母值
                    xiao++; //更新小写字母值
                }
            }
        }
        ```
    

代码:

069九乘法表的剖析

  • A: 9玖乘法表的分析

    • a: 打字与印刷格式
      11=1
      1
      2=2 22=4
      1
      3=3 23=6 33=9

    • b: 标题分析
      通过观看发现,若是把一一=1那样的剧情看做1颗的话,那么打字与印刷结果就成了之类效果:

      **




      那样,便是打字与印刷玖行星,每行打印星的个数与眼下行数相等。
      再观察“13=3 23=6 33=九”得出它们如下的变化规律:
      每行第n次 +”
      “+ 行号 +”=”+ 每行第n次 * 行号
      如: 1 +”“+ 2 +”=”+ 12; // 相当于12=2
      2 +”
      “+ 2 +”=”+ 22; // 相当于22=4

    • c: 解题步骤

      • 概念2个外层for循环,早先值从一始发,循环5回。用来控制打字与印刷的行数
      • 在外层for循环内部,定义二个for循环,初步值从壹起来,循环次数与眼下行数相等。用来成功每行打字与印刷钦命次数的乘法公式
        如壹*1=1
      • 在内层for循环中,达成每行钦赐次数的乘法公式打字与印刷 如11=1
        System.out.print(k +”
        “+ j +”=”+ j*k +”\t”);
        // 变量k代表:每行中的第n次
        // 变量j代表:行号
      • 在外循环中,当每行内定次数的乘法公式打字与印刷实现后,通过System.out.println()切换来下一行。
        如此,再一次打印乘法公式时,就在下1行输出打印了
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 #define N 5 
 5 
 6 void sort(char *name[]) //排序
 7 {
 8     int i,j;
 9     char *sp; //用于临时交换
10     for(i = 0;i < N-1;i++) //利用选择排序法进行排序
11     {
12         for(j = i+1;j < N;j++)
13         {
14             if(strcmp(name[i],name[j]) > 0)
15                         { //当name[i]>name[j]时进行交换来排序①
16                 sp = name[i];
17                 name[i] = name[i+1];
18                 name[i+1] = sp;
19             }
20         }
21     }
22 }
23 
24 void prins(char *put[]) //输出
25 {
26     int i;
27     for(i = 0;i < N;i++)
28         printf("%s ",put[i]); //不能写*put[i]②
29 }
30 
31 int main() {
32     char *spa[] = {"China","America","Australia","France","Germany"};
33     sort(spa);
34     prins(spa);
35     getch();
36     return 0;
37 }                    

079玖乘法表的效果完成

  • A: 9九乘法表的效应完成

    • a: 案例代码

        /*
            利用嵌套for循环,实现99乘法表示
            实现步骤:
              1. 定义外循环控制行数
              2. 内循环控制个数,个数,每次都在递增
              3. 循环中输出,乘法表的格式   1*3=3
        */
    
        public class Test05 {
            public static void main(String[] args) {
                for (int j = 1; j < 10; j++) {
                    for (int k = 1; k <= j; k++) {
                        System.out.print(k +"*"+ j +"="+ j*k +"\t");
                    }
                    System.out.println();
                }
            }
        }
    
        ```
    

 

08落实数组的遍历

  • A: 完结数组的遍历

    • a: 题目分析

      • 通过轮回,大家可以成功数组申月素的拿走,数组名[索引]
      • 观看发现,各个数组成分之间进入了2个逗号”,”进行分隔;并且,整个数组的光景有一对中括号”[]”包裹数组全数因素。
    • b: 解题步骤

      • 使用输出语句完结打字与印刷 左边的中括号”[”
      • 采纳循环,输出数组成分值。输出成分值分为二种状态,如下:
        • 终极三个数组成分,加上多个右边的中括号”]”
        • 非最后三个数组成分,加上贰个逗号”,”
    • c: 案例代码

            /*
                定义方法,实现数组的遍历
                遍历中,输出结果  [11,33,565,66,78,89]
                int[] arr = {3,4,45,7};
                结果包含字符串, [  ]  ,
                实现步骤:
                  1. 定义方法实现数组的遍历
                  2. 先打印[ 中括号
                  3. 遍历数组
                    输出数组的元素和逗号
                    判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出]中括号
            */
            public class ArrayMethodTest{
                public static void main(String[] args){
                    int[] arr = {11,44,55,33,66};
                    printArray(arr);
    
                    int[] arr2 = {22,88,99,33,66};
                    printArray(arr2);
    
                }
                /*
                   定义方法,实现功能
                   返回值: void
                   方法参数: 数组
                */
                public static void printArray(int[] arr){
                    //输出一半中括号,不要换行打印
                    System.out.print("[");
                    //数组进行遍历
                    for(int i = 0 ; i < arr.length ; i++){
                        //判断遍历到的元素,是不是数组的最后一个元素
                        //如何判断 循环变量 到达 length-1
                        if( i == arr.length-1 ){
                            //输出数组的元素和]
                            System.out.print(arr[i]+"]");
                        }else{
                        //不是数组的最后一个元素,输出数组元素和逗号
                            System.out.print(arr[i]+",");
                        }
                    }
                    System.out.println();
                }
            }
        ```
    

运作结果:America Australia China France 德文y

0九数组逆序原理

  • A: 数组逆序原理

  • a: 标题分析(图解见day07_source/数组的逆序原理.JPG)

    • 通过观望发现,本标题要贯彻原数组成分倒序存放操作。即原数组存款和储蓄元素为{11,22,3三,4四},
      逆序后为原数组存款和储蓄成分变为{4四,33,2二,11}。
    • 由此图解发现,想完结数组成分逆序,其实正是把数组中索引为start与end的因素实行交流。
    • 每一遍交流后,start索引地点后移,end索引地点前移,再进行交流
    • 截止start地方超过了end地点,交流甘休,此时,数组成分逆序完结。
  • b: 解题步骤

    • 概念三个目录变量start值为0,变量end值为数经理度减去1(即数组最终三个成分索引)
    • 使用循环,达成数组索引start地方成分与end地点元素值交流。
    • 在循环换进程中,每一遍调换甘休后,start地方后移1,end地点前移一
    • 在循环换进程中,开始判断start地点是还是不是当先了end地点,若已超过,则跳出循环

解释:①strcmp(str1,str2)中,

10数组逆序功用完结

  • A:案例代码

        /*
           数组的逆序:
             数组中的元素,进行位置上的交换
             逆序 不等于 反向遍历
             就是数组中最远的两个索引,进行位置交换,实现数组的逆序
             使用的是数组的指针思想,就是变量,思想,可以随时变换索引
             反转 reverse
             实现步骤:
               1. 定义方法,实现数组的逆序
               2. 遍历数组
                 实现数组的最远索引换位置
                 使用临时的第三方变量
        */
        public class ArrayMethodTest_1{
            public static void main(String[] args){
                int[] arr = {3,5,7,1,0,9,-2};
                //调用数组的逆序方法
                reverse(arr);
                //看到数组的元素,遍历
                printArray(arr);
            }

            /*
               定义方法,实现数组的逆序
               返回值: 没有返回值
               参数:   数组就是参数
            */
            public static void reverse(int[] arr){
                //利用循环,实现数组遍历,遍历过程中,最远端换位
                //for的第一项,定义2个变量, 最后,两个变量++ --
                for( int min = 0 , max = arr.length-1 ; min < max  ; min++,max--){
                    //对数组中的元素,进行位置交换
                    //min索引和max索引的元素交换
                    //定义变量,保存min索引
                    int temp = arr[min];
                    //max索引上的元素,赋值给min索引
                    arr[min] =  arr[max];
                    //临时变量,保存的数据,赋值到max索引上
                    arr[max] = temp;
                }
            }
        }

当str1 > str2时,函数值 > 0;

1一选项排序原理

  • A: 选拔排序原理
    • a: 标题分析(图解见day0七_source/选择排序原理.JPG)
      • 通过阅览发现,本标题要实现把数组成分{一叁,四陆,22,65,三}举办排序
      • 波及数组排序,就要拓展成分值大小的比较,通过上海教室发现,大家想成功排序要经过多少次的比较才可以做到。
      • 上海体育场面中用每圈要比较的首先个因素与该因素后边的数组成分依次相比到数组的最终三个成分,把小的值放在第3个数组成分中,数组循环一圈后,则把最小成分值交换来了第一个要素中。
      • 数组再循环一圈后,把第二小的因素值调换成了第一个因素中。依据那种措施,数组循环多圈未来,就形成了数组成分的排序。那种排序情势我们称为接纳排序。

* b: 解题步骤
    * 使用for循环(外层循环),指定数组要循环的圈数(通过图解可知,数组循环的圈数为数组长度 - 1)
    * 在每一圈中,通过for循环(内层循环)完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素,把小的值放在第一个数组元素中
    * 在每一圈中,要参与比较的第一个元素由第几圈循环来决定。如上图所示
        * 进行第一圈元素比较时,要比较的第一个元素为数组第一个元素,即索引为0的元素
        * 进行第二圈元素比较时,要比较的第一个元素为数组第二个元素,即索引为1的元素
        * 依次类推,得出结论:进行第n圈元素比较时,要比较的第一个元素为数组第n个元素,即数组索引为n-1的元素

当str1 = str2时,函数值 = 0;

1二精选排序功效完成

A: 案例代码

        /*
          数组的排序: 一般都是升序排列,元素,小到大的排列

          两种排序的方式
             选择排序: 数组的每个元素都进行比较
             冒泡排序: 数组中相邻元素进行比较
             规则: 比较大小,位置交换
        */
        public class ArrayMethodTest_2{
            public static void main(String[] args){
                int[] arr  = {3,1,4,2,56,7,0};
                //调用选择排序方法
                //selectSort(arr);
                printArray(arr);
            }
            /*
                定义方法,实现数组的选择排序
                返回值: 没有
                参数:  数组
                实现步骤:
                  1.嵌套循环实现排序
                    外循环,控制的是一共比较了多少次
                    内循环,控制的是每次比较了多少个元素
                  2. 判断元素的大小值
                    小值,存储到小的索引
            */
            public static void selectSort(int[] arr){
                for(int i = 0 ; i < arr.length - 1; i++){
                    //内循环,是每次都在减少,修改变量的定义
                    for(int j = i+1 ; j < arr.length ; j++){
                        //数组的元素进行判断
                        if(arr[i] > arr[j]){
                            //数组的换位
                            int temp = arr[i];
                            arr[i] = arr[j];
                            arr[j] = temp; 
                        }
                    }
                }
            }

            /*
               定义方法,实现功能
               返回值: void
               方法参数: 数组
            */
            public static void printArray(int[] arr){
                //输出一半中括号,不要换行打印
                System.out.print("[");
                //数组进行遍历
                for(int i = 0 ; i < arr.length ; i++){
                    //判断遍历到的元素,是不是数组的最后一个元素
                    //如何判断 循环变量 到达 length-1
                    if( i == arr.length-1 ){
                        //输出数组的元素和]
                        System.out.print(arr[i]+"]");
                    }else{
                    //不是数组的最后一个元素,输出数组元素和逗号
                        System.out.print(arr[i]+",");
                    }
                }
                System.out.println();
            }
        }

当str1 < str2时,函数值 < 0;

壹三冒泡排序效率达成

  • A: 冒泡排序成效实现
    * a: 标题分析
    * 通过观看发现,本标题要完毕把数组成分{壹三,四六,2二,陆伍,3}进行排序
    *
    提到数组排序,就要开始展览成分值大小的可比,通过上海体育场面发现,大家想成功排序要通过若干次的可比才能够形成。
    *
    上海体育场所中相邻的元素值依次相比,把大的值放前边的成分中,数组循环一圈后,则把最大成分值调换成了最后贰个因素中。
    数组再循环壹圈后,把第1大的要素值沟通成了尾数首个成分中。根据那种格局,数组循环多圈以往,
    就实现了数组成分的排序。这种排序形式大家誉为冒泡排序。

  • b: 解题步骤
    *
    使用for循环(外层循环),钦赐数组要循环的圈数(通过图解可见,数组循环的圈数为数高管度 –
    一)
    *
    在每壹圈中,通过for循环(内层循环)完结相邻的成分值依次相比较,把大的值放后边的因素中
    * 每圈内层循环的次数,由第几圈循环来决定。如上海教室所示
    * 进行第2圈元素相比时,内层循环次数为数首席营业官度 – 壹
    * 进行第二圈成分相比较时,内层循环次数为数老总度 – 贰
    * 依次类推,得出结论:举办第n圈成分相比较时,内层循环次数为数高管度 –
    n

  • c: 案例代码

                /*
                  数组的排序: 一般都是升序排列,元素,小到大的排列
                                  两种排序的方式
                     选择排序: 数组的每个元素都进行比较
                     冒泡排序: 数组中相邻元素进行比较
                     规则: 比较大小,位置交换
                */
                public class ArrayMethodTest_2{
                    public static void main(String[] args){
                        int[] arr  = {3,1,4,2,56,7,0};
                        //调用选择排序方法
                        //selectSort(arr);
                                            //调用冒泡排序方法
                        bubbleSort(arr);
                        printArray(arr);
                    }
                    /*
                       定义方法,实现数组的冒泡排序
                       返回值: 没有
                        参数:  数组
                    */
                    public static void bubbleSort(int[] arr){
                        for(int i = 0 ; i < arr.length - 1; i++){
                            //每次内循环的比较,从0索引开始, 每次都在递减
                            for(int j = 0 ; j < arr.length-i-1; j++){
                                //比较的索引,是j和j+1
                                if(arr[j] > arr[j+1]){
                                    int temp = arr[j];
                                    arr[j] = arr[j+1];
                                    arr[j+1] = temp;
                                }
                            }
                        }
                    }
    
                    /*
                       定义方法,实现功能
                       返回值: void
                       方法参数: 数组
                    */
                    public static void printArray(int[] arr){
                        //输出一半中括号,不要换行打印
                        System.out.print("[");
                        //数组进行遍历
                        for(int i = 0 ; i < arr.length ; i++){
                            //判断遍历到的元素,是不是数组的最后一个元素
                            //如何判断 循环变量 到达 length-1
                            if( i == arr.length-1 ){
                                //输出数组的元素和]
                                System.out.print(arr[i]+"]");
                            }else{
                            //不是数组的最后一个元素,输出数组元素和逗号
                                System.out.print(arr[i]+",");
                            }
                        }
                        System.out.println();
                    }
                }
    

 
 ②因为put[i]是二个字符串指针,字符串指针指向贰个字符常量的地点,由printf()的函数原型可见那里不能够用*put[i],不然会出错。

1四数组的扣除查找原理

  • A: 数组的扣除查找原理(图解见day07_source/折半找寻原理.JPG)

  • a: 标题分析

    • 通过阅览发现,本标题要兑现查找钦定数值在要素有序的数组中贮存的地方(索引),再次回到该岗位(索引)。
    • 我们应用数组最中间地点的成分值与要物色的钦点数值举办相比较,若相等,重返中间成分值的目录
    • 最中间地点的成分值与要摸索的内定数值进行相比,若不对等,则依照比较的结果,裁减查询范围为上次数组查询范围的二分之一;
      再依照新的询问范围,更新最中间成分地方,然后使用当凉月素值与要寻找的钦定数值实行相比
       比较结实万分,重返中间成分值的目录

      相比较结实不对等,继续减弱查询范围为上次数组查询范围的拾贰分之5,更新最中间元素地方,继续比较,依次类推。
    • 当查问范围缩短到小于0个要素时,则钦点数值未有询问到,重返索引值-一。
  • b: 解题步骤

  • 概念1个用来记录索引值的变量,变量min记录当前限制最小索引值,起头值为0;变量max记录当前限定最大索引值,开首值为数老板度-一;变量mid记录当前当前范围最中间成分的索引值,开端值为(min+max)
    / 二

  • 利用循环,判断当前界定下,最中间成分值与钦赐查找的数值是不是等于
     若相等,停止循环,再次来到当前界定最中间成分的索引值mid
     若不对等,依据比较结实,裁减查询范围为上3次询问范围的一般
     中间成分值 比
    要询问的数值大,表明要查询的数值在近期限定的最小索引地点与中间索引地点之间,此时,更新查询范围为:
    限制最大索引值 = 上二回中间索引地点 -一;
     中间元素值 比
    要询问的数值小,说明要查询的数值在当前范围的最大索引地点与中间索引地点之间,此时,更新查询范围为:
    范围最小索引值 = 上二遍中间索引地点 +壹;

    在新的查询范围中,更新当兰秋素值的任务,再一次使用最中间成分值与钦赐查找的数值是还是不是等于。
    中间索引值 = (范围最小索引值 +范围最大索引值) / 2;

  • 老是查询范围裁减百分之五十后,使用if语句判断,查询范围是不是小于0个因素,若小于0个要素,则证实钦点数值未有查询到,重返索引值-一。

美高梅开户网址,总计:要显然字符串指针的法则,通过营造指针数组来进展字符串指针直接的逐一调换,套用1维数组的排序方法就足以开始展览字符串指针的排序,达到指标。

1五数组的扣除查找代码达成

  • A: 案例代码

        /*
           数组的查找功能
             在一个数组中,找一个元素,是否存在于数组中,如果存在,就返回索引

             普通查询:
               找到元素在数组中出现的索引,如果没有这个 元素,结果就是负数

        */
        public class ArrayMethodTest_3{
             public static void main(String[] args){
                 int[] arr = {1,3,5,7,9,11,15};
                 int index = binarySearch(arr,10);
                 System.out.println(index);

             }

             /*
                 定义方法,实现,折半查找
                 返回值: 索引
                 参数: 数组,被找的元素 
                 实现步骤:
                   1. 需要的变量定义
                      三个,三个指针

                   2. 进行循环折半
                      可以折半的条件  min <= max

                   3. 让被找元素,和中间索引元素进行比较
                       元素 > 中间索引  小指针= 中间+1
                       元素 < 中间索引  大指针= 中间-1
                       元素 == 中间索引  找到了,结束了,返回中间索引

                    4. 循环结束,无法折半
                      元素没有找到 ,返回-1
             */
             public static int binarySearch(int[] arr, int key){
                 //定义三个指针变量
                 int min = 0 ;
                 int max = arr.length -1 ;
                 int mid = 0;
                 //循环折半,条件 min<=max
                 while( min <= max){
                     //公式,计算中间索引
                     mid = (min+max)/2;
                     //让被找元素,和中间索引元素进行比较
                     if(key > arr[mid]){
                         min = mid + 1;
                     }else if (key < arr[mid]){
                         max = mid - 1;
                     }else{
                         //找到元素,返回元素索引
                         return mid;
                     }
                 }
                 return -1;
             }

            /*
               定义方法,实现数组的普通查询
               返回值: 索引
               参数:   数组, 被找的元素

               实现步骤:
                 1. 遍历数组
                 2. 遍历过程中,使用元素和数组中的元素进行比较
                    如果相同,返回元素在数组中的索引
                    如果不同,返回负数
            */
            public static int search(int[] arr, int key){
                //遍历数组
                for(int i = 0 ; i < arr.length ; i++){
                    //数组元素,被查找的元素比较
                    if(arr[i] == key){
                        //返回索引
                        return i;
                    }
                }
                return -1;
            }
        }

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图