数组,冒泡排序

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<script>

    //求一组数中的所有数的和 和平均值
/*    var arr = [10,20,30,10];
    var len = arr.length;
    var sum = arr[0];
    var avg;
    for(var i =1;i<len;i++){
        sum += arr[i];
    }
    avg = sum/len;
    console.log(sum+"/"+len);
    console.log(avg);*/
/*    var arr = [11,2,31,1,4,134,1,41,42,131,434];
    var sum = arr[0];//获取到数组第一个索引的值
    var avg;
    for(var i=1;i<arr.length;i++){//因数组中第一个值已被取出 所以直接从索引为1开始 因此i=1;
        sum += arr[i];//求数组中元素的和
    }
    avg = sum/arr.length;//除以数组的长度 求取平均值
    console.log(sum+"/"+arr.length);
    console.log(avg);*/
    //求一组数中的最大值和最小值,以及所在位置
 /*   var arr = [1,2,4,5,6];
    var max = arr[0];//先取出索引为0的值 之后用于与后面的值比较
    var maxIndex = 0;//因max 赋值为索引为0的值 索引定义最大值得变量开始值也为0
    var min = arr[0];//先取出索引为0的值 之后用于与后面的值比较
    var minIndex = 0;//因min 赋值为索引为0的值 索引定义最大值得变量开始值也为0
    for(var i =0;i<arr.length;i++){//因数组第一个值已被取出  所以从1开始
        //(最大值)判断当max值小于arr[i]时,将arr[i]赋值给max 索引值等于i
        if(max<arr[i]){
            max = arr[i];
            maxIndex = i;
        }
        //(最小值)
        if(min>arr[i]){
            min = arr[i];
            minIndex = i;
        }

    }
   /!* console.log("最大值"+max);
    console.log("最大值索引"+maxIndex);
    console.log(‘最小值‘+min);
    console.log(‘最小值索引‘+minIndex);
*!/
    console.log("最大值"+max);
    console.log("最大值索引"+maxIndex);
    console.log("最小值"+min);
    console.log("最小值索引"+minIndex);*/
    //将字符串数组用|或其他符号分割
/*    var arr = ["流水","蜻蜓","浮云"];
    var str = arr[0];
    var part = ‘|‘;
    for(var i =1;i<arr.length;i++){
        str+=part+arr[i];
    }
    console.log(str);*/
/*    var arr = [‘数‘,‘时刻是经典款‘,‘随便‘];
    var str = arr[0];
    var part = ‘?‘;
    for(var i =1;i<arr.length;i++){
        str += part + arr[i];
    }
    console.log(str);*/
    //将数组中值为0的去掉,不为0的存入新数组
/*    var arr =  ["我的",0,0,0,"他的",1,2,3,0,"谁的"];
  /!*  alert(arr);
    alert(arr.length);*!/
    var newArr = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i]!=0){
            newArr[newArr.length] = arr[i];
        }
    }
    console.log(newArr);*/
/*    var arr =  ["我的",0,0,0,"他的",1,2,3,0,"谁的"];
    var newArr = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i]!=0){
            newArr[newArr.length] = arr[i];
        }
    }
    console.log(newArr);*/
    /*
    var arr = [1,2,4,23,4,9,5,8,3,0,39,0];
    var newArr = [];
    for(var i =0;i<arr.length;i++){
        if(arr[i]!=0){
            newArr[newArr.length] = arr[i];
        }
    }
    console.log(newArr);*/
    //翻转数组
/*    var arr = [1,2,4,23,4,9,5,8,3,0,39,0];
    console.log(arr);
    var newArr = [];
    for(var i = arr.length-1;i>=0;i--){
        newArr[newArr.length] = arr[i];
    }
    console.log(newArr);*/
    //冒泡排序,从小到大
  /*  var arr = [1,2,4,23,4,9,5,8,3,0,39,0];
    console.log(arr);
    var m = 0;
    var n = 0;
    //比较的轮数
    for(var i=0;i<arr.length-1;i++){
        //控制比较结束之后直接跳轮数的开关
        var onOff = true;
        //比较的次数循环,且每轮循环之后都会有元素不再比较所以减i
        for(var j =0;j<arr.length-1-i;j++){
           //判断什么时候进行位置调换
            if(arr[j]>arr[j+1]){
                var temp = arr[j];//将上一个变量存起来
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    //默认执行继续
                    onOff = false;
            }
            n++;
        }
        m++;
        if(onOff){
            break;
        }
    }
    console.log(arr);*/
    var arr = [1,2,345,3,25,56,77,89,990,0];//定义一个数组
    console.log(arr);
    var m = 0;//比较次数的轮数
    var n = 0;//比较的次数
    //第一次循环控制比较次的轮数
    for(var i =0;i<arr.length-1;i++){
        //定义一个开关 控制比较次数的判断不再执行时跳数比较循环
        var onOff = true;
        //定义比较次数的循环
        for(var j=0;j<arr.length-1-i;j++){
            //判断什么时候进行位置互换
            if(arr[j]<arr[j+1]){
                var temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    //开关为false 比较继续
                    onOff = false;
            }
            n++;//比较次数自增
        }
        m++;//比较轮数自增
        if(onOff){
            break;
        }
    }
    console.log("轮数"+m);
    console.log("次数"+n);
    console.log(arr);

</script>
</body>
</html>
时间: 2024-08-05 11:15:09

数组,冒泡排序的相关文章

数组冒泡排序,文件读取,数据库读取,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++)

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

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

js数组冒泡排序,快速排序的原理以及实现

实习了好久,大概用了半年ng2了吧,突然被同事问到js排序问题,一时竟有些懵逼,回来就温故一下,希望自己不忘初心,加油加油! 冒泡排序: 随便从数组中拿一位数和后一位比较,如果是想从小到大排序,那么就把小的那一位放到前面,大的放在后面,简单来说就是交换它们的位置,如此反复的交换位置就可以得到排序的效果. function sortA(arr){ for(var i=0;i<arr.length-1;i++){ for(var j=i+1;j<arr.length;j++){ //获取第一个值和

数组---冒泡排序

所谓数组,就是相同数据类型的元素按一定的顺序排列的集合,就是把有限个数据类型相同的变量用一个名字命名,然后用编号区分她们的变量的集合,这个名称就叫数组名,编号称为下标. 组成数组的各个变量称为数组的分量或元素. 数组中元素的索引是从0开始的,也就是a[0],a[1]....... 引用一下:冒泡排序 冒泡排序算法的运作如下: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重

数组冒泡排序、选择排序、二分查找法

1 数组高级冒泡排序原理图解[掌握] 画图演示 需求: 数组元素:{24, 69, 80, 57, 13} 请对数组元素进行排序. 冒泡排序 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处 2 数组高级冒泡排序代码实现[掌握] 案例演示 数组高级冒泡排序代码 package com.heima.array; public class Demo1_Array { public static void main(String[] args) { int[] arr = {24,

2015.12.08 数组 冒泡排序

昨天学到的函数,在C语言中是这么叫,而在OC和swift中叫做“方法”. 数组 数组不像是“char”.“int”.“float”之类的类型保存单个数据,数组是用来保存多个相同类型的数据的. 在定义数组的时候,必须要确定数组的元素个数! 例://定义一个数组,拥有5个元素,默然每个元素的值为0 int numsArray[5];   //5 * 4 = 20 //定义一个数组,拥有4个元素,依次是1, 2, 3, 4 int numsArray[] = {1, 2, 3, 4};   //4 *

js面试常考之数组冒泡排序

js的数组排序 给出一个无需的数字数组,让写冒泡排序: 解析:冒泡排序是指由第一项数与第二项的数相比较,第一项大的话两者互换位置,若第二项大的话就位置不变: 在接着比较第二第三项,比较结果重复上一个步骤:(内for循环)   第一次比较完后在从第二项开始在按上一环节比较:(外for循环) 只到循环完最后第二项为止: 举例数组 arr = [3,56,4,1,34,78,23,59,66,42]; //冒泡排序 function arrSort(arr){ var len = arr.length

数组 -自动遍历数组-冒泡排序

数组:定义一组同类型的指定个数的变量索引从0开始 int[] name=new int[n]; ------------------------------------------------------ 自动遍历数组: foreach (int a in shu) { console.writeline(a); } 上式相当于: for( int i=0;i<shu.length;i++) { int a; a=shu[i]; console.writeline(a); } ---------