八大排序方法

---

1、插入排序 -直接插入排序   

从前向后依次记录x(>0)位置的元素,x 依次和前面的元素进行比较，大于x的元素后移一位，小于等于x时在其后插入x元素

效率：

时间复杂度：O（n^2）.

    NSMutableArray *originArr =[NSMutableArray arrayWithObjects:@1,@5,@3,@7,@9,@8,@2,@4,@6, nil];
    
    for (int i = 1; i<originArr.count; i++) {
        
        if (originArr[i]<originArr[i-1]) {//和i-1位置元素比较
            int cur = [originArr[i] intValue];
            int j = i-1;
            originArr[i] = originArr[i-1];
            //和i-1位置之前的元素进行比较
            while (cur<[originArr[j-1] intValue]&&j>0) {
                originArr[j] = originArr[j-1];//大于持有数字的元素向后移动一个位置
                j--;
            }
            originArr[j] =[NSNumber numberWithInt:cur];
        }
        NSString *arrStr = [originArr componentsJoinedByString:@","];
        NSLog(@"第%d次排序结果----%@",i,arrStr);
        
    }

打印信息：

2.插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

NSMutableArray *originArr =[NSMutableArray arrayWithObjects:@1,@5,@3,@7,@9,@8,@2,@4,@6, nil];
    
    int dk = (int)originArr.count/2;
    
    while (dk>=1) {
        for (int i = dk; i<originArr.count; i++) {
            
            if (originArr[i]<originArr[i-dk]) {//和i-1位置元素比较
                int cur = [originArr[i] intValue];
                int j = i-dk;
                originArr[i] = originArr[i-dk];
                //和i-1位置之前的元素进行比较
                while (j>dk&&cur<[originArr[j-dk] intValue]) {
                    originArr[j] = originArr[j-dk];//大于持有数字的元素向后移动一个位置
                    j-=dk;
                   
                }
                originArr[j] =[NSNumber numberWithInt:cur];
            }
            NSString *arrStr = [originArr componentsJoinedByString:@","];
            NSLog(@"排序序列号dk=%d i=%d 结果----%@",dk,i,arrStr);
        }
        
        dk = dk/2;
    }

打印结果：

3. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

 NSMutableArray *originArr =[NSMutableArray arrayWithObjects:@1,@5,@3,@7,@9,@8,@2,@4,@6, nil];
    
    for (int i =0; i<originArr.count; i++) {
        
        int min = i;
       
        for (int j = i+1;j<originArr.count ; j++) {
            if (originArr[min]>originArr[j]) {
                min = j;
            }
        }
        
        int mid = [originArr[i] intValue];
        originArr[i] = originArr[min];
        originArr[min] = [NSNumber numberWithInt:mid];
         NSString *arrStr = [originArr componentsJoinedByString:@","];
         NSLog(@"第%d次排序结果----%@",i,arrStr);
    }

打印结果：

 简单选择排序的改进——二元选择排序

简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：

NSMutableArray *originArr =[NSMutableArray arrayWithObjects:@1,@5,@3,@7,@9,@8,@2,@4,@6,@10, nil];
    
    for (int i =0; i<=originArr.count/2; i++) {
        
        int min = i;
        int max = (int)originArr.count-i-1;
        for (int j = i;j<originArr.count-i; j++) {
            
            if (originArr[max]<originArr[j]) {
                max = j;
            }
            
            if (originArr[min]>originArr[j]) {
                min = j;
            }
        }
        
        
        
        if (max==i) {//最大最小值出现交互替换的情况（i,originArr.count-i-1,max,min 四个元素交替换位置导致位置错乱）
        
            NSNumber *mid = originArr[min];
            
            originArr[min] = originArr[max];
            originArr[max] = mid;
            
            NSNumber *mid2 = originArr[min];
            
            originArr[min] = originArr[originArr.count-i-1];
            
            originArr[originArr.count-i-1] = mid2;
    
        }else{
        
        int midMin = [originArr[i] intValue];
        originArr[i] = originArr[min];
        originArr[min] = [NSNumber numberWithInt:midMin];
        
        
        int midMax = [originArr[originArr.count-i-1] intValue];
        originArr[originArr.count-i-1] = originArr[max];
        originArr[max] = [NSNumber numberWithInt:midMax];
        }
        
        NSString *arrStr = [originArr componentsJoinedByString:@","];
        NSLog(@"第%d次排序结果----%@",i,arrStr);
    }

打印结果：

冒泡排序

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

NSMutableArray *originArr =[NSMutableArray arrayWithObjects:@9,@5,@10,@7,@1,@8,@2,@4,@6,@3, nil];
    for (int i = 0; i<originArr.count; i++) {
        for (int j = 0; j<originArr.count-i-1; j++) {
            if (originArr[j]>originArr[j+1]) {
                NSNumber *tmp = originArr[j+1];
                originArr[j+1] = originArr[j];
                originArr[j] = tmp;
            }
        }
        NSString *arrStr = [originArr componentsJoinedByString:@","];
        NSLog(@"第%d次排序结果----%@",i+1,arrStr);
    }

打印结果：