主流語言實現冒泡排序算法

什麼是冒泡排序

冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序算法。

它重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重複地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。

這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名“冒泡排序”。

下面主要講解幾種常用開發語言的冒泡排序的實現邏輯：

主流語言實現冒泡排序：

1.c語言之冒泡排序

#include <stdio.h>
 
#define ARR_LEN 255 /*數組長度上限*/
#define elemType int /*元素類型*/
 
/* 冒泡排序 */
/* 1. 從當前元素起，向後依次比較每一對相鄰元素，若逆序則交換 */
/* 2. 對所有元素均重複以上步驟，直至最後一個元素 */
/* elemType arr[]: 排序目標數組; int len: 元素個數 */
void bubbleSort (elemType arr[], int len) {
    elemType temp;
    int i, j;
    for (i=0; i<len-1; i++) /* 外循環爲排序趟數，len個數進行len-1趟 */
        for (j=0; j<len-1-i; j++) { /* 內循環爲每趟比較的次數，第i趟比較len-i次 */
            if (arr[j] > arr[j+1]) { /* 相鄰元素比較，若逆序則交換（升序爲左大於右，降序反之） */
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
}
 
int main (void) {
    elemType arr[ARR_LEN] = {3,5,1,-7,4,9,-6,8,10,4};
    int len = 10;
    int i;
     
    bubbleSort (arr, len);
    for (i=0; i<len; i++)
        printf ("%d\t", arr[i]);
    putchar ('\n');
     
    return 0;
}

2.c++之冒泡排序

#include <iostream>
using namespace std;
template<typename T>
//整數或浮點數皆可使用
void bubble_sort(T arr[], int len)
{
    int i, j;  T temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
        if (arr[j] > arr[j + 1])
        {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
}
int main()
{
    int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
 
    cout << endl;
 
    float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
    len = (int) sizeof(arrf) / sizeof(*arrf);
    bubble_sort(arrf, len);
    for (int i = 0; i < len; i++)
        cout << arrf[

3.c#之冒泡排序

namespace 數組排序
{
    class Program
    {
        static void Main(string[] args)
        {
            int temp = 0;
            int[] arr = {23, 44, 66, 76, 98, 11, 3, 9, 7};
            #region該段與排序無關
            Console.WriteLine("排序前的數組：");
            foreach (int item in arr)
            {
                Console.Write(item + "");
            }
            Console.WriteLine();
            #endregion
            for (int i = 0; i < arr.Length - 1; i++)
            {
                #region將大的數字移到數組的arr.Length-1-i
                for (int j = 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 (int item in arr)
            {
                Console.Write(item+"");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

4.Python3之冒泡排序

def bubble_sort(nums):
    for i in range(len(nums) - 1):  # 這個循環負責設置冒泡排序進行的次數
        for j in range(len(nums) - i - 1):  # j爲列表下標
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums
 
print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))
# 輸出：[8, 12, 19, 22, 32, 33, 45, 97]

5.Java之冒泡排序

public static void bubbleSort(int arr[]) {
 
        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]) {
                    int temp = arr[j];
                     
                    arr[j]=arr[j+1];
                     
                    arr[j+1]=temp;
            }
            }    
        }
    }

6.JavaScript之冒泡排序

function bubbleSort(arr) {
    var i = arr.length, j;
    var tempExchangVal;
    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--;
    }
    return arr;
}
 
var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
var arrSorted = bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);

7.kotlin之冒泡排序

fun bubbleSort(array: Array<Int>) { 
   val arrayLength = array.size    
   for (i in 0 until arrayLength) {        
       for (j in 0 until arrayLength - i - 1) {            
           if (array[j] > array[j + 1]) {                
               val temp = array[j]                
               array[j] = array[j + 1]                
               array[j + 1] = temp           
           }       
       }   
   }   
   // Prints result.
}

8.GO語音之冒泡排序

package main
 
import "fmt"
 
func bubble_sort(a []int){
    n := len(a)
    for i := 0; i < n - 1; i++ {
        for j := 0; j < n - 1 - i; j++ {
            if a[j] > a[j + 1]{
                a[j], a[j + 1] = a[j + 1], a[j]
            }
        }
    }
    
}
 
func print_arr(a []int){
    n := len(a)
    for i:= 0; i < n; i++ {
        fmt.Printf("%d ", a[i])
    }
    
    fmt.Printf("\n")
}
 
func main(){
    a := []int{4, 3, 1, 6, 2, 0, -1}
    print_arr(a)
    
    bubble_sort(a)
    print_arr(a)
}

9.GO語言第二種方式

func 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
        }
    }
}

總結：

算法原理其實很簡單，就是每次對相鄰的兩個元素進行比較，若前者大於後者則進行交換，如此一趟下來最後一趟的就是最大元素，重複以上的步驟，除了已經確定的元素。