优化的交换排序(冒泡排序)
Bubble Sort is a simple, stable, and in-place sorting algorithm. Due to its simplicity, it is widely used as a sorting algorithm by computer programmers.
气泡排序是一种简单，稳定且就地的排序算法。 由于其简单性，它被计算机程序员广泛用作排序算法。
The basic working principle of a simple bubble sort is that it repeatedly swaps the adjacent elements if they are in the wrong order. Hence, after every full iteration, the largest element reaches its position as in the sorted array.
简单冒泡排序的基本工作原理是，如果相邻元素的顺序错误，它将反复交换。 因此，在每次完整的迭代之后，最大元素将到达其在排序数组中的位置。
However, this simple bubble sort has time complexity O(n^2) in all cases because the inner loop runs even if the array is sorted. Therefore, we use an optimized version of bubble sort. This version uses a bool variable to check whether any swap took place in the previous iteration. If yes, only then the next iteration takes place. If no, then the loop breaks.
但是，这种简单的冒泡排序在所有情况下都具有时间复杂度O(n ^ 2) ，因为即使对数组进行排序，内部循环也会运行。 因此，我们使用冒泡排序的优化版本 。 此版本使用bool变量来检查在先前的迭代中是否发生了任何交换。 如果是，则仅进行下一次迭代。 如果否，则循环中断。
Pseudo-code:
伪代码：
1. for i: 0 to n-1 not inclusive do:
2. swapped = false
3. for j: 0 to n-i-1 not inclusive do:
4. If a[j] > a[j+1] then
5. swap a[j] and a[j+1]
6. swapped = true
7. end if
8. end for
9. if swapped == false then
10. break
11. end if
12. end for
Example:
例：
Input Array:
输入数组：
5 8 1 2 9
5 8 1 2 9
Here, I will run from 0 to 3
在这里，我将从0运行到3
Since, i < n-1 => i < 5-1 => i < 4
因为，我<n-1 =>我<5-1 =>我<4
Iteration 1 (i = 0):
迭代1(i = 0)：
For j = 0, (5 8 1 2 9) -> (5 8 1 2 9) No swaps because 5 < 8
For j = 1, (5 8 1 2 9) -> (5 1 8 2 9), swap because 1 < 8
For j = 2, (5 1 8 2 9) -> (5 1 2 8 9), swap because 2 < 8
For j = 3, (5 1 2 8 9) -> (5 1 2 8 9), no swap
对于j = 0，( 5 8 1 2 9)->( 5 8 1 2 9)没有交换因为5 <8
对于j = 1，(5 8 1 2 9)->(5 1 8 2 9)，交换是因为1 <8
对于j = 2，(5 1 8 2 9)->(5 1 2 8 9)，交换因为2 <8
对于j = 3，(5 1 2 8 9 )->(5 1 2 8 9 )，没有交换
1st Pass gives – 5 1 2 8 9
1 次通给出- 5 1 2 8 9
Iteration 2 (i = 1):
迭代2(i = 1)：
For j = 0, (5 1 2 8 9) -> (1 5 2 8 9) No swap because 1 < 5
For j = 1, (1 5 2 8 9) -> (1 2 5 8 9), swap because 2 < 5
For j = 2, (1 2 5 8 9) -> (1 2 5 8 9), no swap
对于j = 0，( 5 1 2 8 9 )->( 1 5 2 8 9 )由于1 <5而没有交换
对于j = 1，(1 5 2 8 9 )->(1 2 5 8 9 )，因为2 <5
对于j = 2，(1 2 5 8 9 )->(1 2 5 8 9 )，没有交换
2nd Pass gives – 1 2 5 8 9
第二遍给– 1 2 5 8 9
Iteration 3 (i = 2):
迭代3(i = 2)：
For j = 0, (1 2 5 8 9) -> (1 2 5 8 9), No swap because 1 < 2
For j = 1, (1 2 5 8 9) -> (1 2 5 8 9), No swap 2 < 5
对于j = 0，( 1 2 5 8 9 )->( 1 2 5 8 9 )，由于1 <2而没有交换
对于j = 1，(1 2 5 8 9 )->(1 2 5 8 9 )，无交换2 <5
3rd Pass gives – 1 2 5 8 9
第三张通过– 1 2 5 8 9
Here, the 4th iteration won't take place since the loop break because there was no swapping in the third iteration.
在这里，由于循环中断，因此第4 次迭代不会发生，因为在第3次迭代中没有交换。
Time Complexity: The time complexity of Binary Search can be described as: T(n) = T(n/2) + C
时间复杂度：二进制搜索的时间复杂度可描述为：T(n)= T(n / 2)+ C
Worst case: O(n^2)
最坏的情况：O(n ^ 2)
Average Case: O(n^2)
平均情况：O(n ^ 2)
Best case: O(n), if the array is already sorted
最佳情况：O(n)，如果数组已经排序
Space Complexity: O(1)
空间复杂度：O(1)
Optimized Bubble Sort Implementation:
优化的冒泡排序实现：
#include <stdio.h>
void swap(int* x, int* y)
{
int temp = *x;
*x = *y;
*y = temp;
}
void bubble_sort(int arr[], int n)
{
int i, j;
bool swapped;
for (i = 0; i < n - 1; i++) {
swapped = false;
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
swapped = true;
}
}
if (swapped == false)
break;
}
}
int main()
{
int arr[] = { 12, 46, 34, 82, 10, 9, 28 };
int n = sizeof(arr) / sizeof(arr[0]);
printf("\nInput Array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
bubble_sort(arr, n);
printf("\nSorted Array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
return 0;
}
Output:
输出：
Input Array:
12 46 34 82 10 9 28
Sorted Array:
9 10 12 28 34 46 82
翻译自: https://www.includehelp.com/c-programs/implement-optimized-bubble-sort.aspx
优化的交换排序(冒泡排序)
 论文解析)
)
