冒泡排序之算法

一、定义
冒泡排序是一种基于比较的排序算法,每次比较,小数字在左,大数字在右。比较是相邻的两个元素比较,交换也发生在这两个元素之间,大数字经过交换会慢慢“浮”到最后面。
二、算法思想
依次比较相邻的两个数,如果不符合排序规则,则调换两个数的位置。这样一遍比较下来,能够保证最大(或最小)的数排在最后一位。
再对最后一位以外的数组,重复前面的过程,直至全部排序完成。
三、具体实现
因为有2层循环,所以有4种实现方式。

//交换元素
function swap(arr,i,j){
  var temp = arr[j];
  arr[j] = arr[i];
  arr[i] = temp;
}

1、外循环正序遍历,内循环正序遍历,结果靠后的元素位置先确定。

function bubbleSort1(arr) {
  var len = arr.length;
  for (var i = 0; i < len; i++) {
    for (var j = 0,stop = len - 1 - i; j < stop; j++) {
      if (arr[j] > arr[j + 1]) {
        swap(arr, j, j + 1);
      }
    }
  }
  return arr;
}
console.log(bubbleSort1([3,5,9,2,11,6,3,5]));

2、外循环正序遍历,内循环逆序遍历,结果靠前的元素位置先确定。

function bubbleSort2(arr) {
  var len = arr.length;
  for (var i = 0; i < len; i++) {
    for (var j = len - 1; j >= i+1; j--) {
      if (arr[j] < arr[j - 1]) {
        swap(arr, j, j - 1);
      }
    }
  }
  return arr;
}
console.log(bubbleSort2([3,5,9,2,11,6,3,5]));

3、外循环逆序遍历,内循环正序遍历,结果靠后的元素位置先确定。

function bubbleSort3(arr) {
  var len = arr.length;
  for (var i = len - 1; i >= 0; i--) {
    for (var j = 0; j < i; j++) {
      if (arr[j] > arr[j + 1]) {
        swap(arr, j, j + 1);
      }
    }
  }
  return arr;
}
console.log(bubbleSort3([3,5,9,2,11,6,3,5]));

4、外循环逆序遍历,内循环逆序遍历,结果靠前的元素位置先确定。

function bubbleSort4(arr) {
  var len = arr.length;
  for (var i = len - 1; i >= 0; i--) {
    for (var j = len - 1; j >= len - 1 - i; j--) {
      if (arr[j] < arr[j - 1]) {
        swap(arr, j, j - 1);
      }
    }
  }
  return arr;
}
console.log(bubbleSort4([3,5,9,2,11,6,3,5]));

5、双向冒泡排序,鸡尾酒排序,内循环逆序遍历,结果靠前的元素位置先确定。

function bubbleSort5(arr) {
  var tail = arr.length -1;
  for (var i = 0; i < tail; tail--) {
    for (var j = tail; j > i; j--) {//第一轮, 先将最小的数据冒泡到前面
      if (arr[j] < arr[j - 1]) {
        swap(arr, j, j - 1);
      }
    }
    i++;
    for (var j = i; j < tail; j++) {//第二轮, 将最大的数据冒泡到后面
      if (arr[j] > arr[j + 1]) {
        swap(arr, j, j + 1);
      }
    }
  }
  return arr;
}
console.log(bubbleSort5([3,5,9,2,11,6,3,5]));

四、效率分析
由于冒泡排序只在相邻元素大小不符合要求时才调换他们的位置, 它并不改变相同元素之间的相对顺序, 因此它是稳定的排序算法。
1、时间复杂度
最坏的情况:每次都需要交换,,共需遍历并交换将近n²/2次,,时间复杂度为O(n²);
最佳的情况:内循环遍历一次后发现排序是对的, 因此退出循环,时间复杂度为O(n);
平均来讲, 时间复杂度为O(n²)。
2、空间复杂度
由于冒泡排序中只有缓存的temp变量需要内存空间, 因此空间复杂度为常量O(1)。

时间: 2024-09-29 17:14:13

冒泡排序之算法的相关文章

冒泡排序(算法源码)

算法源码: //BubbleSort.cpp #include <iostream>using namespace std; void BubbleSort(int a[], int n){ for(int i=n-1;i>0;i--) {for(int j=0;j<i;j++) { if (a[j]>a[j+1]) { int tmp = a[j]; a[j] = a[j+1]; a[j+1] = tmp; } } }}int main(){ int a[]={4,3,6,

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

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

内嵌汇编与C/C++实现的冒泡排序,快速排序算法排序500W个数据对比

内嵌汇编是微软为了提高程序的直接操作硬件能力,以及实现大任务程序效率的提高,而嵌入在VC中的,他不依赖于汇编器对内嵌汇编代码进行汇编,这些内嵌汇编代码由C编译器内部实现,可以使程序好像自陷到汇编状态一样.这意味着你如果在C/C++程序中使用了 inline  asm进行 汇编 那么 就注定无法跨平台的,对于没有汇编基础的同学是需要去学习下王爽的8086汇编程序设计.,因为有些时候C++程序员是不得不懂这些东西的 ,否则你永远无法知道编译器为你的函数做了什么,.你还有哪些地方需要优化, 不管处于什

《冒泡排序》算法设计之二

冒泡排序过程 1.首先比较相邻的两个元素,如果前面数据大于后面数据的话,就将这两个数进行交换,依次推,直到完成第N-1个记录与第N个记录交换为止(第一趟起泡). 2.然后再进行第二趟气泡.由第一趟气泡,可知末尾是最大数,所以第二趟之比较前N-1个数 3.第三趟--   比较N-2个数 ................................................................................... 冒泡分析 通过上述的过程分析,可以知道冒泡就好

java 冒泡排序 经典算法题

//        冒泡排序:经典算法题.//        有一组数字 2,10,8,20,11,把这组数按照从大到小的顺序排列出来.20,11,10,8,2//        2,10,8,20,11 //        找出最大的数,放到第一位(1,2,3,4,5)//        20,10,8,2,11 //        从剩下的4个数中,找最大的(2,3,4,5)//        20,11,8,2,10 //        从剩下的3个数中,找最大的(3,4,5)//    

冒泡排序的算法

思想(升序): 1.比较两个相邻数据之间的大小,保证大的值在后面,最后,经过一次排序后会选出本次数组中的最大值,放在最后一位: 2.在排除上一次的最大值数组中,再选出一位最大值放在最后一位: 3.直到排除(选出)数组长度-1个最大值后,排序完成: 比如:数组为{10 ,34 ,300 ,56 ,6, 56 ,7 ,87 , 5}数组长度为9: public class find_em { public static void main(String[] args){ int arr[]={10,

冒泡排序java算法

public class maopao { public static void main(String[] args) { int[] array = {332,94,65,4,15,64,16,5,4}; int temp = 0 ; /** * i:0-8 9 个 * 第一次: i=0 the inner for should loop 8 times so the number is * */ for(int i =0 ;i<array.length;i++){ for (int j =

冒泡排序改进算法

先上一段传统的选择排序的代码: public class SortTest2 { public static void main(String[] args) { int[] a = new int[args.length]; for(int i=0; i<args.length; i++) { a[i] = Integer.parseInt(args[i]); } print(a); selectSort(a); print(a); } private static void selectio

冒泡排序算法

冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. 本文地址:http://www.cnblogs.com/archimedes/p/bubble-sort-algorithm.html,转载请注明源地址. 冒泡排序对n个项目需要O(n2)的比较次数,且可以原地排序.尽