首页 > 代码库 > 9.19 数组 冒泡排序和二分法

9.19 数组 冒泡排序和二分法

数组:相同类型数据的集合

强类型语言:1,数组里面只能存放相同数据类型的数据。

            2,定义数组时需要定一个长度(可以存放元素的数量)

集合:1,可以存放任意类型的数据,

      2,定义时候不需要制定长度

      3,内存空间不连续

 

JS

数组:1,可以存放任何类型的数据。

      2,定义时候不需要制定长度

 

定义一个数组 var  attr = array(1,3.14,”aa”);  数组里面数据排列顺序是0  1  2  3  4…

                                        中间每个数据用逗号分割,

            Var   attr= attr(5);

        Var  attr=[1,3.14,”aa”] 直接用方括号来定义  输出的时候

                                 Alert(attr[2]);

 

属性 

length  就是数组长度,

Alert(attr.length);  输出数组长度,

Push   追加元素

Attr.push(“bb”); 就是将bb添加到attr数集里面,

 

数组  遍历

for(var i=0;i<attr.length;i++)

{

       alert(attr[i]);

}

 

foreach(  )方式遍历  a是索引。

for(var a in attr)

{

       alert(attr[a]);

}

 

例子

10个分数,求总分,最高分,最低分

var attr =[89,80,76,49,90,25,85,76,59,40];

 

var sum = 0;

for(var i=0;i<attr.length;i++)

{

       sum += attr[i];

}

 

alert(sum);成绩总和

 

var zg = 0;

for(var i=0;i<attr.length;i++)

{

       if(attr[i]>zg)

       {

              zg = attr[i];

       }    

}

alert(zg);最高成绩

 

var zd = zg;

for(var i=0;i<attr.length;i++)

{

       if(attr[i]<zd)

       {

              zd = attr[i];

       }

}

alert(zd); 最低成绩。

 

添加去重

var attr = [2,5,10,16,27];

var sj = 27;

var cf = true;

for(var i=0; i<attr.length;i++)

{

       if(sj == attr[i])

       {

              cf = false;

              break;

       }

}

if(cf)

{

       attr.push(sj);

       alert(attr.length);

}

else

{

       alert("有重复值");

}

var attr = [1,8,26,4,15,3,7,42,9];

 

对数组元素进行排序

冒泡排序

8 6 4 5 3 7 2 9 1     8

8 6 5 4 7 3 9 2 1     7

8 6 5 7 4 9 3 2 1     6

8 6 7 5 9 4 3 2 1     5

8 7 6 9 5 4 3 2 1     4

8 7 9 6 5 4 3 2 1     3

8 9 7 6 5 4 3 2 1     2

9 8 7 6 5 4 3 2 1     1 

 

两个相邻的元素进行比较,满足条件元素互换

进行比较的轮数是数组的长度减一

 

定义一个交换使用的中间变量

var zj = 0;

 

控制比较的轮数

for(var i=0;i<attr.length-1;i++)

{

       控制每轮比较的次数

       for(var j=0;j<attr.length-1-i;j++)

       {

              如果下一个元素大于当前元素

              if(attr[j]<attr[j+1])

              {

                     zj = attr[j];  互换

                     attr[j] = attr[j+1];

                     attr[j+1] = zj;

                    

              }

       }

}

 

alert(attr[0]);

 

attr.sort();

 

alert(attr[3]);

 

 

在数组里面查找数据

var attr = [1,2,3,4,5,6,7,8,9];

 

要查找的值

var v = 0;

 

 

循环遍历的方式

var sy = -1;

for(var i=0;i<attr.length;i++)

{

       if(attr[i]==v)

       {

              sy = i;

       }

}

 

if(sy == -1)

{

       alert("没找到数据");

}

else

{

       alert("该数据在数组里面的索引为:"+sy);

}

 

二分法查找数据

 

最小索引

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)

       {

              判断两个数据中的另外一个是否等于用户查找的值

              if(attr[midsy+1]==v)

              {

                     找到了值,退出循环

                     midsy = midsy+1;

                     break;

              }

              else

              {

                     没有找到值,退出循环

                     midsy = -1;

                     break;

              }

       }

       用来改范围

       if(attr[midsy]>v)

       {

              maxsy = midsy;

       }

       else

       {

              minsy = midsy;

       }

}

alert(midsy);

9.19 数组 冒泡排序和二分法