当前位置:17727 > 17727.com > 17727.com选择法排序,选择排序

17727.com选择法排序,选择排序

文章作者:17727.com 上传时间:2019-12-10

从小到大的选择排序 是从一个数组中依次选出 最小数值 输出,第二小的数值输出,第三小的数值输出... ...直到最后一个数组中最后一个数遍历完成,则 整个排序输出完成。

 

选择法排序指每次选择所要排序的数组中的最大值(由小到大排序则选择最小值)的数组元素,将这个数组元素的值与最前面没有进行排序的数组元素的值互换。以数字9、6、15、4、2为例,采用选择法实现数字按从小到大进行排序,每次交换的顺序如图8.17所示。

 17727.com 1

图8.17  选择法排序示意图

从图8.17可以发现,在第一次排序过程中将第一个数字和最小的数字进行了位置互换;而第二次排序过程中,将第二个数字和剩下的数字中最小的数字进行了位置互换;依此类推,每次都将下一个数字和剩余的数字中最小的数字进行位置互换,直到将一组数字按从小到大排序。

下面通过实例来看一下如何通过程序使用选择法实现数组元素从小到大的排序。 

01奇数求和练习

  • A: 奇数求和练习

    • a: 题目分析

      • 为了记录累加和的值,我们需要定义一个存储累加和的变量
      • 我们要获取到1-100范围内的数
      • 判断当前数是否为奇数,是奇数,完成累加和操作
      • 累加完毕后,最终显示下累加和的值
    • b: 解题步骤

      • 定义一个用来记录累加和的变量
      • 使用for循环语句,Markdown Preview Enhanced: Toggle Scroll Sync完成1-100之间每个数的获取
      • 使用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);
            }
        }
    

PHP有很多关于数组的函数,方便数组操作。

 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 值
            }
实例 利用选择排序将学生成绩进行排序

在本实例中,声明了一个整型数组和两个整型变量,其中整型数组用于存储用户输入的数字,而整型变量用于存储数值最小的数组元素的数值和该元素的位置,然后通过双层循环进行选择法排序,最后将排好序的数组进行输出。具体代码如下:

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("%dt",a[i]);                /*输出制表位*/

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

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

39           }

40   

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

42  }

 

运行程序,显示结果如图8.18所示。

 17727.com 2

图8.18  选择排序运行图

从该实例代码和运行结果可以看出:

(1)声明一个整型数组a,并通过键盘为数组元素赋值。

(2)设置一个嵌套循环,第一层循环为前9个数组元素,并在每次循环时将对应当前次数的数组元素设置为最小值(如果当前是第3次循环,那么将数组中第3个元素(也就是下标为2的元素)设置为当前的最小值);在第二层循环中,循环比较该元素之后的各个数组元素,并将每次比较结果中较小的数设置为最小值,在第二层循环结束时,将最小值与开始时设置为最小值的数组元素进行互换。当所有循环都完成以后,就将数组元素按照从小到大的顺序重新排列了。

(3)循环输出数组中的元素,并在输出5个元素以后进行换行,在下一行输出后面的5个元素。

 

本文摘自明日科技出版的《零基础学C语言》,转载请注明出处!!!

02水仙花练习功能实现

  • A: 水仙花练习功能实现

    • a: 题目分析

      • 明确什么样的数就是水仙花数。水仙花数是指一个3位数(100-999之间),其每位数字立方之和等于该3位数本身。
        如153 = 111 + 333 + 555,即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方;
      • 获取水仙花范围内的所有3位数(100-999之间的每个3位数)
      • 判断该3位数是否满足水仙花数,满足,打印该3位数
    • b: 解题步骤

      • 使用for循环,得到100-999之间的每个3位数
      • 获取3位数中百位数字、十位数字、个位数字
      • 使用if条件语句,判断该3位数是否满足水仙花数,满足,使用输出语句,打印该3位数
    • 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);
                   }
               }
           }
       }           
    

数组每个实体包含两个项:key和value,可以通过查询键来获取其相应的值。这些键可以是数值键或关联键。数值键与值没有真正的联系,它们只是值在数组中的位置。

  

03ASCII编码表

  • A: ASCII编码表
    • a: 英文全称
      • American Standard Code for Information Interchange,美国标准信息交换代码
    • b: ASCII编码表由来
      • 计算机中,所有的数据在存储和运算时都要使用二进制数表示
      • a、b、c、d这样的52个字母(包括大写)、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示
      • 具体用哪些二进制数字表示哪个符号,当然每个人都可以约定自己的一套(这就叫编码)
      • 大家如果要想互相通信而不造成混乱,那么大家就必须使用相同的编码规则,于是美国有关的标准化组织就出台了ASCII编码,
        统一规定了上述常用符号用哪些二进制数来表示。
    • c: 中文编码表
      • GB2312
      • UNICODE
    • d: 字符中重要的ASCII码对应关系
      • a : 97
      • A : 65
      • 0 : 48

PHP提供了很多遍历数组的方法,无法使用关联键还是数值键,都依赖于一种称为数组指针的特性。

04char类型的存储

  • A: char类型的存储

    • a: 取值范围

      • short:占两个字节,是有符号数据,取值范围-32768-32767
      • char: 占两个字节,是无符号数据,取值范围0-65536
    • 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;
            }
        }   

创建数组

05输出所有英文字母

  • A: 输出所有英文字母

    • a: 题目分析

      • 一共26个大小写字母,那么,可以考虑循环26次。在每次循环中,完成指定字母的大小写打印
      • 找出ABCDEFG…XYZ这些字母之间的变化规律
        通过ASCII表发现,后面的字母比它前面的字母,ASCII值大1
        下一个字母 = 上一个字母 + 1
        如: 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++; //更新小写字母值
                }
            }
        }
        ```
    

PHP不需要在创建数组时指定其大小,因为PHP是一种松散的语言,所以不需要在使用数组前先行声明。尽管没有限制,PHP仍提供了正式和非正式的数组声明方法。

0699乘法表的分析

  • A: 99乘法表的分析

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

    • b: 题目分析
      通过观察发现,如果把11=1这样的内容 看做一颗的话,那么打印结果就成了如下效果:

      **




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

    • c: 解题步骤

      • 定义一个外层for循环,初始值从1开始,循环9次。用来控制打印的行数
      • 在外层for循环内部,定义一个for循环,初始值从1开始,循环次数与当前行数相等。用来完成每行打印指定次数的乘法公式 如1*1=1
      • 在内层for循环中,完成每行指定次数的乘法公式打印 如11=1
        System.out.print(k +"
        "+ j +"="+ j*k +"t");
        // 变量k代表:每行中的第n次
        // 变量j代表:行号
      • 在外循环中,当每行指定次数的乘法公式打印完毕后,通过System.out.println()切换到下一行。
        这样,再次打印乘法公式时,就在下一行输出打印了

引用PHP数组的各个元素,用一对中括号来指示。数组没有大小限制,所以只需建立引用就可以创建数组,例如:

0799乘法表的功能实现

  • A: 99乘法表的功能实现

    • 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();
                }
            }
        }
    
        ```
    
$state[0]= ‘111';$state[1]= ‘222';

08实现数组的遍历

  • A: 实现数组的遍历

    • a: 题目分析

      • 通过循环,我们可以完成数组中元素的获取,数组名[索引]
      • 观察发现,每个数组元素之间加入了一个逗号”,”进行分隔;并且,整个数组的前后有一对中括号”[]”包裹数组所有元素。
    • 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();
                }
            }
        ```
    

如果索引值是数值索引而且是递增的,还可以在创建时省略索引值。

09数组逆序原理

  • A: 数组逆序原理

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

    • 通过观察发现,本题目要实现原数组元素倒序存放操作。即原数组存储元素为{11,22,33,44},
      逆序后为原数组存储元素变为{44,33,22,11}。
    • 通过图解发现,想完成数组元素逆序,其实就是把数组中索引为start与end的元素进行互换。
    • 每次互换后,start索引位置后移,end索引位置前移,再进行互换
    • 直到start位置超越了end位置,互换结束,此时,数组元素逆序完成。
  • b: 解题步骤

    • 定义两个索引变量start值为0,变量end值为数组长度减去1(即数组最后一个元素索引)
    • 使用循环,完成数组索引start位置元素与end位置元素值互换。
    • 在循环换过程中,每次互换结束后,start位置后移1,end位置前移1
    • 在循环换过程中,最先判断start位置是否超越了end位置,若已超越,则跳出循环
$state[] =‘111';$state[] =‘222';

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;
                }
            }
        }

可以使用array()创建数组,如:

11选择排序原理

  • A: 选择排序原理
    • a: 题目分析(图解见day07_source/选择排序原理.JPG)
      • 通过观察发现,本题目要实现把数组元素{13,46,22,65,3}进行排序
      • 提到数组排序,就要进行元素值大小的比较,通过上图发现,我们想完成排序要经过若干次的比较才能够完成。
      • 上图中用每圈要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素,把小的值放在第一个数组元素中,数组循环一圈后,则把最小元素值互换到了第一个元素中。
      • 数组再循环一圈后,把第二小的元素值互换到了第二个元素中。按照这种方式,数组循环多圈以后,就完成了数组元素的排序。这种排序方式我们称为选择排序。
* b: 解题步骤
    * 使用for循环(外层循环),指定数组要循环的圈数(通过图解可知,数组循环的圈数为数组长度 - 1)
    * 在每一圈中,通过for循环(内层循环)完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素,把小的值放在第一个数组元素中
    * 在每一圈中,要参与比较的第一个元素由第几圈循环来决定。如上图所示
        * 进行第一圈元素比较时,要比较的第一个元素为数组第一个元素,即索引为0的元素
        * 进行第二圈元素比较时,要比较的第一个元素为数组第二个元素,即索引为1的元素
        * 依次类推,得出结论:进行第n圈元素比较时,要比较的第一个元素为数组第n个元素,即数组索引为n-1的元素
$state =array;$state =array(‘one'=>'111', ‘two'=>'222');

12选择排序功能实现

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();
            }
        }

使用list()提取数组,例如:

13冒泡排序功能实现

  • A: 冒泡排序功能实现
    * a: 题目分析
    * 通过观察发现,本题目要实现把数组元素{13,46,22,65,3}进行排序
    * 提到数组排序,就要进行元素值大小的比较,通过上图发现,我们想完成排序要经过若干次的比较才能够完成。
    * 上图中相邻的元素值依次比较,把大的值放后面的元素中,数组循环一圈后,则把最大元素值互换到了最后一个元素中。
    数组再循环一圈后,把第二大的元素值互换到了倒数第二个元素中。按照这种方式,数组循环多圈以后,
    就完成了数组元素的排序。这种排序方式我们称为冒泡排序。

  • b: 解题步骤
    * 使用for循环(外层循环),指定数组要循环的圈数(通过图解可知,数组循环的圈数为数组长度 - 1)
    * 在每一圈中,通过for循环(内层循环)完成相邻的元素值依次比较,把大的值放后面的元素中
    * 每圈内层循环的次数,由第几圈循环来决定。如上图所示
    * 进行第一圈元素比较时,内层循环次数为数组长度 - 1
    * 进行第二圈元素比较时,内层循环次数为数组长度 - 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();
                    }
                }
    
$state= array(‘one', ‘two', ‘three');list = $state;

14数组的折半查找原理

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

  • a: 题目分析

    • 通过观察发现,本题目要实现查找指定数值在元素有序的数组中存储的位置(索引),返回该位置(索引)。
    • 我们使用数组最中间位置的元素值与要查找的指定数值进行比较,若相等,返回中间元素值的索引
    • 最中间位置的元素值与要查找的指定数值进行比较,若不相等,则根据比较的结果,缩小查询范围为上次数组查询范围的一半;
      再根据新的查询范围,更新最中间元素位置,然后使用中间元素值与要查找的指定数值进行比较
       比较结果相等,返回中间元素值的索引
       比较结果不相等,继续缩小查询范围为上次数组查询范围的一半,更新最中间元素位置,继续比较,依次类推。
    • 当查询范围缩小到小于0个元素时,则指定数值没有查询到,返回索引值-1。
  • b: 解题步骤

  • 定义3个用来记录索引值的变量,变量min记录当前范围最小索引值,初始值为0;变量max记录当前范围最大索引值,初始值为数组长度-1;变量mid记录当前当前范围最中间元素的索引值,初始值为(min+max) / 2

  • 使用循环,判断当前范围下,最中间元素值与指定查找的数值是否相等
     若相等,结束循环,返回当前范围最中间元素的索引值mid
     若不相等,根据比较结果,缩小查询范围为上一次查询范围的一般
     中间元素值 比 要查询的数值大,说明要查询的数值在当前范围的最小索引位置与中间索引位置之间,此时,更新查询范围为:
    范围最大索引值 = 上一次中间索引位置 -1;
     中间元素值 比 要查询的数值小,说明要查询的数值在当前范围的最大索引位置与中间索引位置之间,此时,更新查询范围为:
    范围最小索引值 = 上一次中间索引位置 +1;
     在新的查询范围中,更新中间元素值的位置,再次使用最中间元素值与指定查找的数值是否相等。
    中间索引值 = (范围最小索引值 +范围最大索引值) / 2;

  • 每次查询范围缩小一半后,使用if语句判断,查询范围是否小于0个元素,若小于0个元素,则说明指定数值没有查询到,返回索引值-1。

数组内的三个值分别赋给了$one, $two,$three, 可直接输出。

15数组的折半查找代码实现

  • 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;
            }
        }

用预定义的值范围填充数组,例如:

$num= range;//类似于$num =array;可选择奇偶:$num =range;

//$num= array;可选择字母:$ch =range;//$ch= array(“A”, “B”, “C”, “D”, “E”, “F”);

输出数组

输出数组内容最常用的方法就是迭代处理各个数组键,并输出相应的值。

foreach()函数可以很方便的遍历一个数组,得到每个value和key。

print_r()函数很方便将数组的内容输出到屏幕上。prinf_r()函数接受一个变量,并将其内容发送给标准输出,成功时返回TRUE,否则返回FALSE。

测试数组

通过is_array()函数知道某个特定变量是否一个数组。

is_array()函数确定某变量是否为数组,如果是则返回TRUE,否则返回FALSE。即使数组只包含一个值,也将被认为是一个数组。

添加和删除数组元素

PHP为扩大和缩小数组提供了一些函数,对模仿各种队列实现提供便利。

array_unshift()函数在数组头添加元素。所有已有的数值键都会相应地修改,以反映其在数组中的新位置,但是关联键不受影响。

$state= array;array_unshift;//$state= array(‘00', ‘11', ‘22', ‘33');

array_push()函数将值添加到数组的末尾,添加新的值之后返回数组中的元素总数。同时通过将这个变量作为输入参数传递给此函数,向数组压入多个变量,其形式为:

$state= array;array_push;//$state= array;

从数组头删除元素:

array_shift()函数删除并返回数组中找到的第一个元素。其结果是,如果使用的是数值键,则所有相应的值都会下移,而使用关联键的数组不受影响,其形式为:

$state= array;array_shift;//$state= array;

array_pop()函数删除并返回数组的最后一个元素,其形式为:

$state= array;array_pop;//$state= array;

定位数组元素

搜索数组:

in_array()函数在数组中搜索一个特定值,如果找到这个值则返回TRUE,否则返回FALSE,其形式如下:

$user= array;$str= ‘111';if{echo‘yes';}else{echo ‘no';}

第三个参数strict可选,它强制in_array()在搜索时考虑类型。

如果在一个数组中找到一个指定的键,函数array_key_exists()返回TRUE,否则返回FALSE。其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');if(array_key_exists{echo'yes';}else{echo‘no';}

搜索关联数组:

array_search()函数在一个数组中搜索一个指定的值,如果找到则返回相应的值,否则返回FALSE,其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');if(array_search{echo'yes';}else{echo‘no';}

获取数组键:

array_key()函数返回一个数组,其中包含所搜索数组中找到的所有键,其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');$keys= array_keys;//array "one" [1]=> string "two" [2]=>string "three" }

array_values()函数返回一个数组中的所有值,并自动为返回的数组提供数组索引,其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');$values= array_values;var_dump {[0]=> string "1" [1]=> string "3" }

遍历数组

通常需要遍历数组并获得各个键或值,PHP提供了一些函数来满足需求。许多函数能完成两项任务,不仅能获取当前指针位置的键或值,还能将指针移向下一个适当的位置。

key()函数返回数组中当前指针所在位置的键,其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');$key= key;//string "one"

注意:每次调用key()时不会移动指针。

current()函数返回数组中当前指针所在位置的数组值。其形式如下:

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');$value= current;var_dump“1”

each()函数返回数组的当前键/值对,并将指针推进一个位置,其形式如下:

$arr =array('one'=>'1', 'two'=>'2', 'three'=>'3');var_dump;//array "1" ["value"]=> string "one" ["key"]=>string "one" }

返回的数组包含4个键,键0和key键包含键名,而键1和value包含相应的数据。如果执行each()前指针位于数组末尾,则返回FALSE。

移动数组指针:

1) 将指针移动到下一个数组位置

next()函数返回紧接着放在当前数组指针下一个位置的数组值,如果指针本来就位于数组的最后一个位置,则返回FALSE

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');echo next; //输出2echo next; //输出3

2) 将指针移动到前一个数组位置

prev()函数返回位于当前指针前一个位置的数组值,如果指针本来就位于数组的第一个位置,则返回FALSE

3) 将指针移动到第一个数组位置

reset()函数用于将数组指针设置回数组的开始位置,如果需要在脚本中多次查看或处理一个数组,经常使用这个函数,另外这个函数还经常在排序结束时使用。

4) 将指针移动到最后一个数组位置

end()函数将指针移动到数组的最后一个位置,并返回最后一个元素。

array_walk()函数将数组中的各个元素传递到用户自定义函数。如果需要对各个数组元素完成某个特定动作,这个函数将起作用。其形式如下:

functiontest{echo$value.' '.$key."";}$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');array_walk;//1 one//2 two//3 three

如果使用多维数组,PHP5中引入的array_walk_recursive()函数可以递归地对数组中的每一个元素应用一个用户定义函数。

确定数组大小和元素唯一性

count()函数返回数组中值的总数

如果启动了可选的mode参数,数组将进行递归计数统计元素。count;

注意:sizeof的别名。功能一致。

统计数组元素出现的频率:

array_count_values()函数返回一个包含关联键/值对的数组,其形式如下:

$arr= array;$res= array_count_values;//Array( [A] => 2 [B] => 1 [C] => 1 )

array_unique()函数会删除数组中所有重复的值,返回一个由唯一值组成的数组,其形式如下:

$arr= array;$res= array_unique;//Array( [0] => A [1] => B [2] => C )

可选参数sort_flags可以确定如何对数组键排序。默认地,值会被作为字符串排序,不过也可以按数值对值排序,或使用PHP默认的排序方法,还可以根据本地化环境排序。

逆置数组元素排序:

array_reverse()函数将数组中元素的顺序逆置,其形式如下:

$arr= array;$res= array_reverse;//Array( [0] => C [1] => B [2] => A )

如果可选参数preserve_keys设置为TRUE,则保持键映射,否则重新摆放后的各个值将对应于先前该位置上的相应键。

$arr= array;$res= array_reverse;print_r;//Array( [2] => C [1] => B [0] => A )

array_flip()函数将置换数组中键及其相应值的角色,其形式如下:

$arr= array;$res= array_flip;//Array( [A] => 0 [B] => 1 [C] => 2 )

数组排序:

sort()函数对数组进行排序,各元素按值由低到高的顺序排列,其形式如下:

sort()函数不返回排序后的数组,相反它只是“就地”对数组排序,不论结果如何都不返回任何值。sort_flags参数可选,将根据这个参数指定的值修改该函数的默认行为。

1) SORT_NUMERIC,按数值排序。对整数和浮点数排序很有用。

2) SORT_REGULAR,按照相应的ASCII值对元素排序。

3) SORT_STRING,按接近于人所认知的正确顺序对元素排序。

要保持初始键/值对应条件下的数组排序需要用到asort函数与sort()函数相同,以升序对数组排序,只不过它将保持键/值的关联,其形式如下:

$arr= array;$res= $arr;print_r;print_r;print_r;//Array ( [0]=> C [1] => B [2] => A ) Array ( [0] => A [1] => B [2] => C )Array ( [2] => A [1] => B [0] => C )

以逆序对数组排序

rsort函数相同,只不过它以相反的顺序对数组元素排序。

如果使用可选的sort_flags参数,具体的排序行为将由这个值确定。

保持键/值对的条件下以逆序对数组排序

与asort函数会保持键/值的关联,但是它以逆序对数组up

$arr= array;arsort;//Array( [3] => D [0] => C [1] => B [2] => A )

如果使用可选的sort_flags参数,具体的排序行为将由这个值确定。

natsort()函数提供了一种相当于人们平常使用的排序机制。

p1.jpg,p10.jpg, p2.jpg, p20.jpg

使用natsort()函数如下:

p1.jpg,p2.jpg, p10.jpg, p20.jpg

不区分大小写的自然排序

Picture1.jpg,PICTURE10.jpg, picture2.jpg, picture20.jpg

ksort()函数按键对数组排序,如果成功则返回TRUE,失败将返回FALSE

krsort相同,也按键排序,将以逆序排序。

根据用户自定义规则排序

usort()函数提供了另一种排序方法,可以使用在该函数中指定的用户自定义比较算法对数组排序。如果需要以某种方法对数据排序,而PHP的任何内置排序函数没有提供相应支持,就需要该函数。

数组合并、拆分、接合和分解

合并数组

array_merge()函数将数组合并到一起,返回一个联合的数组。所得到的数组以第一个输入数组参数开始,按后面数组参数出现的顺序依次追加。其形式如下:

$arr= array;$arr1= array;$arr2= array_merge;print_r;//Array( [0] => C [1] => B [2] => A [3] => D [4] => 1 [5] => 2 [6]=> 3 [7] => 4 )

递归追加数组

array_merge_recursive相同,可以将两个或多个数组合并到一起,形成一个联合的数组。两者之间的区别在于,当某个输入数组中的某个键已经存在于结果数组中时该函数会采取不同的处理方法。array_merge()会覆盖前面存在的键/值对,将其替换为当前输入数组中的键/值对,而array_merge_recursive()将两个值合并在一起,形成一个新的数组并以原有的键作为数组名。其形式为:

$arr= array('one'=>'C', 'one'=>'B');$arr1= array('three'=>'1', 'one'=>'2');$arr2= array_merge_recursive;print_r;//Array( [one] => Array  [three] => 1 )

合并两个数组

array_combine()函数会生成一个新数组,这个数组由一组提交的键和对应的值组成,其形式为:

$arr= array;$arr1= array;$arr2= array_combine;print_r;//Array

拆分数组

array_slice()函数将返回数组中的一部分,从键offset开始,到offset+length位置结束。

offset为正值时,拆分将从距数组开头的offset位置开始;如果offset为负值,则拆分从距数组末尾的offset位置开始。如果省略了可选参数length,则拆分将从offset开始,一直到数组的最后一个元素。如果给出了length且为正数,则会在距数组开头的offset+length位置结束。相反,如果给出了length且为负数,则在距数组开头的count

  • |length|位置结束。其形式如下:

    $arr= array;$arr1= array_slice;print_r;//Array

array_intersect()函数返回一个保留了键的数组,这个数组只由第一个数组中出现的且在其他每个输入数组中都出现的值组成。其形式如下:

$arr= array;$arr1= array;$arr2= array;$arr3= array_intersect;print_r;//Array

注意:只有在两个元素有相同的数据类型时,array_intersect()才会认为它们相等。

array_intersect_assoc基本相同,只不过它在比较中还考虑了数组的键。因此,只有在第一个数组中出现,且在所有其他输入数组中也出现的键/值对才被返回到结果数组中。其形式如下:

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');$arr1= array('a'=>'A', 'c'=>'B', 'E');$arr2= array('a'=>'A', 'b'=>'F', 'd'=>'B');$arr3= array_intersect_assoc;print_r;//Array

求关联数组的差集

函数array_diff_assoc基本相同,只是它在比较时还考虑了数组的键,因此,只在第一个数组中出现而不在其他输入数组中出现的键/值对才会被返回到结果数组中。其形式如下:

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');$arr1= array('a'=>'A', 'b'=>'B', 'e'=>'E');$arr3= array_diff_assoc;print_r;//Array

array_rand()函数将返回数组中的一个或多个键。其形式为:

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');$arr1= array_rand;print_r;//Array

shuffle()函数随机地对数组元素重新排序。

array_sum()函数将数组内的所有值加在一起,返回最终的和,其形式如下:

$arr= array;$count= array_sum;//44

如果数组中包含其他数据类型,这些值将被忽略。

划分数组

array_chunk()函数将数组分解为一个多维数组,这个多维数组由多个包含size个元素的数组所组成。其形式如下:

$arr= array;$arr1= array_chunk;print_r;//Array( [0] => Array  [1] => Array 

本文由17727发布于17727.com,转载请注明出处:17727.com选择法排序,选择排序

关键词: