1.冒泡排序

wikipedia:

冒泡排序（英語：Bubble Sort）又稱為泡式排序，是一種簡單的排序算法。它重復(fù)地走訪過要排序的數(shù)列，一次比較兩個(gè)元素，如果它們的順序錯(cuò)誤就把它們交換過來。走訪數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個(gè)算法的名字由來是因?yàn)樵叫〉脑貢?huì)經(jīng)由交換慢慢“浮”到數(shù)列的頂端。

為什么介紹用“浮”呢？看它的動(dòng)圖應(yīng)該就可以理解了。

總結(jié)一下就是：比較相鄰的兩個(gè)元素然后交換這兩者，一直到一整個(gè)數(shù)列都按照順序排列。

2.冒泡排序的步驟

可以先看動(dòng)圖，如果動(dòng)圖就能夠理解的話，就不需要看下面的步驟了。

如果覺得動(dòng)圖太快，可以按照下面的步驟一步步理解。

第一次迭代

1. 從第一個(gè)下標(biāo)開始，也就是0，比較第一個(gè)和第二個(gè)元素。
2. 如果第一個(gè)元素比第二個(gè)元素大，那就交換兩者。
3. 然后比較第二個(gè)元素和第三個(gè)元素，如果兩者也不是升序，那交換兩者。
4. 一直比較和交換，直到最后。

之后的迭代

冒泡排序就是不斷重復(fù)迭代的過程，隨著不斷的交換，大的元素會(huì)和動(dòng)圖一樣交換到后面，小的元素則會(huì)換到前面。下圖是第二次迭代。

下圖是最后一次迭代，當(dāng)-2和-9交換后，這一整個(gè)數(shù)組的排序就完成了。

3.冒泡排序的實(shí)現(xiàn)

偽代碼

function bubble_sort (array, length) {
    var i, j;
    for(i from 0 to length-1){
        for(j from 0 to length-1-i){
            if (array[j] > array[j+1])
                swap(array[j], array[j+1])
        }
    }
}

助記碼

i∈[0,N-1)               //循環(huán)N-1遍
   j∈[0,N-1-i)           //每遍循環(huán)要處理的無序部分
     swap(j,j+1)          //兩兩排序（升序/降序）

Python

# Bubble sort in Python

def bubbleSort(array):
    
  # loop to access each array element
  for i in range(len(array)):

    # loop to compare array elements
    for j in range(0, len(array) - i - 1):

      # compare two adjacent elements
      # change > to < to sort in descending order
      if array[j] > array[j + 1]:

        # swapping elements if elements
        # are not in the intended order
        temp = array[j]
        array[j] = array[j+1]
        array[j+1] = temp


data = [-2, 45, 0, 11, -9]

bubbleSort(data)

print('Sorted Array in Ascending Order:')
print(data)

Java

// Bubble sort in Java

import java.util.Arrays;

class Main {

  // perform the bubble sort
  static void bubbleSort(int array[]) {
    int size = array.length;
    
    // loop to access each array element
    for (int i = 0; i < size - 1; i++)
    
      // loop to compare array elements
      for (int j = 0; j < size - i - 1; j++)

        // compare two adjacent elements
        // change > to < to sort in descending order
        if (array[j] > array[j + 1]) {

          // swapping occurs if elements
          // are not in the intended order
          int temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
        }
  }

  public static void main(String args[]) {
      
    int[] data = { -2, 45, 0, 11, -9 };
    
    // call method using class name
    Main.bubbleSort(data);
    
    System.out.println("Sorted Array in Ascending Order:");
    System.out.println(Arrays.toString(data));
  }
}

C

// Bubble sort in C

#include <stdio.h>

// perform the bubble sort
void bubbleSort(int array[], int size) {

  // loop to access each array element
  for (int step = 0; step < size - 1; ++step) {
      
    // loop to compare array elements
    for (int i = 0; i < size - step - 1; ++i) {
      
      // compare two adjacent elements
      // change > to < to sort in descending order
      if (array[i] > array[i + 1]) {
        
        // swapping occurs if elements
        // are not in the intended order
        int temp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = temp;
      }
    }
  }
}

// print array
void printArray(int array[], int size) {
  for (int i = 0; i < size; ++i) {
    printf("%d  ", array[i]);
  }
  printf("\n");
}

int main() {
  int data[] = {-2, 45, 0, 11, -9};
  
  // find the array's length
  int size = sizeof(data) / sizeof(data[0]);

  bubbleSort(data, size);
  
  printf("Sorted Array in Ascending Order:\n");
  printArray(data, size);
}

C++

// Bubble sort in C++

#include <iostream>
using namespace std;

// perform bubble sort
void bubbleSort(int array[], int size) {

  // loop to access each array element
  for (int step = 0; step < size; ++step) {
      
    // loop to compare array elements
    for (int i = 0; i < size - step; ++i) {

      // compare two adjacent elements
      // change > to < to sort in descending order
      if (array[i] > array[i + 1]) {

        // swapping elements if elements
        // are not in the intended order
        int temp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = temp;
      }
    }
  }
}

// print array
void printArray(int array[], int size) {
  for (int i = 0; i < size; ++i) {
    cout << "  " << array[i];
  }
  cout << "\n";
}

int main() {
  int data[] = {-2, 45, 0, 11, -9};
  
  // find array's length
  int size = sizeof(data) / sizeof(data[0]);
  
  bubbleSort(data, size);
  
  cout << "Sorted Array in Ascending Order:\n";  
  printArray(data, size);
}

4.冒泡排序的復(fù)雜度

平均復(fù)雜度的計(jì)算

所以，比較的次數(shù)是

(n-1) + (n-2) + (n-3) +.....+ 1 = n(n-1)/2

基本上等于$n^2$文章來源地址http://www.zghlxwxcb.cn/news/detail-418119.html

到了這里，關(guān)于排序算法之冒泡排序（圖解）的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！