• 冒泡排序

    冒泡排序

    编辑

     
    冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
    它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
    这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。
    由于冒泡排序简洁的特点，它通常被用来对于计算机程序设计入门的学生介绍算法的概念。
     

    1算法原理编辑

    冒泡排序算法的运作如下：（从后往前）
    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
    3. 针对所有的元素重复以上的步骤，除了最后一个。
    4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。[1]

    2算法分析编辑

    时间复杂度

    若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数
     和记录移动次数
     均达到最小值：
     ，
     。
    所以，冒泡排序最好的时间复杂度为
     。
    　　若初始文件是反序的，需要进行
     趟排序。每趟排序要进行
     次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
    冒泡排序的最坏时间复杂度为
     。
    综上，因此冒泡排序总的平均时间复杂度为
     。

    算法稳定性

    冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

    算法描述

    RUBY

    1
    2
    3
    4
    5
    6
    7
    8
    9
    defbubbleSort(array)
    returnarrayifarray.size<2
    (array.size-2).downto(0)do|i|
    (0..i).eachdo|j|
    array[j],array[j+1]=array[j+1],array[j]ifarray[j]>=array[j+1]
    end
    end
    returnarray
    end

    PHP

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    functionbubbleSort($numbers){
    $cnt=count($numbers);
    for($i=0;$i<$cnt-1;$i++){//循环比较
    for($j=$i+1;$j<$cnt;$j++){
    if($numbers[$j]<$numbers[$i]){//执行交换
    $temp=$numbers[$i];
    $numbers[$i]=$numbers[$j];
    $numbers[$j]=$temp;
    }
    }
    }
    return$numbers;
    }
     
    $num=array(20,40,60,80,30,70,90,10,50,0);
    var_dump(bubbleSort($num));
    //输出结果如下：
    //array(10){[0]=>int(0)[1]=>int(10)[2]=>int(20)[3]=>int(30)[4]=>int(40)[5]=>int(50)[6]=>int(60)[7]=>int(70)[8]=>int(80)[9]=>int(90)}

    C#语言

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    冒泡算法C#
    namespace数组排序
    {
    classProgram
    {
    staticvoidMain(string[]args)
    {
    inttemp=0;
    int[]arr={23,44,66,76,98,11,3,9,7};
    #region该段与排序无关
    Console.WriteLine("排序前的数组：");
    foreach(intiteminarr)
    {
    Console.Write(item+"");
    }
    Console.WriteLine();
    #endregion
    for(inti=0;i<arr.Length-1;i++)
    {
    #region将大的数字移到数组的arr.Length-1-i
    for(intj=0;j<arr.Length-1-i;j++)
    {
    if(arr[j]>arr[j+1])
    {
    temp=arr[j+1];
    arr[j+1]=arr[j];
    arr[j]=temp;
    }
    }
    #endregion
    }
    Console.WriteLine("排序后的数组：");
    foreach(intiteminarr)
    {
    Console.Write(item+"");
    }
    Console.WriteLine();
    Console.ReadKey();
    }
    }
    }

    Erlang

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    bubble_sort(L)->
    bubble_sort(L,length(L)).
     
    bubble_sort(L,0)->
    L;
    bubble_sort(L,N)->
    bubble_sort(do_bubble_sort(L),N-1).
     
    do_bubble_sort([A])->
    [A];
    do_bubble_sort([A,B|R])->
    caseA<Bof
    true->[A|do_bubble_sort([B|R])];
    false->[B|do_bubble_sort([A|R])]
    end.

    C语言

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #include<stdio.h>
    #defineSIZE8
     
    voidbubble_sort(inta[],intn);
     
    voidbubble_sort(inta[],intn)//n为数组a的元素个数
    {
        inti,j,temp;
        for(j=0;j<n-1;j++)
            for(i=0;i<n-1-j;i++)
            {
                if(a[i]>a[i+1])//数组元素大小按升序排列
                {
                    temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
                }
            }
    }
    intmain()
    {
        intnumber[SIZE]={95,45,15,78,84,51,24,12};
        inti;
        bubble_sort(number,SIZE);
        for(i=0;i<SIZE;i++)
        {
            printf("%d",number[i]);
        }
        printf(" ");
    }

    JAVA

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    publicclassBubbleSort
    {
    publicvoidsort(int[]a)
    {
    inttemp=0;
    for(inti=a.length-1;i>0;--i)
    {
    for(intj=0;j<i;++j)
    {
    if(a[j+1]<a[j])
    {
    temp=a[j];
    a[j]=a[j+1];
    a[j+1]=temp;
    }
    }
    }
    }
    }

    JavaScript

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    functionbubbleSort(arr)
    {vari=arr.length,j;
    vartempExchangVal;
    while(i>0)
    {
    for(j=0;j<i-1;j++)
    {
    if(arr[j]>arr[j+1])
    {
    tempExchangVal=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=tempExchangVal;
    }
    }
    i--;
    }
    returnarr;
    }vararr=[3,2,4,9,1,5,7,6,8];
    vararrSorted=bubbleSort(arr);
    console.log(arrSorted);
    alert(arrSorted);
    控制台将输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
    并且弹窗；

    易语言

    数组 = { 233, 1,5, 5, 6, 8, 7, 9, 41, 62, 2, 1, 3, 0 }
    　　c = 1
    　　b = 取数组成员数 (数组)
    　　.判断循环首 (c >0)
    　　c = 0
    　　.变量循环首 (1, b － 1, 1, d)
    　　.如果真 (数组 [d] > 数组 [d + 1]) ' 此处用于，对两个数据进行对比，可以修改成，拼音，数字大小，文本长度，等等
    　　e = 数组 [d]
    　　数组 [d] = 数组 [d + 1]
    　　数组 [d + 1] = e
    　　b = d
    　　c = c + 1
    　　.如果真结束
    　　.变量循环尾 ()
    　　.判断循环尾 ()

    BASIC语言

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    Submaopao()
     
    Dimaa=Array(233,10086,31,15,213,5201314,427)
     
    DimiAsInteger,jAsInteger
     
    Fori=UBound(a)-1To0Step-1
     
    Forj=0Toi
    Ifa(j)>a(j+1)Thena(j)=a(j)+a(j+1):a(j+1)=a(j)-a(j+1):a(j)=a(j)-a(j+1)'交换变量数值
    EndIf
    Nextj
    Nexti
    Fori=0ToUBound(a)
    Printa(i)
    Nexti
    EndSub

    Objective-C

    (void)bubbleSort:(NSMutableArray *)array{ int i, y; BOOL bFinish = YES; for (i = 1; i<= [array count] && bFinish; i++) { bFinish = NO; for (y = (int)[array count]-1; y>=i; y--) { if ([[array objectAtIndex:y] intValue] < [[array objectAtIndex:y-1] intValue]) { [array exchangeObjectAtIndex:y-1 withObjectAtIndex:y]; bFinish = YES; } } }}Pythonalist = [1,12,2,4,51,66,45,25,96,78,55,23] def bubbleSort(aList): aLen = len(aList) for key in xrange(aLen-1): for x in xrange(aLen - key -1): if aList[x] > aList[x+1]: aList[x], aList[x+1] = aList[x+1], aList[x] print(alist)bubbleSort(alist)print(alist)

    Go语言

    package mainimport ("fmt")const (LENGTH=8){ func main() { var tmp intnumber:=[]int {95, 45, 15, 78, 84, 51, 24, 12} for i := 0; i < LENGTH; i++ { for j := LENGTH-1; j >i; j-- { if (number[j]<number[j-1]) { tmp=number[j-1] number[j-1]=number[j] number[j]=tmp } } } for i := 0; i < LENGTH; i++ { fmt.Printf("%d ", number[i]) } fmt.Printf(" "); }}

    GO语言2

    Gofunc BubbleSort(values[] int) { flag := true vLen := len(values) for i := 0; i < vLen-1; i++ { flag = true for j := 0; j < vLen-i-1; j++ { if values[j] > values[j+1] { values[j], values[j+1] = values[j+1], values[j] flag = false //continue } } if flag { break } }}

    Perl

    #! /usr/bin/perl -w use strict; my @list = (1,3,6,12,8);bubble_sort(@list, scalar @list);print "@list "; sub bubble_sort { my $arrays_ref = shift; my $num = shift; for (my $i = 0; $i < $num - 1; $i++) { for (my $j = 0; $j < $num - $i - 1; $j++) { if ($arrays_ref->[$j] > $arrays_ref->[$j+1]) { my $tmp = $arrays_ref->[$j]; $arrays_ref->[$j] = $arrays_ref->[$j+1]; $arrays_ref->[$j+1] = $tmp; } } }

    PASCAL

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    var
    a:array[1..4]ofinteger;
    i,j,temp,n:integer;
    begin
    read(n);
    fori:=1tondoread(a[i]);
    fori:=1tondo
    forj:=1ton-ido
    ifa[j]>a[j+1]then
    begin
    temp:=a[j];
    a[j]:=a[j+1];
    a[j+1]:=temp;
    end;
    fori:=1tondowrite(a[i]);
    end.

    Python

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    defbubble(bubbleList):
    listLength=len(bubbleList)
    whilelistLength>0:
    foriinrange(listLength-1):
    ifbubbleList[i]>bubbleList[i+1]:
    bubbleList[i]=bubbleList[i]+bubbleList[i+1]
    bubbleList[i+1]=bubbleList[i]-bubbleList[i+1]
    bubbleList[i]=bubbleList[i]-bubbleList[i+1]
    listLength-=1
    printbubbleList
    if__name__=='__main__':
    bubbleList=[3,4,1,2,5,8,0]
    bubble(bubbleList)
  • 相关阅读:
    node.js--express学习之路（三）
    node.js--express学习之路（二）
    node.js--express学习之路（一）
    js简单实现获取验证码倒计时
    HTML5新特性postMessage解决跨域
    跨域通信—JSONP
    前端跨域的那些事
    前后端通信—CORS（支持跨域）
    前后端通信—webSocket（支持跨域）
    JavaScript的运行机制
  • 原文地址：https://www.cnblogs.com/isoftware/p/3754055.html
Copyright © 2020-2023  润新知