Repository navigation
Expand file tree
/
Copy pathbubble_sort.cpp
More file actions
255 lines (228 loc) · 8.54 KB
/
Copy pathbubble_sort.cpp
File metadata and controls
255 lines (228 loc) · 8.54 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
/**
* Copyright © https://github.com/microwind All rights reserved.
*
* @author: jarryli@gmail.com
* @version: 1.0
*/
#include <iostream>
#include <chrono>
#include <vector>
#include <iomanip>
using namespace std;
using namespace std::chrono;
/**
* 冒泡排序算法实现
* 提供四种不同的实现方式，适合不同场景和性能需求
*/
// 函数声明
void printArray(const vector<int>& arr, const string& label);
void performanceTest(void (*sortFunc)(vector<int>&), vector<int> arr, const string& name);
/**
* 冒泡排序基础版本 - 升序排列
*
* 算法原理：
* 1. 从数组左端开始，依次比较相邻元素
* 2. 若左元素大于右元素，则交换位置
* 3. 继续向后比较，直到数组末尾
* 4. 重复以上过程，每轮都会将当前未排序部分的最大值"冒泡"到最后
*
* 生活类比：就像水中的气泡，轻的气泡会自然上浮到水面
* 在排序中，大的数字会逐渐"上浮"到数组的右侧
*
* 时间复杂度：O(n²) - 需要比较 n*(n-1)/2 次
* 空间复杂度：O(1) - 只使用常数个额外变量
* 稳定性：稳定 - 相等元素的相对位置不会改变
*
* @param arr 待排序的整数数组
*/
void bubbleSort1(vector<int>& arr) {
cout << "bubbleSort1 from left to right:" << endl;
int len = arr.size();
// 外循环：控制排序轮数，每轮确定一个最大值的位置
for (int i = 0; i < len; i++) {
// 内循环：控制比较次数，len-i-1 避免重复比较已排序部分
for (int j = 0; j < len - i - 1; j++) {
// 关键点：自左往右每两个进行比较，把大的交换到右侧
if (arr[j] > arr[j + 1]) {
// C++特点：使用std::swap交换
swap(arr[j], arr[j + 1]);
}
}
}
printArray(arr, "基础升序版本排序结果");
}
/**
* 冒泡排序基础版本 - 降序排列
*
* 算法思路：
* 与升序版本相反，从数组末尾开始比较
* 每轮将当前未排序部分的最小值"下沉"到左侧
*
* 时间复杂度：O(n²) - 需要比较 n*(n-1)/2 次
* 空间复杂度：O(1) - 只使用常数个额外变量
* 稳定性：稳定 - 相等元素的相对位置不会改变
*
* @param arr 待排序的整数数组
*/
void bubbleSort2(vector<int>& arr) {
cout << "bubbleSort2 from right to left:" << endl;
int len = arr.size();
// 外循环：控制排序轮数，每轮确定一个最小值的位置
for (int i = 0; i < len; i++) {
// 内循环：从右向左比较，j > i 避免重复比较已排序部分
for (int j = len - 1; j > i; j--) {
// 关键点：自右往左每两个进行比较，把小的交换到右侧
if (arr[j - 1] < arr[j]) {
// C++特点：使用std::swap交换
swap(arr[j - 1], arr[j]);
}
}
}
printArray(arr, "基础降序版本排序结果");
}
/**
* 冒泡排序优化版本
*
* 优化思路：
* 增加一个标志位，记录某一轮是否发生了元素交换
* 如果某一轮没有发生任何交换，说明数组已经完全有序
* 此时可以提前终止排序过程，避免不必要的比较
*
* 优化效果：
* - 对于完全有序的数组：时间复杂度从 O(n²) 优化到 O(n)
* - 对于部分有序的数组：也会有明显的性能提升
* - 对于完全逆序的数组：性能与基础版本相同
*
* 时间复杂度：最好O(n)，最坏O(n²)，空间复杂度：O(1)
* 稳定性：稳定 - 相等元素的相对位置不会改变
*
* @param arr 待排序的整数数组
*/
void bubbleSort3(vector<int>& arr) {
cout << "bubbleSort3 add flag:" << endl;
// 优化点：增加一个标志，如果某一轮没有进行过任何的交换
// 则说明当前数组已排好序，则不必继续后面的遍历
int len = arr.size();
bool flag = true;
// 外循环：增加 flag 条件，当数组已有序时提前终止
for (int i = 0; i < len && flag == true; i++) {
flag = false; // 每轮开始时重置标志
// 内循环：控制比较次数，len-i-1 避免重复比较已排序部分
for (int j = 0; j < len - i - 1; j++) {
// 关键点：自左往右每两个进行比较，把大的交换到右侧
if (arr[j] > arr[j + 1]) {
flag = true; // 发生交换，设置标志
// C++特点：使用std::swap交换
swap(arr[j], arr[j + 1]);
}
}
}
printArray(arr, "优化版本排序结果");
}
/**
* 插入思想+交换排序，并非严格冒泡
*
* 算法思路：
* 将数组分为两部分：左侧已排序区域，右侧待排序区域
* 每次从待排序区域取出第一个元素，插入到已排序区域的正确位置
*
* 这种方法结合了插入排序的思想，在某些情况下性能更好
*
* 时间复杂度：O(n²)，空间复杂度：O(1)
* 稳定性：稳定 - 相等元素的相对位置不会改变
*
* @param arr 待排序的整数数组
*/
void bubbleSort4(vector<int>& arr) {
cout << "bubbleSort4:" << endl;
int len = arr.size();
// 外循环：控制排序轮数，i 从 1 开始，因为第 0 个元素默认为已排序
for (int i = 1; i < len; i++) {
// 内循环：在已排序区域中查找插入位置
for (int j = 0; j < i; j++) {
// 关键点：如果待插入元素小于已排序区域的某个元素，则交换
if (arr[j] > arr[i]) {
// C++特点：使用std::swap交换
swap(arr[i], arr[j]);
}
}
}
printArray(arr, "插入式版本排序结果");
}
/**
* 打印数组内容的辅助函数
* @param arr 要打印的数组
* @param label 数组的标签说明
*/
void printArray(const vector<int>& arr, const string& label) {
cout << label << ": [";
for (size_t i = 0; i < arr.size(); i++) {
cout << arr[i];
if (i < arr.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
}
/**
* 性能测试辅助函数
* @param sortFunc 排序函数
* @param arr 测试数组
* @param name 版本名称
*/
void performanceTest(void (*sortFunc)(vector<int>&), vector<int> arr, const string& name) {
printArray(arr, name + "原始数组");
auto start = high_resolution_clock::now();
sortFunc(arr);
auto end = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(end - start);
cout << name << ": " << fixed << setprecision(3) << duration.count() / 1000.0 << "ms" << endl;
cout << endl;
}
/**
* 主测试函数
*/
int main() {
cout << "=== 冒泡排序算法演示 ===" << endl;
cout << endl;
vector<int> testData = {7, 11, 9, 10, 12, 13, 8};
// 测试1：基础升序版本
performanceTest(bubbleSort1, testData, "基础升序版本");
// 测试2：基础降序版本
performanceTest(bubbleSort2, testData, "基础降序版本");
// 测试3：优化版本
performanceTest(bubbleSort3, testData, "优化版本");
// 测试4：插入式版本
performanceTest(bubbleSort4, testData, "插入式版本");
cout << "=== 算法对比总结 ===" << endl;
cout << "1. 基础版本：简单易懂，适合学习算法原理" << endl;
cout << "2. 降序版本：展示算法的灵活性，可按需排序" << endl;
cout << "3. 优化版本：通过标志位优化，适合实际应用" << endl;
cout << "4. 插入式版本：结合其他排序思想，性能更稳定" << endl;
return 0;
}
/* 打印结果
jarry@Mac bubblesort % g++ bubble_sort.cpp -o bubble_sort && ./bubble_sort
=== 冒泡排序算法演示 ===
基础升序版本原始数组: [7, 11, 9, 10, 12, 13, 8]
bubbleSort1 from left to right:
基础升序版本排序结果: [7, 8, 9, 10, 11, 12, 13]
基础升序版本: 0.xxxms
基础降序版本原始数组: [7, 11, 9, 10, 12, 13, 8]
bubbleSort2 from right to left:
基础降序版本排序结果: [13, 12, 11, 10, 9, 8, 7]
基础降序版本: 0.xxxms
优化版本原始数组: [7, 11, 9, 10, 12, 13, 8]
bubbleSort3 add flag:
优化版本排序结果: [7, 8, 9, 10, 11, 12, 13]
优化版本: 0.xxxms
插入式版本原始数组: [7, 11, 9, 10, 12, 13, 8]
bubbleSort4:
插入式版本排序结果: [7, 8, 9, 10, 11, 12, 13]
插入式版本: 0.xxxms
=== 算法对比总结 ===
1. 基础版本：简单易懂，适合学习算法原理
2. 降序版本：展示算法的灵活性，可按需排序
3. 优化版本：通过标志位优化，适合实际应用
4. 插入式版本：结合其他排序思想，性能更稳定
*/