冒泡排序 订阅
冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。 展开全文
冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。
信息
时间复杂度
O(n²)
外文名
Bubble Sort
算法稳定性
稳定排序算法
中文名
冒泡排序
实    质
把小(大)的元素往前(后)调
所属学科
计算机科学
冒泡排序算法原理
冒泡排序算法的原理如下: [1] 
收起全文
精华内容
参与话题
问答
  • 冒泡排序冒泡排序动画、冒泡排序代码、冒泡排序教程 代码下载
    展开全文
  • 双向冒泡排序 冒泡排序 性能对比

    千次阅读 2018-04-11 19:22:49
    双向冒泡排序 冒泡排序 性能对比 数据结构与算法与语言无关,此篇博文用的描述语言是go 冒泡排序 冒泡排序的时间复杂度是O(n2) 先看一个简单的冒泡排序 //普通冒泡排序 func normalBubbleSort(sequence []...

    双向冒泡排序 冒泡排序 性能对比

    数据结构与算法与语言无关,此篇博文用的描述语言是go

    冒泡排序

    冒泡排序的时间复杂度是O(n2)

    先看一个简单的冒泡排序

    //普通冒泡排序
    func normalBubbleSort(sequence []int){
        for i := 0;i < len(sequence) - 1;i++ {
            for j := 0;j < len(sequence) - 1 - i;j++ {
                if sequence[j] > sequence[j + 1] {
                    //交换元素值
                    sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
                }
            }
        }
    }

    这是一个相当简单的冒泡排序

    冒泡排序就如它的名字一样,冒泡,在上述算法中,第一趟排序会确定最大的一个值,并把它放在尾部,第二趟会确定一个第二大的值,放在倒数第二位……,直到没有元素可交换为止(本文着重讨论性能对比,要是想了解冒泡排序,可以看看相关的文章,这里就不再赘述了)

    比如一个序列为{5,2,73,7,3,9,2,8}

    第一趟冒泡排序后它会是下面这样

    这里写图片描述

    经过多次排序之后,整个序列变成有序的

    这里写图片描述

    双向冒泡排序

    接下来看一下改进后的冒泡排序,双向冒泡排序。原始的冒泡排序是是单向的,它始终是从下标为0的元素向后扫描

    而双向冒泡排序是从两端进行扫描

    这里写图片描述

    首先从首部到尾部进行扫描,把最大的数往后交换,然后从尾部到首部进行扫描,把最小的数往前交换,多次扫描后,最终得到一个有序的序列

    这里写图片描述

    代码实现

    //双向冒泡排序
    func bubbleSort(sequence []int){
        var i int
    
        //是否交换标志
        isSwap := true
    
        for isSwap {
            isSwap = false
            //自顶而下的扫描
            for j := i;j < len(sequence) - i - 1;j++ {
                if sequence[j] > sequence[j + 1] {
                    sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
                    isSwap = true
                }
            } 
    
            //自底而下的扫描
            for j := len(sequence) - i - 1;j >= i + 1;j-- {
                if sequence[j] < sequence[j - 1] {
                    sequence[j], sequence[j - 1] = sequence[j - 1], sequence[j]
                }
                isSwap = true
            }
    
            i++
        }
    }

    改进后的双向冒泡排序

    双向冒泡排序固然很好,但是上述的代码有个问题,做了一些无用的工作,比如,双向扫描每次都把已经有序的部分再扫描了一遍。

    例如,经过两次扫描后的结果:

    这里写图片描述

    由此可见,该序列两边的两个元素都已经有序了,而下次扫描还会扫描到两边的两个元素

    改进方法是创建两个哨兵,sentryI之前的部分是已经有序的部分,sentryJ之后的部分也是有序的部分,那么每次扫描,只需要扫描,sentryI到sentryJ中间的部分就行了

    这里写图片描述

    那么这样第三次扫描就只需要扫描蓝色的部分即可,在每次扫描过后sentryI++,sentryJ—,直到sentryI >= sentryJ的时候停止扫描,此时序列中的元素已经有序

    代码实现

    //冒泡排序2
    func bubbleSort2(sequence []int){
        //i ,j 哨兵
        var sentryI ,sentryJ int = 0, len(sequence) - 1
    
        for sentryI < sentryJ {
            //自顶而下的扫描
            for i := sentryI;i < sentryJ;i++ {
                if sequence[i] > sequence[i + 1] {
                    sequence[i], sequence[i + 1] = sequence[i + 1], sequence[i]
                }
            }
            sentryJ--
            //自底而上的扫描
            for i := sentryJ;i > sentryI;i-- {
                if sequence[i] < sequence[i - 1] {
                    sequence[i], sequence[i - 1] = sequence[i - 1], sequence[i]         
                }
            }
            sentryI++
        }
    }

    性能对比

    现在来对比一下三个排序算法(普通冒泡,双向冒泡,改进后的双向冒泡)的性能

    首先初始化随机产生10k个数,放入一个容器中,然后对这个10k个数进行排序,看一下所消耗的时间

    以下给出代码实现

    package main
    
    import (
        "time"
        "fmt"
        "math/rand"
    )
    
    var sequence []int = make([]int,10000)
    
    //初始化序列
    func init(){
        for i := 0;i < 10000;i++ {
            sequence[i] = rand.Intn(10000)
        }
    }
    
    func main(){
        //普通冒泡排序
        t := time.Now()
        normalBubbleSort(sequence)  
        fmt.Println(time.Since(t))
        //双向冒泡排序
        t = time.Now()
        bubbleSort(sequence)    
        fmt.Println(time.Since(t))
        //改进版冒泡排序
        t = time.Now()
        bubbleSort2(sequence)
        fmt.Println(time.Since(t))
    }
    
    //普通冒泡排序
    func normalBubbleSort(sequence []int){
        for i := 0;i < len(sequence) - 1;i++ {
            for j := 0;j < len(sequence) - 1 - i;j++ {
                if sequence[j] > sequence[j + 1] {
                    sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
                }
            }
        }
    }
    
    //双向冒泡排序
    func bubbleSort(sequence []int){
        var i int
    
        //是否交换标志
        isSwap := true
    
        for isSwap {
            isSwap = false
            //自顶而下的扫描
            for j := i;j < len(sequence) - i - 1;j++ {
                if sequence[j] > sequence[j + 1] {
                    sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
                    isSwap = true
                }
            } 
    
            //自底而下的扫描
            for j := len(sequence) - i - 1;j >= i + 1;j-- {
                if sequence[j] < sequence[j - 1] {
                    sequence[j], sequence[j - 1] = sequence[j - 1], sequence[j]
                }
                isSwap = true
            }
    
            i++
        }
    }
    
    //改进版冒泡排序
    func bubbleSort2(sequence []int){
        //i ,j 哨兵
        var sentryI ,sentryJ int = 0, len(sequence) - 1
    
        for sentryI < sentryJ {
            //自顶而下的扫描
            for i := sentryI;i < sentryJ;i++ {
                if sequence[i] > sequence[i + 1] {
                    sequence[i], sequence[i + 1] = sequence[i + 1], sequence[i]
                }
            }
            sentryJ--
            //自底而上的扫描
            for i := sentryJ;i > sentryI;i-- {
                if sequence[i] < sequence[i - 1] {
                    sequence[i], sequence[i - 1] = sequence[i - 1], sequence[i]         
                }
            }
            sentryI++
        }
    }

    打印结果

    120.6209ms //普通版冒泡排序
    59.073403ms //双向冒泡排序
    40.989477ms //改进版冒泡排序

    可以看到普通版冒泡排序比其它两个的两倍还要多!

    我们再加大排序的量,改成初始化100k个数,来排序这100k个数

    普通版冒泡排序等的我差点放弃,来看一下打印结果

    打印结果

    16.369802704s //普通版冒泡排序
    5.811546606s  //双向冒泡排序
    3.753537398s //改进版冒泡排序

    普通版冒泡排序用了整整16s!!!而双向冒泡只用了5s,改进版的仅仅只用了3s

    通过数据量的增加可以明显的看出差距了

    虽然平时我们不大可能会遇到这么大的数据量,而小数据量的差距又不是很大,再说了,如果你做顶层开发,许多语言都封装了排序算法,直接调用就行了,不必这么大费周章,但是,我觉得了解算法及其性能是很有必要的,它始终能渗透你的思维

    展开全文
  • C 冒泡排序 冒泡排序的优化

    千次阅读 2016-01-07 14:33:24
    本文包含冒泡排序的三种实现方式 分别为冒泡排序初级版,升级版,终级版(自己起的名字) 使用时只要使用终极版就本以了,终级版为升级版的优化版本 至于初极版和升级版只是为了帮助理解 冒泡排序的时间复杂度为O(n²)

    本文包含冒泡排序的三种实现方式

    分别为冒泡排序初级版,升级版,终级版(自己起的名字)

    使用时只要使用终极版就本以了,终级版为升级版的优化版本

    至于初极版和升级版只是为了帮助理解

    冒泡排序的时间复杂度为O()

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string>
    #include <math.h>
    #include <vector>
    #include <sstream>
    #include <list>
    #include <algorithm>
    #include <time.h>
    //头文件引用的较多,有一些和本程序无关
    
    using namespace std;
    
    //取随机数
    int random(int min = 1, int max = 100); 
    
    //打印数组
    void coutArr(int arr[]);
    
    //冒泡排序初级版
    void bubbleSort0(int arr[]);
    
    //冒泡排序升级版
    void bubbleSort1(int arr[]);
    
    //冒泡排序终级版(避免已经有序的情况下做无意义的循环比较)
    void bubbleSort2(int arr[]);
    
    //自动生成等排序数组的个数
    const int NUM = 10;
    int main(int argc, char *argv[])
    {
    	srand(((int)time(0)));
    	
    	//也可用其他的数据形式,如链表...
    	int arr[NUM+1];//网上学的小技巧,arr[0]位置用作哨兵,插入排序用到这个哨兵了
    	for(int i = 1; i < NUM + 1; i++)//随机取NUM个数,在[1-100]之间(有可能重复)
    		arr[i] = random();
    
    	cout << "排序前:" << endl;
    	coutArr(arr);
    
    	//bubbleSort0(arr);//初级版
    	//bubbleSort1(arr);//升级版
    	bubbleSort2(arr);//终级版
    
    	cout << "排序后:" << endl;;
    	coutArr(arr);
    
    	system("pause");
    	return 0;
    }
    
    //取随机数
    int random(int min, int max)  
    {  
        //srand(((int)time(0))); //随机种子 写在这不好使,不知道为什么  
        //return min + (rand() % (max - min + 1));  
        return min + (max - min + 1) * rand() / RAND_MAX;//也可以这么写  
    }
    
    //打印数组
    void coutArr(int arr[])
    {
    	cout << arr[1];
    	for(int i = 2; i < NUM + 1; i++)
    		cout << ", " << arr[i];
    	cout << endl << endl;
    }
    
    //冒泡排序初级版
    void bubbleSort0(int arr[])
    {
    	for(int i = 1; i < NUM; i++)
    		for(int j = i + 1; j <= NUM; j++)
    			if(arr[i] > arr[j])
    				swap(arr[i], arr[j]);
    }
    
    //冒泡排序升级版
    void bubbleSort1(int arr[])
    {
    	for(int i = 1; i < NUM; i++)
    		for(int j = NUM - 1; j >= i; j--)//从后向前
    			if(arr[j] > arr[j+1])
    				swap(arr[j], arr[j+1]);
    }
    
    //冒泡排序终级版(避免已经有序的情况下做无意义的循环比较)
    void bubbleSort2(int arr[])
    {
    	bool flag = true;
    	for(int i = 1; i < NUM && flag; i++)
    	{
    		flag = false;
    		for(int j = NUM - 1; j >= i; j--)//从后向前
    		{
    			if(arr[j] > arr[j+1])
    			{
    				swap(arr[j], arr[j+1]);
    				flag = true;//有交换代表还未排好序
    			}
    		}
    	}
    }
    运行结果:



    展开全文
  • 冒泡排序 冒泡排序:BubbleSort

    千次阅读 2009-10-22 08:41:00
    编辑词条 冒泡排序 冒泡排序:BubbleSort 基本概念 冒泡排序的基本概念是:依次比较相邻的两个数,将小数放在前面,大数放在后面。即首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,...

     编辑词条 冒泡排序  冒泡排序:BubbleSort
      基本概念
      冒泡排序的基本概念是:依次比较相邻的两个数,将小数放在前面,大数放在后面。即首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。重复以上过程,仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再大于第2个数),将小数放前,大数放后,一直比较到最小数前的一对相邻数,将小数放前,大数放后,第二趟结束,在倒数第二个数中得到一个新的最小数。如此下去,直至最终完成排序。
      由于在排序过程中总是小数往前放,大数往后放,相当于气泡往上升,所以称作冒泡排序。
      用二重循环实现,外循环变量设为i,内循环变量设为j。外循环重复9次,内循环依次重复9,8,...,1次。每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,...,9,对于每一个i, j的值依次为1,2,...10-i。
      产生
      在许多程序设计中,我们需要将一个数列进行排序,以方便统计,常见的排序方法有冒泡排序,二叉树排序,选择排序等等。而冒泡排序一直由于其简洁的思想方法和比较高的效率而倍受青睐。
      排序过程
      设想被排序的数组R[1..N]垂直竖立,将每个数据元素看作有重量的气泡,根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R,凡扫描到违反本原则的轻气泡,就使其向上"漂浮",如此反复进行,直至最后任何两个气泡都是轻者在上,重者在下为止。
      算法示例
      49 13 13 13 13 13 13 13
      38 49 27 27 27 27 27 27
      65 38 49 38 38 38 38 38
      97 65 38 49 49 49 49 49
      76 97 65 49 49 49 49 49
      13 76 97 65 65 65 65 65
      27 27 76 97 76 76 76 76
      49 49 49 76 97 97 97 97
      Procedure BubbleSort(Var R : FileType) //从下往上扫描的起泡排序//
      Begin
      For I := 1 To N-1 Do //做N-1趟排序//
      begin
      NoSwap := True; //置未排序的标志//
      For J := N - 1 DownTo 1 Do //从底部往上扫描//
      begin
      If R[J+1]< R[J] Then //交换元素//
      begin
      Temp := R[J+1]; R[J+1 := R[J]; R[J] := Temp;
      NoSwap := False
      end;
      end;
      If NoSwap Then Return//本趟排序中未发生交换,则终止算法//
      end
      End; //BubbleSort//
      该算法的时间复杂性为O(n2),算法为稳定的排序方
      冒泡排序c++代码
      #include <iostream.h>
      void BubbleSort(int* pData,int Count)
      {
      int iTemp;
      for(int i=1;i<Count;i++)
      {
      for(int j=Count-1;j>=i;j--)
      {
      if(pData[j]<pData[j-1])
      {
      iTemp = pData[j-1];
      pData[j-1] = pData[j];
      pData[j] = iTemp;
      }
      }
      }
      }
      void main()
      {
      int data[] = {10,9,8,7,6,5,4};
      BubbleSort(data,7);
      for (int i=0;i<7;i++)
      cout<<data[i]<<" ";
      cout<<"/n";
      }
      冒泡排序PHP代码
      <?php
      //冒泡排序(一维数组)
      function bubble_sort($array)
      {
      $count = count($array);
      if ($count <= 0) return false;
      for($i=0; $i<$count; $i++)
      {
      for($j=$count-1; $j>$i; $j--)
      {
      if ($array[$j] < $array[$j-1])
      {
      $tmp = $array[$j];
      $array[$j] = $array[$j-1];
      $array[$j-1] = $tmp;
      }
      }
      }
      return $array;
      }
      //使用实例
      $_array = array('5', '8' ,'5' ,'6' ,'9' ,'3' ,'2' ,'4');
      $_array = bubble_sort($_array);
      print ($_array);
      ?>
      冒泡排序Ruby代码
      def bubble(arr)
      (arr.length-1).downto(1) do |j|
      a1 = arr.dup
      j.times do |i|
      if arr > arr[i+1]
      arr,arr[i+1] = arr[i+1],arr
      end
      end
      break if a1 == arr
      end
      arr
      end
      冒泡排序Java代码
      static void BubbleSort(int a []){
      int temp=0;
      for (int i = 0; i < a.length ; i++) {
      for (int j = 0; j < a.length - i - 1; j++){
      if (a[j]>a[j + 1]){ //把这里改成大于,就是升序了
      temp=a[j];
      a[j]=a[j + 1];
      a[j + 1]=temp;
      }
      }
      }
      }
      冒泡排序Visual Basic代码
      Option Explicit
      Private Sub Form_click()
      Dim a, c As Variant
      Dim i As Integer, temp As Integer, w As Integer
      a = Array(12, 45, 17, 80, 50)
      For i = 0 To UBound(a) - 1
      If (a(i) > a(i + 1)) Then '若是递减,改为a(i)<a(i+1)
      temp = a(i)
      a(i) = a(i + 1)
      a(i + 1) = temp
      End If
      Next
      For Each c In a
      Print c;
      Next
      End Sub
      冒泡排序Pascal代码
      <i id="bks_9tjbxut2">program bubblesort;
      const
      N=20;
      MAX=10;
      var
      a:array[1..N] of 1..MAX;
      temp,i,j:integer;
      begin
      randomize;
      for i:=1 to N do a:=1+random(MAX);
      writeln('Array before sorted:');
      for i:=1 to N do write(a,' ');
      writeln;
      for i:=N-1 downto 1 do
      for j:=1 to i do
      if a[j]<a[j+1] then
      begin
      temp:=a[j];
      a[j]:=a[j+1];
      a[j+1]:=temp
      end;
      writeln('Array sorted:');
      for i:=1 to N do write(a,' ');
      writeln;
      writeln('End sorted.');
      readln;
      end.
      冒泡排序C#代码
      public void BubbleSort(int[] array) {
      int length = array.Length;
      for (int i = 0; i <= length - 2; i++) {
      for (int j = length - 1; j >= 1; j--) {
      if (array[j] < array[j - 1] ) {
      int temp = array[j];
      array[j] = array[j - 1];
      array[j - 1] = temp;
      }
      }
      }
      }
      冒泡排序Python代码
      #algo
      def bubble(list):
      count = len(list) -1
      while count > 0 :
      i = 0
      onceflag = True
      while i < count :
      if int(list) > int(list[i+1]) :
      tmp = list
      list = list [i+1]
      list[i+1] =tmp
      onceflag = False
      i = i + 1
      if onceflag : return list
      count = count - 1
      return list
      #test
      li = [1,9,8,5,4,3,6,7,0,2]
      print bubble(li)
      冒泡排序法的改进
      比如用冒泡排序将4、5、7、1、2、3这6个数排序。在该列中,第二趟排序结束后,数组已排好序,但计算机此时并不知道已经反排好序,计算机还需要进行一趟比较,如果这一趟比较,未发生任何数据交换,则知道已排序好,可以不再进行比较了。因而第三趟比较还需要进行,但第四、五趟比较则是不必要的。为此,我们可以考虑程序的优化。
      为了标志在比较中是否进行了,设一个布尔量flag。在进行每趟比较前将flag置成true。如果在比较中发生了数据交换,则将flag置为false,在一趟比较结束后,再判断flag,如果它仍为true(表明在该趟比较中未发生一次数据交换)则结束排序,否则进行下一趟比较。
      性能分析
      若记录序列的初始状态为"正序",则冒泡排序过程只需进行一趟排序,在排序过程中只需进行n-1次比较,且不移动记录;反之,若记录序列的初始状态为"逆序",则需进行n(n-1)/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。


    百度百科中的词条内容仅供参考,如果您需要解决具体问题
    (尤其在法律、医学等领域),建议您咨询相关领域专业人士。 本词条对我有帮助
    354
     
    扩展阅读:
    1.http://www.zjyz.org/jiaoshi/jszy/Exg/competition/algorithm/sort2.htm
    2.http://www.window07.com/dev/code/2006-3-4/k74957.htm
    3.http://zn3.ccjy.cn/wz/olympiad/sjjg/16.htm
    4.http://ruby-lang.org.cn/forums/redirect.php?tid=4251&goto=lastpost#lastpost
    [我来完善]相关词条:
    更多
    快速排序算法基数排序直接插入排序堆排序指针函数函数指针希尔排序结构体杨辉三角
    插入排序选择排序归并排序递归Shell排序 开放分类:
    编程,算法,数据结构,排序组合

     

    展开全文
  • 冒泡排序

    万次阅读 多人点赞 2019-09-16 16:28:32
    冒泡排序是一种比较简单的排序算法,它循环走过需要排序的元素,依次比较相邻的两个元素,如果顺序错误就交换,直至没有元素交换,完成排序。 若对n个人进行排序,我们需要n-1次比较,所以第k次比较需要进行n-k次...
  • 经典算法---冒泡排序

    万次阅读 多人点赞 2014-09-24 15:58:50
    原文链接: 冒泡排序---经典排序算法 | 逍遥游 冒泡排序(BubbleSort)以其“在排序过程中相邻元素不断交换,一些元素慢慢被换到最后,看起来就像是元素在冒泡一样”而得名,是一种简单的基于关键词比较的排序...
  • Java 冒泡排序

    千次阅读 多人点赞 2019-05-28 15:19:23
    冒泡排序的原理有一下几个步骤 1 逐一比较数组中相邻的两个元素,如果后面的数字小于前面的数组,就交换前后元素 2 经过一轮的比较之后一定有一个最大的排在后面的位置 3 每次比较剩下的元素,经过n-1次比较,可以...
  • C语言冒泡排序

    千次阅读 2016-06-26 17:42:12
    C语言冒泡排序
  • java冒泡排序

    千次阅读 2018-01-17 17:43:42
    Java冒泡排序  冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • Java冒泡排序算法

    千次阅读 多人点赞 2018-10-21 07:25:16
    java冒泡排序算法 1.基本思想: 对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组的前面(从小到大排序),把大的元素移动到数组的后面,即交换两个元素的位置,这样较小的元素就像气泡一样从...
  • 冒泡排序 C++版

    千次阅读 2018-11-03 17:49:11
    一、说明:冒泡排序的原理在注释中,文中冒泡排序使用了模板来传入数据,详细情况看下面的测试代码。 二、测试代码 #include &amp;lt;iostream&amp;gt; #include &amp;lt;vector&amp;gt; ...
  • C语言冒泡排序算法

    千次阅读 多人点赞 2018-12-25 17:05:57
    冒泡排序的概念:冒泡排序(Bubble Sort)是一种简单的交换排序,它是通过两两比较相邻记录的关键字,如果发生逆序就进行交换,从而使关键字小的记录如气泡一般逐渐往上“漂浮”(左移),或者使关键字大的记录如...
  • C#冒泡排序实现

    千次阅读 2018-08-10 17:45:52
    冒泡排序:前后两个两两比较,根据需求(从小到大,从大到小)比较  时间复杂度:O(n²) 稳定性:稳定 空间复杂度 O(1) using System; using System.Collections.Generic; using System.Linq; using System....
  • 冒泡排序C语言实现

    千次阅读 多人点赞 2016-10-20 18:51:28
    冒泡排序C语言实现
  • C++冒泡排序

    千次阅读 多人点赞 2015-07-23 17:17:00
    C++冒泡排序
  • Python 冒泡排序

    千次阅读 2018-10-24 14:20:54
    冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列...
  • Java基础(冒泡排序)

    万次阅读 多人点赞 2019-05-17 16:54:30
    冒泡排序简介 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 针对所有的元素重复以上的...
  • 排序算法系列:冒泡排序与双向冒泡排序

    万次阅读 多人点赞 2016-01-29 15:25:32
    **排序算法**应该算是一个比较热门的话题,在各个技术博客平台上也都有一些博文进行了一定程度的讲解。...本文就先从最简单的冒泡排序开始说起,别说你已经彻底了解了冒泡排序算法(虽然一开始我也是这样以为的)。
  • 本文(所有排序算法代码+综合比较代码)链接: 一、比较目的:        由于《数据结构》课本中各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。所以我希望通过...
  • 算法 - 冒泡排序(C#)

    万次阅读 多人点赞 2019-03-14 18:34:09
    分享一个大牛的人工智能教程。... * 冒泡排序(Bubble Sort),是一种计算机科学领域较简单的排序算法。 * 它重复地走访要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来,直到没有元素...
  • python面试--冒泡排序

    千次阅读 2017-06-27 18:07:32
    python冒泡排序

空空如也

1 2 3 4 5 ... 20
收藏数 95,075
精华内容 38,030
关键字:

冒泡排序