冒泡排序算法(C#、Java、Python、JavaScript、C、C++实现)

一.介绍

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。

走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），

就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

二.原理

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

三.时间复杂度

 冒泡排序算法的时间复杂度是

C#代码实现

using System;

namespace BubbleSort
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { , , , ,  };
            foreach (var item in GetBubbleSort(arr))
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }

        static int[] GetBubbleSort(int[] arr)
        {
            int count = ;
            int temp = ;
            for (int i = ; i < arr.Length - ; i++)
            {
                for (int j = i + ; j < arr.Length; j++)
                {
                    if (arr[j] < arr[i])
                    {
                        temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                    }
                    count++;
                }
                count++;
            }

            Console.WriteLine(count);
            return arr;
        }
    }
}

 Java代码实现

package cn.lb.test;

public class BubbleSort {
    public static void main(String[] args){
        int[] arr={2,5,6,4,3};
        for (int item :getBubbleSort(arr))
       {
           System.out.println(item);
       }
    }

   public static int[] getBubbleSort(int[] arr)
    {
        int count=0;
        int temp=0;
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j =0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1])
                {
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
                count++;
            }
            count++;
        }
        return  arr;
    }
}

Python代码实现

def getBubbleSort(arr):
    for i in range(len(arr)-1,0,-1):
        for j in range(0,i):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]
    return arr
arr=[2,4,6,3,5]
arr=getBubbleSort(arr)
print(arr)

JavaScript代码实现

let getBubbleSort=(arr)=>{
    let temp=0;
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length-i-1; j++) {
             if (arr[j]<arr[j+1]) {
                 temp=arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
             }
        }
     }
  return arr;
}
let arr=[2,5,6,4,3];
 arr=getBubbleSort(arr);
arr.forEach(num=>{
  console.log(num);
});

C语言实现

#include <stdio.h>
int* getBubbleSort(int arr[], int len)
{
    int i, j, temp;
    for (i = ; i < len - ; i++)
    {
        for (j = ; j < len - i - ; j++)
        {
            if (arr[j] > arr[j + ])
            {
                temp = arr[j];
                arr[j] = arr[j + ];
                arr[j + ] = temp;
            }
        }
    }
    return arr;
}

int main() {
    int arr[] = { ,,,, };
    int len = (int)sizeof(arr) / sizeof(*arr);
    int* p = getBubbleSort(arr, len);
    int i;
    for (i = ; i < len; i++)
    {
        printf("%d", *(p + i));
    }
}

C++实现

#include <iostream>
using namespace std;

int* getBubbleSort(int arr[], int len)
{
    int i, j, temp;
    for (i = ; i < len - ; i++)
    {
        for (j = ; j < len - i - ; j++)
        {
            if (arr[j] > arr[j + ])
            {
                temp = arr[j];
                arr[j] = arr[j + ];
                arr[j + ] = temp;
            }
        }
    }
    return arr;
}

int main() {
    int arr[] = { ,,,, };
    int len = (int)sizeof(arr) / sizeof(*arr);
    int* p = getBubbleSort(arr, len);
    int i;
    for (i = ; i < len; i++)
    {
        cout<<("%d", *(p + i))<<endl;
    }
}