算法记录 : 基本排序

好几天没动编译器了，今天先练练手，下次给出Shell排序,堆排序和归并排序

    这几天心情还可以，不过有点不务正业，先给出一套基本的排序算法，下次给出一组复杂的排序算法，最后让他们来个火并

inline  void  exch(t_uint32  & a, t_uint32  & b) 
... { 
  t_uint32 tmp = a; 
  a = b; 
  b = tmp; 
}  
inline  bool  comp_exch(t_uint32  & a, t_uint32  & b) 
... { 
  if(b < a) 
  ...{ 
    exch(a,b); 
    return true; 
  }else 
  ...{ 
    return false; 
  } 
}  

inline  void  bleb_sort(t_uint32  * arr, size_t n) 
... { 
  size_t left = 0, right = n - 1; 
  for(size_t i = left; i < right; ++i) 
  ...{ 
    for(size_t j = right; j > left; --j) 
    ...{ 
      comp_exch(arr[j - 1], arr[j]); 
    } 
  } 
}  

    这个是选择排序,选择排序的运作是找出最小的一个，和最左面的交换，而后把剩下的数组当作一个新的来对待
    这个select的缺点是不依赖于数组内已经形成的顺序，所以比较操作不会少，但是优势是移动操作很少，因此在某些机器上也许会快一些

void  select_sort(t_uint32  * arr, size_t n) 
... { 
  for(size_t i = 0; i < n - 1; ++i) 
  ...{ 
    size_t min = i; 
     
    for(size_t j = i + 1; j < n; ++j) 
    ...{ 
      if(arr[j] < arr[min]) 
      ...{ 
        min = j; 
      } 
    } 
    exch(arr[i], arr[min]); 
     
  } 
}  

void  insertion_sort(t_uint32  * arr, size_t n) 
... { 
  for(size_t i = 1; i < n; ++i) 
  ...{ 
    for(size_t j = i; j > 0; --j) 
    ...{ 
      if(!comp_exch(arr[j - 1], arr[j])) break; 
    } 
  } 
}  

void  insertion_sort2(t_uint32  * arr, size_t n) 
... { 
  for(size_t j = n - 1; j > 0; --j) comp_exch(arr[j - 1], arr[j]);//先找出最小的元素，放到arr[0]做终结标记 
  for(size_t i = 2; i < n; ++i) 
  ...{ 
    size_t j = i; 
    t_uint32 tmp = arr[j];//先存一份copy 
     
    while(tmp < arr[j - 1])  //如果它小于前面那个有序序列中的最大一个 
    ...{ 
      arr[j] = arr[j - 1];  //那么前面那个有序序列中每个大于tmp的都要向后挪一个元素（因为最初的tmp被保存了，所以无所谓被覆盖) 
      j--; 
    } 
    arr[j] = tmp; 
  } 
}

 

    这是insertion的一个优化版本 
    这个是插入排序,可以认为先从最左面的元素开始，形成一个有序的序列，例如a[0]是有序的，而后第一次循环就j = i此时，i = 1, j 也等于1，所以第一次循环之后形成一个arr[0],arr[1]是有序的，而后 i = 2, j等于2，这里等于把arr[2]当作一个元素插入
前面有序的序列arr[0], arr[1]，此时这个序列所有比arr[2]大的元素都要向后移动一次,如果前面的比arr[2]小，则终止内圈循环
    冒泡实在没啥可说的，就是把最小的值移动到数组最最左边，然后把left加一当作一个新数组来对待（也是移动到最左边）
    这玩意存在的唯一意义可能就是便于实现而已，复杂度O(n^2)，是稳定排序