众所周知，冒泡排序是比较简单并别比较经典的排序算法，时间复杂度为O(n2).他的原理就是相邻元素互相比较，如果前者比后者大，那么交换位置，然后进行下一步比较，第一轮之后，最大值就会跑到最后边去。

例如有如下一个数组。 {10,12,5,24,38,26,14,2}

10125243826142

第一次循环：

1.10和12比，不动；12和5比，交换位置

10512243826142

2.然后12和24比，不动；24和38比，不动；38和26比，交换位置

10512242638142

3.然后38和14比，交换位置

10512242614382

4.最后38和2比，交换位置

10512242614238

到这里，第一次冒泡就结束了，可以看到38是最大值，它已经跑到了最后，同理，进行

第2次（8-6）循环结果如下（26跑到了最后）：

10 512241422638

第3次(比较了8-3次)

10512142242638

第四次（比较了8-4次）

10512214242638

第五次（比较了8-5次）

10521214242638

第六次（比较了8-6次）

52101214242638

第七次（比较了8-7次）

25101214242638

第八次（不用循环了，只剩下最后一个值了，肯定是最小了）总共用了7次大循环，根据上图可以得出每次小循环的次数是总长度减去循环次数，因为之前最大值已经在最后，所以在比较就无意义。那么这个过程转换为代码如下。

.NET版本

//此段代码已经过 VS2012编程环境验证
 for (int i = 0; i < sortArr.Length - 1; i++) // 索引从 0 开始，所以长度减一
            {
                for (int j = 0; j < sortArr.Length - 1 - i; j++) //长度减一之后在减去i就是每次的小循环次数
                {
                   
                    if (sortArr[j] > sortArr[j + 1]) //如果大于就换位置
                    {
                        temp = sortArr[j];
                        sortArr[j] = sortArr[j + 1];
                        sortArr[j + 1] = temp;
                    }
                }
            }
//当然也有人这么写 就是第二个循环不减去 i，其实也正确，只不过效率不如上边的代码高一些，不减的话会做些无意义的比较。大循环 长度不减1同理

Objective-C版本(代码未验证，读者可自行实验，原理相通)

//核心代码 NSMutableArrar * sortArr
for (int i = 0; i < [sortArr count]; i++) // 索引从 0 开始，所以长度减一
            {
                for (int j = 0; j < [sortArr count] - 1 - i; j++) //长度减一之后在减去i就是每次的小循环次数
                {
                   
                       NSInteger a1 = [[sortArr objectAtIndex: j] intValue];
                       NSInteger a2 = [[sortArr objectAtIndex: j+1] intValue];
                       if(a1 > a2)
                       {
                           [sortArr exchangeObjectAtIndex:j withObjectAtIndex:j+1];
                       }
                }
            }


好了，到这里就是最基本的冒泡排序算法实现了，当然还有各种优化，面试过程中经常见到冒泡排序，你写出这段代码，基本上就算过了。（看面试官的心情啦~）