常见面试排序： http://blog.csdn.net/pi9nc/article/details/12220851

快速排序：

选取第一个元素作为基准值：

1. /************************************************** 
2.  函数功能：对数组快速排序                        
3.  函数参数：指向整型数组arr的首指针arr；           
4.            整型变量left和right左右边界的下标    
5.  函数返回值：空                                   
6. /**************************************************/  
7. void QuickSort(int *arr, int left, int right)  
8. {  
9.  int i,j;  
10.  if(left<right)  
11.  {  
12.    i=left;j=right;  
13.    arr[0]=arr[i]; //准备以本次最左边的元素值为标准进行划分，先保存其值  
14.    do  
15.    {  
16.      while(arr[j]>arr[0] && i<j)   
17.        j--;        //从右向左找第1个小于标准值的位置j  
18.      if(i<j)                               //找到了，位置为j  
19.      {   
20.        arr[i] = arr[j];  
21.        i++;  
22.      }           //将第j个元素置于左端并重置i  
23.      while(arr[i]<arr[0] && i<j)  
24.        i++;      //从左向右找第1个大于标准值的位置i  
25.      if(i<j)                       //找到了，位置为i  
26.      {   
27.        arr[j] = arr[i];  
28.        j--;  
29.      }           //将第i个元素置于右端并重置j  
30.    }while(i!=j);  
31.    arr[i] = arr[0];         //将标准值放入它的最终位置,本次划分结束  
32.    quicksort(arr, left, i-1);     //对标准值左半部递归调用本函数  
33.    quicksort(arr, i+1, right);    //对标准值右半部递归调用本函数  
34.  }  
35. }  


随机选取基准值：
1. //使用引用，完成两数交换  
2. void Swap(int& a , int& b)  
3. {  
4. int temp = a;  
5. a = b;  
6. b = temp;  
7. }  
8. //取区间内随机数的函数  
9. int Rand(int low, int high)  
10. {  
11. int size = hgh - low + 1;  
12. return  low + rand()%size;   
13. }  
14.    //快排的partition算法，这里的基准数是随机选取的  
15. int RandPartition(int* data, int low , int high)  
16. {      
17. swap(data[rand(low,high)], data[low]);//  
18. int key = data[low];  
19. int i = low;  
20.   
21. for(int j=low+1; j<=high; j++)  
22. {  
23.  if(data[j]<=key)  
24.  {  
25.   i = i+1;  
26.   swap(data[i], data[j]);  
27.  }              
28. }   
29. swap(data[i],data[low]);  
30. return i;  
31. }  
32. //递归完成快速排序  
33. void QuickSort(int* data, int low, int high)  
34. {  
35. if(low<high)  
36. {  
37.  int k = RandPartition(data,low,high);  
38.  QuickSort(data,low,k-1);  
39.  QuickSort(data,k+1,high);  
40. }  
41. }  
有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在大写字母的前面(不要求保持原顺序)
        这题可能大家都能想到的方法是：设置首尾两个指针，首指针向后移动寻找大写字母，尾指针向前移动需找小写字母，找到后都停下，交换。之后继续移动，直至相遇。这种方法在这里我就不做讨论写代码了。
        但是这题也可以采用类似快排的partition。这里使用从左往后扫描的方式。字符串在调整的过程中可以分成两个部分：已排好的小写字母部分、待调整的剩余部分。用两个指针i和j，其中i指向待调整的剩余部分的第一个元素，用j指针遍历待调整的部分。当j指向一个小写字母时，交换i和j所指的元素。向前移动i、j，直到字符串末尾。代码如下：
[cpp] view plaincopy
1. #include <iostream>  
2. using namespace std;  
3. void Proc( char *str )  
4. {  
5. int i = 0;  
6. int j = 0;  
7. //移动指针i, 使其指向第一个大写字母  
8. while( str[i] != '\0' && str[i] >= 'a' && str[i] <= 'z' ) i++;  
9. if( str[i] != '\0' )  
10. {  
11. //指针j遍历未处理的部分，找到第一个小写字母  
12. for( j=i; str[j] != '\0'; j++ )  
13. {  
14. if( str[j] >= 'a' && str[j] <= 'z' )  
15. {  
16. char tmp = str[i];  
17. str[i] = str[j];  
18. str[j] = tmp;  
19. i++;  
20. }  
21. }  
22. }  
23. }  
24. int main()  
25. {  
26. char data[] = "SONGjianGoodBest";  
27. Proc( data );  
28. return 0;  
29. }