Summary of common iOS algorithms and application knowledge points

#pragma mark - Objective-C
//Bubbling sort- (void)bubbleSort:(id)array{
  if (!([array isKindOfClass:[NSArray class]] || [array isKindOfClass:[NSMutableArray class]])) {
    NSLog(@"The passed parameter is not an array type");
    return;
  }
  NSMutableArray *tmpArr;
  if ([array isKindOfClass:[NSMutableArray class]]) {
    tmpArr = array;
  }else{
    tmpArr = [array mutableCopy];
  }
  for (int i = 0; i<; i++) {
    for (int j = 0; j <  -1; j++) {
      if ([tmpArr[j] compare:tmpArr[j+1]] == NSOrderedDescending) {
        [tmpArr exchangeObjectAtIndex:i withObjectAtIndex:j+1];
      }
    }
  }
  NSLog(@"The result of sorting is: %@/n",tmpArr);
}

#pragma mark - C
//Bubbling sortvoid bubble_sort(int arr[], const int size){
  for (int i = 0; i < size; i++) {
    for (int j = 0; j<size -1 ; j++) {
      if (arr[j] > arr[j+1]) {
        swap(arr[j], arr[j+1]);
      }
    }
  }
}

void swap(int i,int j){
  i = i + j;
  j = i - j;
  i = i - j;
}

/**
  Quick sort
  @param array Any type
  @param low The start position of the array to be sorted
  @param high End position of the array to be sorted
  */
- (void)quickSort:(NSMutableArray*)array low:(int)low high:(int)high{
  
  if (array == nil ||  == 0) {
    return;
  }
  if (low >= high) {
    return;
  }
  //Take the median value  int middle = low + (high - low)/2;
  NSNumber *prmt = array[middle];
  int i = low;
  int j = high;
  
   //Start sorting so that left<prmt and right>prmt  while (i &lt;= j) {
//    while ([array[i] compare:prmt] == NSOrderedAscending) {
//      i++;
//    }
    while ([array[i] intValue] &lt; [prmt intValue]) {
      i++;
    }
//    while ([array[j] compare:prmt] == NSOrderedDescending)
    while ([array[j] intValue] &gt; [prmt intValue]) {
      j--;
    }
    
    if(i &lt;= j){
      [array exchangeObjectAtIndex:i withObjectAtIndex:j];
      i++;
      j--;
    }
  }
  
  if (low &lt; j) {
    [self quickSort:array low:low high:j];
  }
  if (high &gt; i) {
    [self quickSort:array low:i high:high];
  }
}

//Quick sortint a[101],n;//Define global variables, these two variables need to be used in subfunctionsvoid quicksort(int left,int right)
{
  int i,j,t,temp;
  if(left&gt;right)
    return;
  
  temp=a[left]; //The reference number stored in temp is  i=left;
  j=right;
  while(i!=j){
    //The order is very important, you must start from the right first    while(a[j]&gt;=temp &amp;&amp; i&lt;j)
      j--;
    //Look for the one on the right    while(a[i]&lt;=temp &amp;&amp; i&lt;j)
      i++;
    //Swap the positions of two numbers in the array    if(i&lt;j){
      t=a[i];
      a[i]=a[j];
      a[j]=t;
    }
  }
  //Finally return the reference number to the position  a[left]=a[i];
  a[i]=temp;
  
  quicksort(left,i-1);//Continue to process the left, here is a recursive process  quicksort(i+1,right);//Continue to process the right side, here is a recursive process}

- (void)selectSort:(NSMutableArray *)array
{
  if(array == nil ||  == 0){
    return;
  }
  
  int min_index;
  for (int i = 0; i < ; i++) {
    min_index = i;
    for (int j = i + 1; j<; j++) {
      if ([array[j] compare:array[min_index]] == NSOrderedAscending) {
        [array exchangeObjectAtIndex:j withObjectAtIndex:min_index];
      }
    }
  }
}

- (void)inserSort:(NSMutableArray *)array
{
  if(array == nil ||  == 0){
    return;
  }
  
  for (int i = 0; i < ; i++) {
    NSNumber *temp = array[i];
    int j = i-1;
    
    while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
      [array replaceObjectAtIndex:j+1 withObject:array[j]];
      j--;
    }
    
    [array replaceObjectAtIndex:j+1 withObject:temp];
  }
}

//Hill sort, the initial dk value is /2- (void)ShellSort:(NSMutableArray *)array dk:(int)dk
{
  
  if(array == nil ||  == 0||dk>=){
    return;
  }
  
  for (int i = 0; i < ; i ++) {
    NSNumber *temp = array[i];
    int j = i - dk;
    
      //If the i-th element is greater than the i-1 element, insert it directly.  If it is less than, move the ordered table and insert it      while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
        [array replaceObjectAtIndex:j+dk withObject:array[j]];
        j-=dk;
      }
      [array replaceObjectAtIndex:j+dk withObject:temp];
    
  }
  
  while (dk>=1) {
    dk = dk/2;
    [self ShellSort:array dk:dk];
  }
}

+(NSData *)compressImage:(UIImage *)image toByte:(NSUInteger)maxLength
{
  // Compress by quality
  CGFloat compression = 1;
  NSData *data = UIImageJPEGRepresentation(image, compression);
  if ( < maxLength) return data;
  //Use dichotomy to improve performance  CGFloat max = 1;
  CGFloat min = 0;
  for (int i = 0; i < 6; ++i) {
    compression = (max + min) / 2;
    data = UIImageJPEGRepresentation(image, compression);
    if ( < maxLength * 0.9) {
      min = compression;
    } else if ( > maxLength) {
      max = compression;
    } else {
      break;
    }
  }
  UIImage *resultImage = [UIImage imageWithData:data];
  if ( < maxLength) return data;
  
  // Compress by size
  NSUInteger lastDataLength = 0;
  while ( > maxLength &&  != lastDataLength) {
    lastDataLength = ;
    CGFloat ratio = (CGFloat)maxLength / ;
    CGSize size = CGSizeMake((NSUInteger)( * sqrtf(ratio)),
                 (NSUInteger)( * sqrtf(ratio))); // Use NSUInteger to prevent white blank
    UIGraphicsBeginImageContext(size);
    [resultImage drawInRect:CGRectMake(0, 0, , )];
    resultImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    data = UIImageJPEGRepresentation(resultImage, compression);
  }
  
  return data;
}

+(NSData *)compressImage:(UIImage *)image
{
  NSData *data=UIImageJPEGRepresentation(image, 1.0);
  if (>300*1024) {
    
    if (>1024*1024) {//1M and above      
      data=UIImageJPEGRepresentation(image, 0.5);
      
    }else if (>300*1024) {//0.5M-1M
      
      data=UIImageJPEGRepresentation(image, 0.8);
      
    }
  }
  return data;
}