分治法

4 2

5 7 1 2

6 3 4 | 2 | 5 |

7 | 1 | 2 | 6 | 3

4 2

5 7 | 1 2

6 3 2 4 | 5

7 | 1 2 | 3 6

4 2 |

5 7 | 1 2 |

6 3 2 4 5

7 | 1 2 3 6

4 | 2 |

5 | 7 | 1 | 2 |

6 | 3 1 2 2 3 4 5 6 7

这种自底向上分治策略的编程模式如下：

如果问题规模足够小，直接求解，否则

单纯地分解原问题为规模更小的子问题，并持续这种分解；

执行求解动作，将子问题的解合并为原问题的解。

由于在自底向上的归并过程中，每一层需要进行i组n/i次比较，而且由于进行的是单纯的对称分解，总的层数总是lg n，因此，归并排序在各种情况下的时间代价都是Θ(n lg n)。试想，能够加大分组的力度，即每次将原问题分解为大于2的子问题，来降低运行时间？

归并排序算法的代码如下：

/*

* p: 左数组第一个元素下标

* q: 左数组最后一个元素下标

* r: 右数组最后一个元素下标

*/

void merge_no_sentinel(int *array, int p, int q, int r)

{

int n1, n2, i, j, k;

int *left=NULL, *right=NULL;

n1 = q-p+1;

n2 = r-q;

left = (int *)malloc(sizeof(int)*(n1)); right = (int *)malloc(sizeof(int)*(n2));

for(i=0; i

{

left[i] = array[p+i];

}

for(j=0; j

{

right[j] = array[q+1+j];

}

i = j = 0;

k = p;

while(i

{

if(left[i] <= right[j])

{

array[k++] = left[i++];

}

else

{

array[k++] = right[j++];

}

}

for(; i

{

array[k++] = left[i];

}

for(; j

{

array[k++] = right[j];

}

free(left);

free(right);

left = NULL;

right = NULL;

}

void merge_sort(int *array, int p, int r)

{

int q;

if(p < r)

{

q = (int)((p+r)/2);

merge_sort(array, p, q);

merge_sort(array, q+1, r);

merge_no_sentinel(array, p, q, r);

}

4 2

5 7 1 2

6 | 3

2 1 2 |

3 | 7

4

5 6

1 |

2 | 2 |

3 |

4

5 |

6 | 7

1 |

2 | 2 |

3 |

4 |

5 |

6 | 7

这种自顶向下分治策略的编程模式如下：

如果问题规模足够小，直接求解，否则

执行求解动作，将原问题分解为规模更小的子问题；

递归地求解每个子问题；

因为求解动作在分解之前进行，在对每个子问题求解之后，不需要合并过程。

快速排序的运行时间与分解是否对称有关，而后者又与选择了哪一个元素来进行划分有关。如果划分是对称的，则运行时间与归并排序相同，为Θ(n lg n)。如果每次分解都形成规模为n-1和0的两个子问题，快速排序的运行时间将变为Θ(n2)。快速排序的平均情况运行时间与其最佳情况相同，为Θ(n lg n)。

快速排序算法的代码如下：

void swap(int *a, int *b)

{

int temp;

temp = *a;

*a = *b;

*b = temp;

}

/*

* p: 数组第一个元素的下标

* r: 数组最后一个元素的下标

* 返回值为分组后主元的下标

*/

int partition(int *array, int p, int r)

{

int i, j, pivot;

pivot = array[r];

i = p-1;

for(j=p; j<=r-1; j++)

{

if(array[j] <= pivot)

{

i++;

swap(&array[i], &array[j]);

}

}

swap(&array[i+1], &array[r]);

return i+1;

}

void quick_sort(int *array, int p, int r)

{

int q;

if(p < r)

{

q = partition(array, p, r);

quick_sort(array, p, q-1);

quick_sort(array, q+1, r);

}

}

通常，我们可以向一个算法中加入随机化成分（参考第5章内容），以便对于所有输入，它均能获得较好

的平均情况性能。将这种方法用于快速排序时，不是始终采用A[r]作为主元，而是从子数组A[p..r]中随机

选择一个元素，即将A[r]与从A[p..r]中随机选出的一个元素交换。

#include

#include

int randomized_partition(int *array, int p, int r)

{

int i;

srand(time(NULL));

i = rand()%(r-p)+p;

swap(&array[i], &array[r]);

return partition(array, p, r);

}

void randomized_quick_sort(int *array, int p, int r)

{

int q;

if(p < r)

{

q = randomized_partition(array, p, r);

randomized_quick_sort(array, p, q-1);

randomized_quick_sort(array, q+1, r);

}

}