ios排序算法
作者：互联网
1.冒泡排序 O(n2)
相邻的两个元素比较，如果第一个比第二个大，就交换，从第一个元素到倒数第二个
- (void)BubbleSort:(NSMutableArray *)array{
for (int i = 0; i<array.count; i++) {
for (int j = 0; j<array.count-1-i; j++) {
if ([array[j+1] integerValue]<[array[j] integerValue]) {
NSNumber *temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
2.选择排序 O(n2)
从循环找到最小的元素，与循环的起始位置交换
- (void)SelectionSort:(NSMutableArray *)array{
for (int i = 0; i<array.count; i++) {
int min = i;
for (int j=i; j<array.count; j++) {
if ([array[j] integerValue]<[array[min] integerValue]) {
min = j;
}
}
NSNumber *temp = array[min];
array[min] = array[i];
array[i] = temp;
}
}
3.插入排序 O(n2)
1.将后一个元素N(i+1)与之前的元素P(i)依次比较
2.如果N<P,将P后移，然后比较P的上一个元素P(i-1)，
3.重复2
4.将N插入到P(i-x)的位置，也就是移完元素以后空出的位置
- (void)InsertSort:(NSMutableArray *)array{
for (int i = 0; i<array.count-1; i++) {
NSNumber *currnt = array[i+1];
int pre = i;
while (pre>=0 && [currnt integerValue]< [array[pre] integerValue]) {
array[pre+1] = array[pre];
pre--;
}
array[pre+1] = currnt;
}
}
4.希尔排序 O(n logn)
其实是一个升级版的插入排序，区别是，插入排序是第二个元素开始(间隔为1)与前面的元素依次比较，循环作用是元素+1；而希尔排序是第length/2个元素开始，与前面的元素（间隔为length/2）比较，循环的作用是元素+1，并且length=length/2。
- (void)xier:(NSMutableArray *)array{
int len = (int)array.count;
int gap = (int)len/2;
while (gap>0) {
for (int i = gap; i<len; i++) {
int tmp = [array[i] intValue];;
int pre = i-gap;
while (pre>=0 && tmp < [array[pre] intValue]) {
array[pre+gap] = array[pre];
pre -= gap;
}
array[pre +gap] = @(tmp);
}
gap = gap/2;
}
}
5.快速排序 O(n logn)
可以理解为两头凑的插入排序。
1.记录一个元素i为基准数，最后一个元素j开始与基准数比较，遇到j比基准数小时，停止遍历，把i的值替换为j的值。
2.从i开始与基准数比较，遇到i比基准数大时，停止遍历，把j的值替换为i的值。此时i的位置值是空的，放入基准数。
3.递归把数组以i-1和i+1为分界线，前后分为2段，重复1、2。直到i(位置)>=j(位置)
- (void)quickSortArray:(NSMutableArray *)array withLeftIndex:(NSInteger)leftIndex andRightIndex:(NSInteger)rightIndex
{
if (leftIndex >= rightIndex) {
return;
}
NSInteger i = leftIndex;
NSInteger j = rightIndex;
NSInteger value = [array[leftIndex] integerValue];
while (i<j) {
while (i<j && [array[j] integerValue] >=value) {
j--;
}
array[i] = array[j];
while (i<j && [array[i] integerValue] <= value) {
i ++;
}
array[j] = array[i];
}
array[i] = @(value);
[self quickSortArray:array withLeftIndex:leftIndex andRightIndex:i-1];
[self quickSortArray:array withLeftIndex:i+1 andRightIndex:rightIndex];
}
6.归并排序 O(n logn)
可以理解为每个元素都是一个已排好的序列，两两排序后合并为一个序列，直到数组里面所有元素都合并为一个序列。
- (void)megerSortAscendingOrderSort:(NSMutableArray *)ascendingArr
{
NSMutableArray *tmpArr = [NSMutableArray arrayWithCapacity:1];
for (NSNumber *num in ascendingArr) {
NSMutableArray *oneArr = [NSMutableArray arrayWithObject:num];
[tmpArr addObject:oneArr];
}
while (tmpArr.count>1) {
NSInteger start = 0;
while (start < tmpArr.count-1) {
tmpArr[start] = [self mergeArrayFirstList:tmpArr[start] secondList:tmpArr[start +1]];
[tmpArr removeObjectAtIndex:start+1];
start ++;
}
}
ascendingArr = tmpArr[0];
}
- (NSArray *)mergeArrayFirstList:(NSArray *)array1 secondList:(NSArray *)array2 {
NSMutableArray *arr = [NSMutableArray arrayWithCapacity:0];
NSInteger leftIndex = 0,rightIndex = 0;
while (leftIndex<array1.count && rightIndex<array2.count) {
if ([array1[leftIndex] integerValue] < [array2[rightIndex] integerValue]) {
[arr addObject:array1[leftIndex]];
leftIndex ++;
}else{
[arr addObject:array2[rightIndex]];
rightIndex ++;
}
}
while (leftIndex<array1.count) {
[arr addObject:array1[leftIndex]];
leftIndex ++;
}
while (rightIndex<array2.count) {
[arr addObject:array2[rightIndex]];
rightIndex ++;
}
return arr;
}
标签：pre,tmpArr,元素,ios,gap,算法,array,排序,NSMutableArray 来源： https://blog.csdn.net/u010306571/article/details/95456418