将会使用C语言、ObjC和Swift分别来实现排序排序，并通过ObjC来举一个模型类选择排序的小例子，希望对大家在开发中应用算法有所帮助。
算法思想
选择排序的思想其实和冒泡排序有点类似，都是在一次排序后把最小的元素放到最前面。但是过程不同，冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。
算法思想：每一趟从前往后查找出值最小的索引（下标），最后通过比较是否需要交换。每一趟都将最小的元素交换到最前面。
举个例子：对5,3,8,6,4这个无序序列进行简单选择排序。
首先要选择5以外的最小数来和5交换，也就是选择3和5交换，一次排序后就变成了3,5,8,6,4。对剩下的序列依次进行选择和交换，最终就会得到一个有序序列。
其实选择排序可以看成是冒泡排序的优化，因为其目的相同，只是选择排序只有在确定了最小数的前提下才进行交换，大大减少了交换的次数，而比较次数是一样的。
注意：冒泡排序是从后往前扫，使大的往下沉，而小的往上浮；选择排序是从前往后扫，每趟找出值最小的索引，使每趟最小值都交换到该趟的最前面，从而得到升序序列。
其过程大概是这样的：
|
1
2
3
4
5
6
7
|
5, 3, 8, 6, 4（开始）
3, 5, 8, 6, 4（第一趟：将最小的3与5交换，使这一趟最小值3放到最前面）
3, 4, 8, 6, 5（第二趟：将最小的4与5交换，使这一趟最小值4放到最前面）
3, 4, 5, 6, 8（第三趟：将最小的5与8交换，使这一趟最小值5放到最前面）
3, 4, 5, 6, 8（第四趟：不需要交换，排序完成）
|
时间复杂度
选择排序可以看作冒泡排序的优化版本，一样要两层循环才能排序完成。
所以，选择排序的时间复杂度为O ( n2 )
伪代码
|
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
|
void selectSort(int arr[], int len) {
int min = 0;
// 只需要n-1趟即可，到最后一趟只有一个元素，一定是最小的了
for i = 0; i < len - 1; ++i {
// 每一趟的开始，假设该趟的第一个元素是最小的
min = i;
// 查找该趟有没有更小的，如果找到更小的，则更新最小值的下标
for j = i + 1; j < len; ++j {
if arr[j] < arr[min] {
min = j;
}
}
// 如果该趟的第一个元素不是最小的，说明需要交换
if min != i {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
|
C语言版
|
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
|
void selectSort(int arr[], int len) {
int min = 0;
// 只需要n-1趟
for (int i = 0; i < len - 1; ++i) {
min = i;
// 从第n+1趟起始找到末尾
for (int j = i + 1; j < len; ++j) {
// 找到比min位置更小的，就更新这一趟所找到的最小值的位置
if (arr[j] < arr[min]) {
min = j;
}
}
// 如果min与i不相等，说明有比i位置更小的，所以需要交换
if (min != i) {
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
|
ObjC版
|
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
|
- (void)selectSort:(int [])arr len:(int)len {
int min = 0;
// 只需要n-1趟
for (int i = 0; i < len - 1; ++i) {
min = i;
// 从第n+1趟起始找到末尾
for (int j = i + 1; j < len; ++j) {
// 找到比min位置更小的，就更新这一趟所找到的最小值的位置
if (arr[j] < arr[min]) {
min = j;
}
}
// 如果min与i不相等，说明有比i位置更小的，所以需要交换
if (min != i) {
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
|
Swift版
|
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
|
func selectSort(var arr: [Int]) ->[Int] {
var min = 0
// 只需要n-1趟
for var i = 0; i < arr.count - 1; ++i {
min = i
// 从第n+1趟起始找到末尾
for var j = i + 1; j < arr.count; ++j {
// 找到比min位置更小的，就更新这一趟所找到的最小值的位置
if arr[j] < arr[min] {
min = j
}
}
// 如果min与i不相等，说明有比i位置更小的，所以需要交换
if min != i {
let temp = arr[i]
arr[i] = arr[min]
arr[min] = temp
}
}
return arr
}
|
尝试ObjC实现模型选择排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
- (void)selectSort:(NSMutableArray *)array {
NSUInteger minIndex = 0;
for (NSUInteger i = 0; i < array.count - 1; ++i) {
minIndex = i;
for (NSUInteger j = i + 1; j < array.count; ++j) {
TestModel *modelj = [array objectAtIndex:j];
TestModel *model = [array objectAtIndex:minIndex];
// 比min下的还要小，则更新min
if ([modelj.uid compare:model.uid options:NSCaseInsensitiveSearch] == NSOrderedAscending) {
minIndex = j;
}
}
if (minIndex != i) {
[array exchangeObjectAtIndex:minIndex withObjectAtIndex:i];
}
}
}
|
测试：
|
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
|
NSMutableArray *array = [[NSMutableArray alloc] init];
for (NSUInteger i = 0; i < 10; ++i) {
TestModel *model = [[HYBTestModel alloc] init];
model.title = [NSString stringWithFormat:@"%ld", 10 - (i + 1)];
model.uid = [NSString stringWithFormat:@"%ld", 10 - (i + 1)];
[array addObject:model];
}
[self selectSort:array];
for (TestModel *model in array) {
NSLog(@"%@ %@", model.uid, model.title);
}
// 打印:
|