JS 冒泡排序从学到优化

目的:理解算法 深化算法

冒泡排序:

直接上动图好于文字

一个冒泡实例

45,67,23,88,21,6,99
// 第一轮 6次
// 45 67 23 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 21 88 6 99
// 45 23 67 21 6 88 99
// 45 23 67 21 6 88 99

// 第二轮 6次
// 23 45 67 21 6 88 99
// 23 45 67 21 6 88 99
// 23 45 21 67 6 88 99
// 23 45 21 6 67 88 99
// 23 45 21 6 67 88 99
// 23 45 21 6 67 88 99

// 第三轮 6次
// 23 45 21 6 67 88 99
// 23 21 45 6 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99

// 第四轮 6次
// 21 23 6 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99

// 第五轮 6次
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99

上代码(基础型)

 1 冒泡排序(双重for循环 第一个for控制轮数 第二个for控制次数 比较的轮数为数据个数-1 比较的次数为数据个数-1)
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>Document</title>
 7     <script>
 8         var a=[45,67,23,88,21,6,99];
 9         var temp=[];
10         var m=0;//轮数
11         var n=0;//一共次数
12         for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
13             for(var j=0;j<a.length-1;j++){
14                 if(a[j]>a[j+1]){//后面的大于前面的 后面再前  前面在后 从小到大
15                     temp=a[j];//a[j]=temp;
16                     a[j]=a[j+1];//a[j+1]=a[j];
17                     a[j+1]=temp;//a[j+1]=temp
18                 //顺序不能调换 因为a[]里面有个下标是一定从小到大的
19                 }
20                 n++
21             }
22             m++;
23         }
24         //document.write(a.length);
25         document.write(a+"<br>");
26         document.write("轮数"+m+"<br>");
27         document.write("总次数"+n+"<br>");
28         // a1  a2
29         // 3    2
30         // temp
31
32         // 2     3
33         //      temp
34
35         //  2    3
36         // temp

上代码(优化1):

冒泡排序优化://每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。) j<a.length-1-i
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script>
        var a=[45,67,23,88,21,6,99];
        var temp=[];
        var m=0;//轮数
        var n=0;//一共次数
        for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
            for(var j=0;j<a.length-1-i;j++){  //每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。)
                if(a[j]>a[j+1]){//后面的大于前面的 后面再前  前面在后 从小到大
                    temp=a[j];//a[j]=temp;
                    a[j]=a[j+1];//a[j+1]=a[j];
                    a[j+1]=temp;//a[j+1]=temp
                //顺序不能调换 因为a[]里面有个下标是一定从小到大的
                }
                n++
            }
            m++;
        }
        //document.write(a.length);
        document.write(a+"<br>");
        document.write("轮数"+m+"<br>");
        document.write("总次数"+n+"<br>");
        // a1  a2
        // 3    2
        // temp 

        // 2     3
        //      temp

        //  2    3
        // temp

45,67,23,88,21,6,99
// 第一轮 6次
// 45 67 23 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 21 88 6 99
// 45 23 67 21 6 88 99
// 45 23 67 21 6 88 99

// 第二轮 6次
// 23 45 67 21 6 88 99
// 23 45 67 21 6 88 99
// 23 45 21 67 6 88 99
// 23 45 21 6 67 88 99
// 23 45 21 6 67 88 99
// 23 45 21 6 67 88 99

// 第三轮 6次
// 23 45 21 6 67 88 99
// 23 21 45 6 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99

// 第四轮 6次
// 21 23 6 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99

// 第五轮 6次
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99

// 第一轮 6次
// 45 67 23 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 88 21 6 99
// 45 23 67 21 88 6 99
// 45 23 67 21 6 88 99
// 45 23 67 21 6 88 99

// 第二轮 5次
// 23 45 67 21 6 88 99
// 23 45 67 21 6 88 99
// 23 45 21 67 6 88 99
// 23 45 21 6 67 88 99
// 23 45 21 6 67 88 99

// 第三轮 4次
// 23 45 21 6 67 88 99
// 23 21 45 6 67 88 99
// 23 21 6 45 67 88 99
// 23 21 6 45 67 88 99

// 第四轮 3次
// 21 23 6 45 67 88 99
// 21 6 23 45 67 88 99
// 21 6 23 45 67 88 99

// 第五轮 2次
// 6 21 23 45 67 88 99
// 6 21 23 45 67 88 99

// 第六轮 1次
// 6 21 23 45 67 88 99

    </script>
</head>
<body>

</body>
</html>

上代码(优化2):

  1 冒泡排序优化2:5轮 5+4+3+2+1=11次
  2 做一个判断
  3 如果在比较的时候 两两不发生比较了 就退出循环
  4 <!DOCTYPE html>
  5 <html lang="en">
  6 <head>
  7     <meta charset="UTF-8">
  8     <title>Document</title>
  9     <script>
 10         var a=[45,67,23,88,21,6,99];
 11         //var a=[1,2,3,4,5,6,7,8,9];
 12         var temp=[];
 13         var m=0;//轮数
 14         var n=0;//一共次数
 15         //如果比较完备提前结束比较。(判断,如果本次比较没有移动任何元素,那么说明已经比较完成)
 16         for(var i=0;i<a.length-1;i++){//这里不减1 后面轮数就+1 这是不对的 因为数组下标0开始
 17              //开闭原则。(写在第一个for循环里,是为了,每轮比较初始化bool变量变为true。)
 18             var bool=true;
 19             for(var j=0;j<a.length-1-i;j++){  //每轮比较少比较一次。(每一轮都会比较出一个最大值,然后后一轮没有必要再比较了,所以没比较一轮,就少比较一次。。。)
 20                 if(a[j]>a[j+1]){//后面的大于前面的 后面再前  前面在后 从小到大
 21                     temp=a[j];//a[j]=temp;
 22                     a[j]=a[j+1];//a[j+1]=a[j];
 23                     a[j+1]=temp;//a[j+1]=temp
 24                 //顺序不能调换 因为a[]里面有个下标是一定从小到大的
 25                     bool=false;
 26                         n++;
 27                 }
 28
 29             }
 30
 31             //bool这个变量默认值为true;如果本轮比较有一对元素相互交换位置,那么也不能跳出循环。
 32         //但是,如果本轮比较没有任何元素相互交换位置,那么说明已经比较完成,可以跳出循环。
 33             if(bool){
 34                 break;
 35             }
 36             m++;
 37         }
 38         //document.write(a.length);
 39         document.write(a+"<br>");
 40
 41         document.write("总次数"+n+"<br>");
 42         document.write("轮数"+m+"<br>");
 43         // a1  a2
 44         // 3    2
 45         // temp
 46
 47         // 2     3
 48         //      temp
 49
 50         //  2    3
 51         // temp
 52
 53
 54 // 第一轮 6次
 55 // 45 67 23 88 21 6 99
 56 // 45 23 67 88 21 6 99
 57 // 45 23 67 88 21 6 99
 58 // 45 23 67 21 88 6 99
 59 // 45 23 67 21 6 88 99
 60 // 45 23 67 21 6 88 99
 61
 62 // 第二轮 6次
 63 // 23 45 67 21 6 88 99
 64 // 23 45 67 21 6 88 99
 65 // 23 45 21 67 6 88 99
 66 // 23 45 21 6 67 88 99
 67 // 23 45 21 6 67 88 99
 68 // 23 45 21 6 67 88 99
 69
 70 // 第三轮 6次
 71 // 23 45 21 6 67 88 99
 72 // 23 21 45 6 67 88 99
 73 // 23 21 6 45 67 88 99
 74 // 23 21 6 45 67 88 99
 75 // 23 21 6 45 67 88 99
 76 // 23 21 6 45 67 88 99
 77
 78 // 第四轮 6次
 79 // 21 23 6 45 67 88 99
 80 // 21 6 23 45 67 88 99
 81 // 21 6 23 45 67 88 99
 82 // 21 6 23 45 67 88 99
 83 // 21 6 23 45 67 88 99
 84 // 21 6 23 45 67 88 99
 85
 86 // 第五轮 6次
 87 // 6 21 23 45 67 88 99
 88 // 6 21 23 45 67 88 99
 89 // 6 21 23 45 67 88 99
 90 // 6 21 23 45 67 88 99
 91 // 6 21 23 45 67 88 99
 92 // 6 21 23 45 67 88 99
 93 // 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍)
 94 // 6 21 23 45 67 88 99
 95 // 6 21 23 45 67 88 99
 96 // 6 21 23 45 67 88 99
 97 // 6 21 23 45 67 88 99
 98 // 6 21 23 45 67 88 99
 99 // 6 21 23 45 67 88 99
100
101
102
103 // 第一轮 6次
104 // 45 67 23 88 21 6 99
105 // 45 23 67 88 21 6 99
106 // 45 23 67 88 21 6 99
107 // 45 23 67 21 88 6 99
108 // 45 23 67 21 6 88 99
109 // 45 23 67 21 6 88 99
110
111 // 第二轮 5次
112 // 23 45 67 21 6 88 99
113 // 23 45 67 21 6 88 99
114 // 23 45 21 67 6 88 99
115 // 23 45 21 6 67 88 99
116 // 23 45 21 6 67 88 99
117
118 // 第三轮 4次
119 // 23 45 21 6 67 88 99
120 // 23 21 45 6 67 88 99
121 // 23 21 6 45 67 88 99
122 // 23 21 6 45 67 88 99
123
124 // 第四轮 3次
125 // 21 23 6 45 67 88 99
126 // 21 6 23 45 67 88 99
127 // 21 6 23 45 67 88 99
128
129
130 // 第五轮 2次
131 // 6 21 23 45 67 88 99
132 // 6 21 23 45 67 88 99
133
134 // 第六轮 1次
135 // 6 21 23 45 67 88 99
136
137     </script>
138 </head>
139 <body>
140
141 </body>
142 </html>
143 // 第一轮 5次
144 // 45 67 23 88 21 6 99
145 // 45 23 67 88 21 6 99
146 // 45 23 67 88 21 6 99
147 // 45 23 67 21 88 6 99
148 // 45 23 67 21 6 88 99
149
150
151 // 第二轮 4次
152 // 23 45 67 21 6 88 99
153 // 23 45 67 21 6 88 99
154 // 23 45 21 67 6 88 99
155 // 23 45 21 6 67 88 99
156
157
158 // 第三轮 3次
159 // 23 45 21 6 67 88 99
160 // 23 21 45 6 67 88 99
161 // 23 21 6 45 67 88 99
162
163
164 // 第四轮 2次
165 // 21 23 6 45 67 88 99
166 // 21 6 23 45 67 88 99
167
168
169
170 // 第五轮 1次
171 // 6 21 23 45 67 88 99
172
173
174 // 第六轮 0次

时间: 2024-10-25 14:48:00

JS 冒泡排序从学到优化的相关文章

【小练习】js冒泡排序

任务:设置随意5个数的数列,用js冒泡排序法使之由小到大排序. 如:[5 3 4 1 2]使之输出为[1 2 3 4 5]. ---------------------------------------------------------------------------------- [解说:何为冒泡排序法] 所谓冒泡排序法,就是对一组数字进行从大到小或者从小到大排序的一种算法.具体方法是,相邻数值两两交换.从第一个数值开始,如果相邻两个数的排列顺序与我们的期望不同,则将两个数的位置进行交

js资源加载优化

互联网应用或者访问量大的应用,对js的加载优化是不可少的.下面记录几种优化方法 CDN  + 浏览器缓存 CDN(content delivery network)内容分发网络, 最传统的优化方式.其实就是将自己页面所依赖的js(静态的)放置到CDN上,或者使用一些CDN库,以此降低对应用服务器的请求,而浏览器缓存也是不重复加载js文件的性质. 优点: 1.简单.容易维护 2.304 cache 简单来说就是转掉请求,缓存不重加载. 缺点: 1.缓存会失效,当用户强制刷新时会有请求 2.无法增量

C#冒泡排序法及优化

冒泡排序法及优化: static void Main(string[] args) { int[] sums = { 20, 2, 1, 26, 27, 28 }; int compareCount = 0; //冒泡排序法 for (int i = 0; i < sums.Length - 1; i++) //总共要比较的趟数 { for (int j = 0; j < sums.Length - 1 - i; j++) //每趟中要比较的次数 { if (sums[j] > sums

Vue.Js的用户体验优化

一次基于Vue.Js的用户体验优化 一.写在前面 半年以前,第一次在项目上实践VueJs,由于在那之前,没有Angular,avalon等框架的实践经验,所以在Vue的使用上,没有给自己总结出更多的经验和体验.随着项目进行和优化改版,无论是新代码的增加还是旧代码,在功能的实现和代码的书写上,Vue逐渐替代了Jquery,除了有些不容易替换和没有找到基于vue更合适的组件.Vue的使用,在我个人的感受中减轻了我操作dom的负担,我不需要从dom中获取数据,然后拼装数据,也不需要向dom中回写展示数

JS日历控件优化(增加时分秒)

JS日历控件优化 在今年7月份时候 写了一篇关于 "JS日历控件" 的文章 , 当时只支持 年月日 的日历控件,现在优化如下: 1. 在原基础上 支持 yyyy-mm-dd 的年月日的控件. 2. 在原基础上增加支持 yyyy-mm-dd HH:MM 年月日时分的控件. 3. 在原基础上增加支持 yyyy-mm-dd HH:MM:SS 年月日时分秒的控件. 4. 增加确定按钮 及 今天 和关闭按钮.当我切换到其他年份的时候,我点击 "今天"按钮 就可以返回当前的年月

客户端JS性能的一些优化的小技巧

下面是一些关于客户端JS性能的一些优化的小技巧:1.[顶]关于JS的循环,循环是一种常用的流程控制.JS提供了三种循环:for(;;). while().for(in).在这三种循环中 for(in)的效率最差,因为它需要查询Hash键,因此应尽量少用for(in)循环,for(;;).while()循环的性能基本持平.当然,推 荐使用for循环,如果循环变量递增或递减,不要单独对循环变量赋值,而应该使用嵌套的++或--运算符.2.如果需要遍历数组,应该先缓存数组长度,将数组长度放入局部变量中,

深析filemap.js——关于JS的算法及优化的实践

关于项目的用法和介绍可以查看上面的两个链接,这篇文章主要内容是对 filemap.js 的代码进行一步一步的分析,详细介绍其运行原理和优化策略. 知识点准备: NodeJS 的基本使用方法(主要是 fs 文件系统): ES6 特性及语法( let , const , for...of , arrow function ...) n叉树先序遍历算法 . 知识点1和2请自行查阅资料,现在对知识点3进行分析. N叉树先序遍历算法 首先明白什么是树.引用 数据结构与算法JavaScript描述 : 一个

冒泡排序及其算法优化分析

1.基本冒泡排序 冒泡排序的基本思想:假设被排序的记录数组d[1...N]垂直竖立,将每个记录d[i]看作是一个气泡,那么重的气泡就会向下下沉,轻的气泡就会向上升.每次都是相邻的两个气泡d[i]和d[i+1]进行比较.如果d[i]>d[i+1],那么就交换两个气泡,然后在比较d[i+1]和d[i+2],以此类推,知道所有的气泡都有序排列.假设排序20,37,11,42,29. 第1次冒泡:20.37,11,42,29 d[0]和d[1]比较 第2次冒泡:20,11,37,42,29 d[1]和d

冒泡排序基本代码及其优化

冒泡排序是一种交换排序,它的基本思想是:两两比较序列中造句记录的关键字,如果反序则交换,直到没有反序的记录为止.它的运行过程如下(以升序排序为例): 比较造句的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.这步做完后,最后的元素会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 比如待排序序列数组为:9 2 6 8 7 3 1 0 4 5,将其升序排序成序