笔试算法题（55）：快速排序实现之非递归实现，最小k值选择（non-recursive version, Minimal Kth Selection of Quick Sort）

 1 struct MyStack {
 2         void push(int n);
 3         int pop();
 4         bool isEmpty();
 5 };
 6 
 7 void partition_5(int *array, int l, int r);
 8 
 9 void quickSort_5(int *array, int l, int r) {
10         /**
11          * 使用显示下推推展替代系统递归栈
12          * */
13         MyStack* stack=new MyStack();
14         /**
15          * 初始化堆栈
16          * */
17         stack->push(l);stack->push(r);
18 
19         int left, right, pivot;
20         while(!stack->isEmpty()) {
21                 /**
22                  * 从堆栈中获取序列段的端点
23                  * */
24                 right=stack->pop();left=stack->pop();
25 
26                 pivot=partition_5(array, left, right);
27                 /**
28                  * 如果当前序列段交叉，则跳过
29                  * */
30                 if(left>=right) continue;
31                 /**
32                  * 为了防止快速排序退化成线性处理，堆栈空间耗用
33                  * 也为线性，此处首先处理较小的序列，也就是将较
34                  * 长的子序列首先入栈，较小的子序列延后入栈；这样
35                  * 可以优先处理最小子序列，从而防止退化成线性空间
36                  * */
37                 if((pivot-left)<(right-pivot)) {
38                         stack->push(pivot+1);stack->push(right);
39                         stack->push(left);stack->push(pivot-1);
40                 } else {
41                         stack->push(left);stack->push(pivot-1);
42                         stack->push(pivot+1);stack->push(right);
43                 }
44         }
45 }
46 
47 int main() {
48         int array[]={2,5,8,2,1,6};
49         quickSort_5(array,0,5);
50         for(int i=0;i<6;i++)
51                 printf("%d,",array[i]);
52         return 1;
53 }

 1 int quickSelect_1(int *array, int l, int r, int k) {
 2         /**
 3          * 如果l和r交叉，则说明r-l+1小于k，没有第K小的元素
 4          * 返回-1表示失败；
 5          * */
 6         if(l>r) return -1;
 7         /**
 8          * 获取划分元素
 9          * */
10         int pivot=partition(array, l, r);
11         /**
12          * 注意k的大小是针对序列的排序值
13          * 而l，r和pivot的大小是在array中的索引值，
14          * 所以k需要经过转化才能与pivot进行比较
15          * */
16         if(pivot>k+l-1)
17                 return quickSelect_1(array, l, pivot-1, k);
18         else if(pivot<k+l-1)
19                 return quickSelect_1(array, pivot+1, r, k-(pivot-l+1));
20         else
21                 return array[pivot];
22 }
23 
24 int quickSelect_2(int *array, int l, int r, int k) {
25         int ltemp=l, rtemp=r;
26         int pivot;
27         while(ltemp<rtemp) {
28                 pivot=partition(array, ltemp, rtemp);
29                 if(pivot>k+l-1) {
30                         rtemp=pivot-1;
31                 } else if(pivot<k+l-1) {
32                         ltemp=pivot+1;
33                         k=k-(pivot-l+1);
34                 } else
35                         return array[pivot];
36         }
37         return -1;
38 }
39 
40 int main() {
41         int array[]={2,5,8,2,1,6};
42 
43         printf("%d\n",quickSelect_1(array,0,5,4));
44         return 1;
45 }