算法熟记-排序系列-快速排序

1. 简述

    假设待排序数组为 int array[], 数组长度为n。快速排序是一个递归得方法。
    当n==1的时候，停止排序。
    当n>1的时候，首先选择数组中得一个元素作为基准，然后，把小于这个基准得元素放到这个基准的左边，把大于这个基准得元素放到这个元素得右边。
    具体实现下面进行简单得说明，假设array[0]作为基准：
    首先，存储基准得值，int tmp=array[0];
    然后，两个指针，int left=0; int right = n-1;
    bool flag_left = false; // 初始从右边开始                                
    while(left < right) {
        if(flag_left == true) {
            如果当前值小于基准，则left++;
            否则，array[right]=array[left]; right--; flag_left = false;
        }       
        else {
             如果当前值大于基准，则right--;
             否则，array[left]=array[right]; left++; flag_left = true;

        }

    } 
    array[left] = tmp;
    上面这段代码中，当轮到left指针执行时，right指针向的位置是可以使用的。当轮到right指针执行时，left指针指向的位置是可以使用的。
    初始时，备份了array[0]，left指针指向的位置是可以使用 得，因此从右边开始。
    最后，递归排序array[0]-array[left-1]和array[left+1]-array[n-1]两个部分的数组。
2. 复杂度

    平均时间复杂度是O(N*logN)。当数组本身已经有序得情况下，需要比较得次数是N*N次。为了解决这样的问题，可以使用乱数快速排序，即每次基准是随即选择的。
    稳定性属于非稳定排序。因为在与基准的比较过程中的交换很可能打破已有的顺序。

3. 代码    

void quick_sort(int array[], int n) {
  if(n <= 1)
    return;
  int tmp = array[0];
  int left = 0; int right = n-1;
  bool left_flag = false;
  while(left < right) {
    if(left_flag == true) { // 当前left指针
      if(array[left] < tmp) {
        left++;
      }
      else {
        array[right] = array[left];
        right--;
        left_flag = false;
      }
    }
    else { // 当前right指针
      if(array[right] > tmp) {
        right--;
      }
      else {
        array[left] = array[right];
        left++;
        left_flag = true;
      }
    }
  } 
  array[left] = tmp;
  quick_sort(array, left); // array[0]-array[left-1]
  quick_sort(array+left+1, n-left-1); // array[left+1], array[n-1]
}

    实际上，快速排序是作为冒泡排序的改进提出来的，很多实现都是通过元素交换实现的，上面的代码是改进后的，更加有效率，把元素交换变成了元素的赋值。
    一般来说，交换排序包括：冒泡排序和快速排序。
    下面贴一个快速排序使用交换元素的实现：
   

void quicksort(int arr[],int beg,int end) {
  if (end  >= beg + 1) {
    int piv = arr[beg], k = beg + 1, r = end;

    // 从基准(array[0])右边的元素开始扫描，对于小于基准的元素跳过，对于大于基准的元素，交换到右边的位置上去,缩减右边的位置。

    // 当右边可以交换的位置与当前元素重叠了，结束循环
    while (k < r) {

      if (arr[k] < piv) 
        k++;
      else
        swap(&arr[k], &arr[r--]);
    }

    // 交换基准
    if (arr[k] < piv){ 

      swap(&arr[k],&arr[beg]);
      quicksort(arr, beg, k);
      quicksort(arr, r, end);                    
    }

    else {
      if (end - beg == 1)
      return;
      swap(&arr[--k],&arr[beg]);
      quicksort(arr, beg, k);
      quicksort(arr, r,   end);                  
    }

  }
}

4. 参考资料

    维基百科-快速排序    http://en.wikipedia.org/wiki/Quicksort