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

时间: 2024-08-05 11:32:33

9.19 数组 冒泡排序和二分法的相关文章

js 排序:sort()方法、冒泡排序、二分法排序。

js中的排序,这里介绍三种,sort()方法.冒泡排序.二分法排序. 1.sort方法 写法:  数组.sort(); 返回排好序的数组,如果数组里是数字,则由小到大,如果是字符串,就按照第一个字符的字符编码大小排序. 写法2: 数组.sort(function(a,b){ return a-b }); 表示从大到小,(如果写 retrun b-a 则由大到小排序): 不详细解释了. 2.冒泡排序. 原理是,直接将原理可能不好懂,我们还是按照下面的方法去讲吧,这样容易懂些. //冒泡排序func

数组冒泡排序,文件读取,数据库读取,string类型的int数组转换成int数组

排序方式(枚举) 1 public enum SortBy 2 { 3 Asc, 4 Desc 5 } 数组冒泡排序方法 1 public class SortEntity 2 { 3 public static int[] SortArray(int[] array,SortBy sortby) 4 { 5 int flag; 6 switch (sortby) 7 { 8 case SortBy.Asc: 9 for (int i = 0; i < array.Length - 1; i++

数组 冒泡排序 打印菱形 随机生成不同的数

判断一个数是否是质数  对这个数从1到这个数挨着取余 如果取余等于零则计数+1,所以当计数=2是  那么说明这个数只能被一和它本身整除 所以它是质数 打印菱形  每一行首先打印空格  然后打印符号 先打印上半部分 然后下半部分 这时候中间两行出现重复 那么需要去掉一行 数组 冒泡排序 首先定义数组 利用for循环把值输入到数组里边 后利用两个for循环 把数组里的数挨个比较 排序 如果a[i]<a[i+i] 然后进行交换 那么是降序输出 如果a[i]>a[i+1] 然后交换了  那么是升序排列

深度剖析数组冒泡排序

<?php /* *@Category  数组冒泡排序类 *@param array_arsort 类中操作方法 *@author yalong sun */ //从大到小排序 class array_maopao{ public function array_arsort($array){ $ary = ''; for($j=0;$j<count($array);$j++){           //其实就是循环的次数 for($i=0;$i<count($array)-1;$i++)

从数组冒泡排序迁移到链表冒泡排序

链表是一种常见的数据结构,在启发式搜索中我们常常需要把无序的链表,按照结点包含的元素数量从小到大排列整齐.面对链表排序问题,尤其是在链表节点是一张巨大的表的情况下,传统的交换法显得力不从心,而通过修改指针指向来使链表逻辑序列有序化是主要的解决途径. 如何对链表进行排序,可以借鉴我们所熟知的数组冒泡的思想.在数组冒泡中我们通过交换与移动两种操作把最值向后移动,在不同趟的排序中我们只需要维护一个变动的尾部.链表的冒泡思路与数组的冒泡是一致的,只不过具体的操作上有些不同,无论是交换还是移动操作,链表都

C语言:“冒泡排序”与“二分法”

1.冒泡排序: what:将元素进行两两比较,大的(小的)向后排. when:数组中有多个元素,需要进行比较排序比较的时候使用. how:N个数字来排队,两两比较小靠前.(升序) 外层循环:N-1(控制比较的轮数) 内层循环:N-1-i(控制每轮比较的的次数,i代表外层循环变量) for example: int num[5];int i,k,j,temp;for(i=0;i<5;i++){printf("请输入5个元素\n");scanf("%d",&

9.19数组以及经典案例

数组:相同类型数据的集合(此解释适于强类型语言) 强类型语言中:1.数组里面只能存放相同数据类型的数据. 2.定义数组的时候需要制定一个长度(可以存放的元素数量). 3.内存空间连续. 集合中:1.可以存放任意类型的数据. 2.定义时不需要制定长度. 3.内存空间不连续. JS中:1.可以存放任意类型数据. 2.定义时不需要制定长度. 定义数组:var attr = array(); 索引:开始为0 alert(attr[]); var attr=[1,3.14,"aa"]    使用

冒泡排序与二分法

var attr=[1,8,6,4,5,3,7,2,9]   //对数组进行排序,冒泡排序 //两个相邻的元素进行比较,满足条件互换//进行比较的轮数是数组的长度-1//控制比较的轮数 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[

冒泡排序 与二分法

<script type="text/javascript"> //var attr = [1,8,26,4,15,3,7,42,9]; //对数组元素进行排序//冒泡排序/*8 6 4 5 3 7 2 9 1 88 6 5 4 7 3 9 2 1 7 8 6 5 7 4 9 3 2 1 68 6 7 5 9 4 3 2 1 5 8 7 6 9 5 4 3 2 1 48 7 9 6 5 4 3 2 1 38 9 7 6 5 4 3 2 1 29 8 7 6 5 4 3 2