quick_sort & heap_sort

quick_sort 分析： 核心在于partition函数的实现，partition可以实现很好的分界，然后递归即可。

非递归，可以考虑用栈来或者queue来保存每次的边界，依次partition。

1. int partition(vector<int>&input,int st,int en) {
2. int i = st;
3. int j = en + 1;
4. int key = input[st];
5. while(i<j) {
6.   do{i++;}while(i<j && input[i]<key); //避免数组溢出，可以用边界隔离，或者在最后面加入一个最大值INT_MAX
7.   do{j--;}while(input[j]>key);
8.   if(i>=j) break;
9.   std::swap(input[i],input[j]);
10. }
11. std::swap(input[st],input[j]);
12. return j;
13. }
14. void quick_sort(vector<int> & input,int st,int en) {
15. if(st>=en) return;
16. int mid = partition(input,st,en);
17. quick_sort(input,st,mid-1);
18. quick_sort(input,mid+1,en);
19. }

heap_sort

1. #include <iostream>
2. #include <vector>
3. using namespace std;
4. void adjust_down(int *const &array,int pos,int len);//向前声明
5. // void adjust_down(int (&array)[6],int pos,int len)
6. void make_heap(int*const &array,int len);
7. void swap(int* const &array,int i,int j){//为了用临时变量的指针，必须让该指针为常量引用
8. int tmp = array[i];
9. array[i] = array[j];
10. array[j] = tmp;
11. }
12. void heap_sort(int* const &array,int len){
13. int real = len - 1;
14. make_heap(array,real);
15. for(int i=real;i>1;i--){
16. swap(array,i,1);
17. real--;
18. adjust_down(array,1,real);
19. }
20. }
21. void make_heap(int* const &array,int len){
22. for(int i=len/2;i>=1;i--){
23. adjust_down(array,i,len);
24. }
25. }
26. void adjust_down(int* const&array,int pos,int len){
27. while(2*pos<=len){
28. int min=0;
29. if(2*pos+1>len) min = 2*pos;
30. else {
31.   min = array[2*pos]>array[2*pos+1]?2*pos+1:2*pos;
32. }
33.   if(array[min]<array[pos]) {
34. swap(array,min,pos);
35. pos = min;
36. }else break;  //满足条件则终止
37. }
38. }
39. int main(){
40. int array[]={0,1,3,4,5,2};
41. heap_sort(array,6);  //把数组变成临时变量指针
42. for(int i=1;i<6;i++) cout<<array[i];
43. cout<<endl;
44. return 0;
45. }