基础算法之 排序

文章目录
    一、选择排序
    二、冒泡排序
    三、快速排序
    四、二分法查找

一、选择排序
概念 ：每一趟从待排序的数据元素中选出最 ( 大/小 ) 值的一个元素，顺序放在已排好序的数列的最后或最前，直到全部待排序的数据元素排完。 如下图

下面演示java示意代码：

方案一 :

int [] arrays = {4,13,56,42,78,0};

for(int i = 0; i< arrays.length-1;i++)
{
    
   for(int j = i+1; j< arrays.length;j++)
   {
       if(arrays[i] > arrays[j])
       {
	      int temp = arrays[i];
	      arrays[i] = arrays[j];
	      arrays[j] = temp;			
	}
   }
			
			
}

方案二 :

int [] arrays = {4,13,56,42,78,0};

for(int i = 0; i< arrays.length-1;i++)
{
   int minIndex = i; 
   for(int j = i+1; j< arrays.length;j++) {
       if(arrays[i] > arrays[j]) {
	    minIndex = j;  	
	}
   }
   if(minIndex != i){
       int temp = arrays[i];
	   arrays[i] = arrays[minIndex];
	   arrays[minIndex] = temp;		
   }		
}

.
.
.

oc代码如下:

NSMutableArray *arrays = [NSMutableArray arrayWithArray:@[@31,@3,@8,@9]];
for (int i = 0; i < arrays.count-1; i++) {
     //默认最小位置是初始位置
     int minIndex = i;
     for (int j = minIndex+1; j < arrays.count; j++) {
                //记住最小角标
         if (arrays[minIndex] > arrays[j])  {
               minIndex = j;
                }
       }
        if (minIndex != i){
             [arrays exchangeObjectAtIndex:i withObjectAtIndex:minIndex];
         }
 }

注意 ： 数组的操作是在内存上，如果按照如上方案一去实现，频繁操作内存的话，是损耗性能的。

二、冒泡排序

冒泡排序 ： 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 θ(n^2)

如下图 ：

示意代码:

 - (NSMutableArray *)BubbleSortOC:(NSArray *)array
{
    
    id temp;
    
    int i, j;
    
    NSMutableArray *arr = [NSMutableArray arrayWithArray:array];
    
    for (i=0; i < [arr count] - 1; ++i) {
        for (j=0; j < [arr count] - i - 1; ++j) {
            if (arr[j] > arr[j+1]) {    // 升序排列
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr;
}

三、快速排序
快速排序是堆冒泡排序的一种改进，基本思想是选取一个记录作为枢纽，经过一趟排序，将整段序列分为两部分。其中一部分的值小于枢纽，另一部分值大于枢纽。然后继续对两部分继续进行排序，从而使整个序列达到有序。

左右指针法
1.选取一个关键字(key)作为枢纽,一般取整租记录的第一个或者最后一个。这里选取最后一个。
2.设置两个变量left=0，right = n-1
3. 从left之后往后走，直到找到大于key的值，right从后往前走，直到找到一个小于key的值，然后交换这两个数。
4. 重复第三步，一直往后找，直到left和right相遇，这时候将key放到left的位置即可。

- (void)quickSort:(NSArray*)arrays
{
  int left = 0;
 int right = arrays.cout-2;
 int key = array.lastObject;
 while(left < right){
   while(left<right && arrays[left] <= key){
      ++left;
   }
   while(left < right && arrays[right] >= key){
     --right;
   }
   swap(arrays[left],arrays[right]);
}
swap(key,arrays[left]);
}

四、二分法查找

当数据量很大适宜采用该方法。
采用二分法查找时，数据需是排好序的。
基本思想：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段 中查找；若x大于当前位置值则在数列的后半段中继续查找，直到找到为止。

- (NSInteger)BinarySearch:(NSArray *)array target:(id)key
{
    NSInteger left = 0;
    NSInteger right = [array count] - 1;
    NSInteger middle = [array count] / 2;
    while (right >= left) {
        middle = (right + left) / 2;
        if (array[middle] == key) {
            return middle;
        } 
        if (array[middle] > key) {
            right = middle - 1;
        }  else if (array[middle] < key) {
            left = middle + 1;
        } 
    }
    return -1;
}