常用排序之冒泡排序法

       冒泡排序一般是重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成，冒泡排序是一种稳定排序。

原理

冒泡排序算法的运作如下：（从后往前）

     1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
     2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
     3.针对所有的元素重复以上的步骤，除了最后一个。

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

例子为从小到大排序：

----------------------------------------------------------

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

    第一次两两比较6 > 2交换(内循环)

        交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

        交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

    第二次两两比较,6 > 4交换

        交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

        交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

    第三次两两比较,6 > 1交换

        交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

        交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

    第四次两两比较,6 > 5交换

        交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

        交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

    第五次两两比较,6 < 9不交换

        交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

        交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

    第一次两两比较2 < 4不交换

        交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

        交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

    第二次两两比较,4 > 1交换

        交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
        交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

    第三次两两比较,4 < 5不交换

        交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
        交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

    第四次两两比较,5 < 6不交换

        交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

        交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

    第一次两两比较2 > 1交换

        交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

        交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    第二次两两比较,2 < 4不交换

        交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
        交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    第三次两两比较,4 < 5不交换

        交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
        交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    第四趟排序(外循环)无交换

    第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

----------------------------------------------------------

例如

void swap(int *left, int*right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}

void Bubble_sort(int a[], int n)
{
	int i, j, temp;
	for (i = 0; i < n - 1; i++) {
	    for (j = 0; j < n-i-1; j++) {
	        if (a[j] > a[j + 1])
		    swap(&a[j],&a[j+1]);
	    }
	}
}
int main()
{
	int b[] = { 9,8,19,4,6,2,3,7,4 };
	Bubble_sort(b, 9);
	for (auto c : b)
		cout << c << " ";
	system("pause");
}

时间复杂度分析

       若文件的初始状态是正序的，一趟扫描即可完成排序，此时为最好的时间复杂度O(n)；

       若初始文件是反序的，需要进行 n-1趟排序。每趟排序要进行n-i 次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：此时为最坏时间复杂度 O(n^2)；

       综上，因此冒泡排序总的平均时间复杂度为O(n^2)。