排序算法之冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法，冒泡排序的特点是调整相邻的两个对象的位置，每进行一次内循环，就可以将最大值调整到最后，这样下次就不需要考虑它了，冒泡排序的时间复杂度为O(N^2)，虽然时间上不占有优势，但是冒泡排序的代码简单，实现难度低。

实例分析：

以数组 arr = [5, 1, 4, 2, 8] 为例说明，加粗的数字表示每次循环要比较的两个数字：

第一次外循环

( 5 1 4 2 8 ) → ( 1 5 4 2 8 )， 5 > 1 交换位置
( 1 5 4 2 8 ) → ( 1 4 5 2 8 )， 5 > 4 交换位置
( 1 4 5 2 8 ) → ( 1 4 2 5 8 )， 5 > 2 交换位置
( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 5 < 8 位置不变

第二次外循环（除开最后一个元素8，对剩余的序列）

( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 1 < 4 位置不变
( 1 4 2 5 8 ) → ( 1 2 4 5 8 )， 4 > 2 交换位置
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )， 4 < 5 位置不变

第三次外循环（除开已经排序好的最后两个元素，可以注意到上面的数组其实已经排序完成，但是程序本身并不知道，所以还要进行后续的循环，直到剩余的序列为 1）

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

第四次外循环（最后一次）
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

 

 

Python实现：

 1 def bubble_sort(items):
 2     list_len = len(items) - 1
 3     if list_len <= 1:
 4         return items
 5     for index in range (0, list_len):
 6         for sub_index in range (0, list_len - index):
 7             if (items[sub_index] > items[sub_index + 1]):
 8                 items[sub_index], items[sub_index + 1] = items[sub_index + 1], items[sub_index]
 9     return items
10 lists = [10, 11, 3, 4, 8, 12, 6, 7, 1]
11 print('final:', bubble_sort(lists))

C++实现：

 1 #include<iostream>
 2 using namespace std;
 3 
 4 template <typename T>
 5 void my_swap (T &a, T &b) {
 6     T temp = a;
 7     a = b;
 8     b = temp;
 9 }
10 
11 template <typename T>
12 void bubble_sort(T arr[], int len) {
13     for (int i = 0; i < len - 1; ++i) {
14         for (int j = 0; j < len - 1 - i; ++j) {
15             if (arr[j] > arr[j + 1]) {
16                 my_swap(arr[j], arr[j + 1]);
17             }
18         }
19     }
20 }
21 
22 int main() {
23     int arr[] = {1, 0, 3, 56, 32, 2, 3, 100, 35};
24     int len = sizeof(arr) / sizeof(arr[0]);
25     bubble_sort(arr, len);
26     std::cout << "sort over:" << std::endl;
27     for (int i = 0; i < len; ++i) {
28         std::cout << arr[i] << std::endl;
29     }
30 }

 

转载于:https://www.cnblogs.com/LyndonYoung/articles/7868355.html