数组

一、冒泡排列

      对数组attr = [1,8,6,4,5,3,7,2,9]进行由大到小排列，用冒泡排列的方法排列时，会对数组进行比较互换。如果前一个数字较大，这2个元素排列方式不变，如果后一个元素较大，则这2个元素互换位置。对比互换方式如下：

                                       第一次  [8,6,4,5,3,7,2,9,1]

                                       第二次  [8,6,4,5,3,7,9,2,1]

                                       第三次  [8,6,5,4,7,9,3,2,1]

                                       第四次  [8,6,5,7,9,4,3,2,1]

　　　　　　　　　　　　　　第五次  [8,6,7,9,5,4,3,2,1]

　　　　　　　　　　　　　　第六次  [8,7,9,6,5,4,3,2,1]

　　　　　　　　　　　　　　第七次  [8,9,7,6,5,4,3,2,1]

　　　　　　　　　　　　　　第八次  [9,8,7,6,5,4,3,2,1] 

    此数组的长度为9，元素进行了8此对比互换以后完成了数组由大到小的排列，排列的次数是attr.length-1。数组attr = [1,8,6,4,5,3,7,2,9]冒泡排列的代码如下：

                           var attr = [1,8,6,4,5,3,7,2,9];              要进行冒泡排列的数组

                           var zj = 0;                                          定义一个交换使用的中间变量  

                            for(var i = 0;i<attr.length-1;i++)         控制比较的轮数
                            {
                             for(var j = 0;j<attr.length-1-i;j++)     控制每轮比较的次数
                                   {
                                         (attr[j]<attr[j+1])                 如果下一个元素大于当前元素
                                         {
                                               zj = attr[j];                     把attr[j]的值给zj
                                               attr[j] = attr[j+1];           把attr[j+1]的值给attr[j]
                                                attr[j+1] = zj;                把zj的值再给attr[j+1]

                                           }
                                    }
                            }

                            alert(attr[0]);         输出索引对应的元素的值，alert(attr[0]);输出的元素就是9。

      但是上面的元素排列的代码存在一个缺点就是每次比较都会对所有的元素进行比较，而实际上不需要每次都比较所有的元素，比如第七次  [8,9,7,6,5,4,3,2,1]，只需要比较前两个元素就可以了，后面的元素已经是由大到小排列了，就没有必要再比较了。由上面的数组比较互换方式上可以看出，第一次需要比较8次，第二次需要比较7此，知道第七次需要比较2次，第8次只需要比较1次。第i次比较的次数j正好是attr.length-1-i，所以上面代码只需要改变j的值，第i轮比较的次数为for(var j = 0;j<attr.length-1-i;j++)。这样就减少了很多的计算量。

      对数组排列除了上面的冒泡排列法以外，还有一种是

                                                             attr.sort（）；

                                                             alert(attr[0]);

      但是此种排列方法在JS中不可以用，因为这种方法只排列数字的第一位。在别的语言里可尝试使用。

二、在数组里面查找数据

      查找用户给定的数的索引（出现在第几个位置）。如果没有，输出一个提示，如果有，输出该元素的索引。

                             var attr = [1,2,3,4,5,6,7,8,9];          数组
                             var v = 6;                                      要查找的值
                             var sy = -1;                                   先把索引定义成一个负数
                             for(var i =0;i<attr.length;i++)          控制查找的次数
                             {
                                  if(attr[i]==v)                             条件判断
　　　　　　　　　　　　{
　　　　　　　　　　　　　　sy = i;                                 如果找到目标值，把i的值给sy
　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　 if(sy == -1)                              如果没找到目标值
 　　　　　　　　　　　　 {
　　　　　　　　　　　　　    alert("没有找到数据");             就输出“没有找到数据”
　　　　　　　　　　　　  }
　　　　　　　　　　　　　else                                         如果找到目标值
　　　　　　　　　　　alert("该元素在数组里的引为: "+sy);    输出该目标元素的索引值

      这种查找数据的方法运算量比较大，要把数组里面的每个元素都拿出来比较，知道找到目标元素。有一种可以减少运算量的方法叫做二分法，也可以查找数据，运算量也大大减少，提高运算效率。

     二分法的原理就是把所有的元素分成2半。比如attr = [1,2,3,4,5,6,7,8,9];这组数组，最小的索引是0，最大的索引是8。把最大和最小索引取个平均值，索引是4，分成的2组数组就是0-4和5-8。看中间的索引，对应的元素是5，而目标值是6>5,索引0-4的数组就不需要考虑了，值考虑索引为5-8的数组。再取索引为5-8的平均值为6（取整数），数组的索引又分成了5-6和7-8。索引6对应的元素是7，目标值是6<7，所以索引7-8的数组就不需要考虑了。以此类推逐步减小目标值的范围，找出目标值的索引。二分法具体的代码如下：

                        var attr = [1,2,3,4,5,6,7,8,9];                数组
                        var v = 6;                                            要查找的值

                        var minsy = 0;                                     最小索引
                        var maxsy = attr.length-1;                    最大索引
                        var midsy;                                           中间索引
                        while(true)
                        {
                              midsy = parseInt((minsy+maxsy)/2) 计算中间索引，有可能出现小数，要

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  把中间索引转成整数。
　　　　　　　　　　{
                                    if(attr[midsy] == v)                   比较中间值和用户给定的值
                                    {
                                            break;
                                    }
                                     if(midsy = minsy)                     只剩2个值的情况下；例如只剩下7和8，求

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  平均数以后是7，结果还是剩下7和8。            
                                     {          

                                          if（attr[midsy]==v）            如果大的索引对应的元素和目标元素相等

                                          {

                                                 midsy = midsy+1;        中间索引+1后输出索引  
                                                 break;                         终止循环

                                          }

                                          else                                    如果大的索引对应的元素和目标元素不相等

                                          {

                                                 midsy = -1;                 给中间索引赋值-1，意思就是数组

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  里面没有目标元素。

                                                 break;                         终止循环

                                          }
                                      }
                                        if(attr[midsy]>v)                   如果中间索引对应的值>给定值，目标值

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  在索引小的那一半里面。
                                        {
                                              maxsy = midsy;              把中间索引值变成最大值
                                        }
                                        else                                     中间索引对应的值<给定值，目标值

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  在索引大的那一半里面。
                                        {
                                                minsy == midsy;
                                        }
                                }
                          }

                                         alert(midsy);

9.19数组