如何实现冒泡排序

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7
 8 <body>
 9 <script>
10     var arr = [3,2,4,1,5];
11
12     /*
13     * 每次循环比较,取出当前的值和他的下一位进行大小的比较,如果当前值比下一个要大(小),交换位置,每次循环确定一个最大(最小)数
14     *
15     * 因为每次比较的数列中,最后一个没有下一位,所以最后一次没有必要再参与比较,所以每次循环比较的次数是要比较的数列元素个数-1次
16     * */
17     for (var i=0; i<arr.length-1; i++) {
18
19         // 获取当前位的值
20         var a = arr[i];
21         // 获取下一位的值
22         var b = arr[i+1];
23
24         // 这里我们以小值在后,如果a小于b交换位置
25         if (a < b) {
26             arr[i] = b;
27             arr[i+1] = a;
28         }
29
30     }
31
32     // 进过上面的一轮循环,就确定这个数列中需要比较的值中最小的值
33     console.log(arr);
34
35 </script>
36 </body>
37 </html>
 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7
 8 <body>
 9 <script>
10 //    var arr = [3,2,4,1,5];
11
12     var arr = [];
13     for (var i=0; i<30000; i++) {
14         arr.push(i);
15     }
16     arr.sort(function () {
17         return Math.random() - 0.5;
18     });
19
20     /*
21     * 每一轮的比较确定一个值,整个比较过程需要比较的次数是 长度-1,以为最后一轮的值,只有一个了,没有比较在比较了
22     * */
23
24     /*
25     * 统计循环的总次数
26     * */
27     var n = 0;
28
29     console.time(‘a‘);
30     for ( var j=0; j<arr.length-1; j++ ) {
31
32         for (var i=0; i<arr.length-1; i++) {
33             var a = arr[i];
34             var b = arr[i+1];
35             if (a < b) {
36                 arr[i] = b;
37                 arr[i+1] = a;
38             }
39
40             n++;
41         }
42
43     }
44     console.timeEnd(‘a‘);
45
46     console.log(n);
47     console.log(arr);
48
49 </script>
50 </body>
51 </html>
 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7
 8 <body>
 9 <script>
10     //var arr = [3,2,4,1,5];
11
12     var arr = [];
13     for (var i=0; i<30000; i++) {
14         arr.push(i);
15     }
16     arr.sort(function () {
17         return Math.random() - 0.5;
18     });
19
20     var n = 0;
21
22     console.time(‘a‘);
23     for ( var j=0; j<arr.length-1; j++ ) {
24
25         /*
26         * 随着大的循环的次数的增加,对应的小的循环就应该减少,减少j次
27         * */
28         for (var i=0; i<arr.length-1-j; i++) {
29             var a = arr[i];
30             var b = arr[i+1];
31             if (a < b) {
32                 arr[i] = b;
33                 arr[i+1] = a;
34             }
35
36             n++;
37
38         }
39
40     }
41     console.timeEnd(‘a‘);
42
43     console.log(n);
44     console.log(arr);
45
46 </script>
47 </body>
48 </html>

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

<body>
<script>
// var arr = [3,2,4,1,5];
// var arr = [5,4,3,1,2];

var arr = [];
for (var i=0; i<30000; i++) {
arr.unshift(i);
}
arr[29999] = 1;
arr[29998] = 0;

// arr.sort(function () {
// return Math.random() - 0.5;
// });

var n = 0;

console.time(‘a‘);
for ( var j=0; j<arr.length-1; j++ ) {

/*
* 随着大的循环的次数的增加,对应的小的循环就应该减少,减少j次
* */

/*
* 每次比较小的循环的时候,设置flag为真,表示已经排序好了,假设排序是ok的
* */
var flag = true;

for (var i=0; i<arr.length-1-j; i++) {
var a = arr[i];
var b = arr[i+1];
if (a < b) {
/*
* 如果比较过程中走了if条件,那么就说明比较未完成,还需要下次再比较,否则就是交换位置没有发生过,表示数据已经排序好了
* */

/*
* 只要走了if,表示有交换,就把flag设置false
* */
flag = false;
arr[i] = b;
arr[i+1] = a;
}

n++;

}

/*
* 循环完成以后,看下flag的值,如果还保持true,则说明上面循环是没有交换的情况发生的,表示排序ok了,如果为false就表示有过交换
* */
if (flag) {
break;
}

}
console.timeEnd(‘a‘);

console.log(n);
console.log(arr);

</script>
</body>
</html>

时间: 2024-10-26 06:49:58

如何实现冒泡排序的相关文章

经典排序算法 - 冒泡排序Bubble sort

 原文出自于 http://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html 经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

php实现冒泡排序

一个程序应包括:对数据的描述:在程序中要指定数据的类型和数据的组织形式,即数据结构(data structure).对操作的描述:即操作步骤,也就是算法(algorithm).Nikiklaus Wirth提出的公式:程序=数据结构+算法作为一个程序员必须得懂点算法啊,就从最简单的开始吧=>冒泡排序 维基百科的说法 冒泡排序(英语:Bubble Sort,台湾另外一种译名为:泡沫排序)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列

算法之冒泡排序(Java示例)

冒泡排序(英语:Bubble Sort) 是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 动画示意 实现示例 Java 1 public class BubbleSortExample { 2 3 static void bubbleSort(int[] arr){ 4 int len =

python 算法中的--冒泡排序

#列表每两个相邻的数,如果前面的比后面的大,那么就交换这两个数# shuffle() 方法将序列的所有元素随机排序. import random def bubble_sort(li): for i in range(len(li)-1): #i代表趟 for j in range(len(li)-i-1): #j列表 if li[j]>li[j+1]: li[j],li[j+1]=li[j+1],li[j] data=list(range(5)) random.shuffle(data) #打

【2017-02-28】冒泡排序

冒泡排序就是比大小,若前者大于后者,则两者交换位置.用两个For循环嵌套来实现 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 数组 { class Program { static void Main(string[] args) { //冒泡排序 3 5 1 2 4 (12345) //思路:第一个for循环执行第一次的时候把第一个数拿出来和后面的数

C语言之冒泡排序算法

一.什么是冒泡排序?冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到数列的顶端,故名.二.冒泡排序的原理   冒泡排序原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头

冒泡排序总结

package Test5; public class maoPai { public static void main(String[] args) { int a[]={56,23,78,1,0,9,46,20}; maoPai.paiXu(a); for(int i=0;i<a.length;i++){ System.out.print(a[i]+" "); } } public static void paiXu(int a[]){ boolean t=true;A冒泡排

利用冒泡排序实现一串字符串从小到大的排序

实现B/S架构,输入一串字母或数字,将它们按从小到大排序,排序算法在服务端实现. 以下是实现: Test.java import java.io.IOException;import java.io.PrintWriter; import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.ser

排序算法大荟萃——冒泡排序算法

1.基本思想:将无序数组R[1...n]垂直排列,从下往上扫描数组R,对比相邻的两个元素,如果上面的元素值小于下面的值,则调整这两个相邻元素的位置,然后继续向上扫描,直到排好序为止. 2.排序过程: (1)初始化:读取无序数组R[1...n] (2)第一趟扫描:从数组R底部开始向上扫描,依次比较相邻的两个元素,若发现数值较小的在上面,则交换两个元素的位置.即依次比较(R[n].R[n-1]).(R[n-1].R[n-2]).....(R[2].R[1]),对于每对元素(R[j].R[j+1]),